`typescript
import { metadata, resize, toWebp } from 'imgkit';

const input = Buffer.from(await Bun.file('input.jpg').arrayBuffer());

// Get image info
const info = await metadata(input);
console.log(info); // { width: 1920, height: 1080, format: 'jpeg', ... }

// Create thumbnail
const thumb = await resize(input, { width: 200, height: 200, fit: 'Cover' });

// Convert to WebP
const webp = await toWebp(input, { quality: 85 });
await Bun.write('output.webp', webp);
`

`typescript
import { metadata, transform } from 'imgkit';

const heic = Buffer.from(await Bun.file('IMG_1234.HEIC').arrayBuffer());

// Check format
const info = await metadata(heic);
console.log(info.format); // 'heic'

// Convert to JPEG
const jpeg = await transform(heic, {
output: { format: 'Jpeg', jpeg: { quality: 90 } }
});
`

`typescript
import { writeExif, toWebp } from 'imgkit';

const webp = await toWebp(aiGeneratedImage, { quality: 90 });

const withMetadata = await writeExif(webp, {
imageDescription: 'A sunset over mountains',
artist: 'Stable Diffusion XL',
software: 'ComfyUI v1.0',
copyright: '© 2024 Your Name',
userComment: JSON.stringify({
prompt: 'sunset over mountains, golden hour, 8k',
seed: 12345,
steps: 30
})
});
`

`typescript
import { toTensor } from 'imgkit';

const buffer = Buffer.from(await Bun.file('photo.jpg').arrayBuffer());

// PyTorch/ONNX (CHW layout, ImageNet normalization)
const tensor = await toTensor(buffer, {
width: 224,
height: 224,
normalization: 'Imagenet', // ResNet, VGG, EfficientNet
layout: 'Chw', // Channel-first for PyTorch
batch: true // Add batch dimension
});

// Shape: [1, 3, 224, 224] - Ready for inference!
const float32Data = tensor.toFloat32Array();

// TensorFlow.js (HWC layout)
const tfTensor = await toTensor(buffer, {
width: 224, height: 224,
normalization: 'ZeroOne',
layout: 'Hwc'
});
`

Built-in normalizations: Imagenet, Clip, ZeroOne, NegOneOne

`typescript
import { imageHash, imageHashDistance } from 'imgkit';

// Generate perceptual hash
const hash1 = await imageHash(image1Buffer, { algorithm: 'PHash' });
const hash2 = await imageHash(image2Buffer, { algorithm: 'PHash' });

// Compare similarity (0 = identical, lower = more similar)
const distance = await imageHashDistance(hash1.hash, hash2.hash);

if (distance < 5) {
console.log('Images are very similar (likely duplicates)');
} else if (distance < 10) {
console.log('Images are somewhat similar');
} else {
console.log('Images are different');
}

// Available algorithms:
// - PHash: DCT-based, most robust (recommended)
// - DHash: Gradient-based, fast
// - AHash: Average-based, fastest
// - BlockHash: Block-based, balanced
`

Use cases: Duplicate detection, content moderation, reverse image search, near-match finding.

`typescript
import { thumbnail, thumbnailBuffer } from 'imgkit';

const buffer = Buffer.from(await Bun.file('photo.jpg').arrayBuffer());

// Generate thumbnail with metadata
const result = await thumbnail(buffer, {
width: 200,
format: 'Webp',
quality: 85,
});
console.log(${result.width}x${result.height});
console.log(Shrink-on-load: ${result.shrinkOnLoadUsed});

// Simple buffer-only API
const thumb = await thumbnailBuffer(buffer, { width: 200 });

// Fast mode for maximum speed (2x faster)
const fast = await thumbnailBuffer(buffer, {
width: 200,
fastMode: true,
});
`

Use cases: Image galleries, preview generation, CDN thumbnails, batch processing.

`typescript
import { smartCrop, smartCropAnalyze } from 'imgkit';

const buffer = Buffer.from(await Bun.file('photo.jpg').arrayBuffer());

// Smart crop to square (Instagram)
const square = await smartCrop(buffer, { aspectRatio: '1:1' });

// Smart crop to landscape (YouTube)
const youtube = await smartCrop(buffer, { aspectRatio: '16:9' });

// Smart crop to portrait (Stories/TikTok)
const portrait = await smartCrop(buffer, { aspectRatio: '9:16' });

// Analyze without cropping (get coordinates)
const analysis = await smartCropAnalyze(buffer, { aspectRatio: '1:1' });
console.log(Best crop at: ${analysis.x}, ${analysis.y});
console.log(Size: ${analysis.width}x${analysis.height});
console.log(Score: ${analysis.score});
`

Use cases: Social media thumbnails, profile pictures, e-commerce products, automatic galleries.

`typescript
import { resize, toWebp } from 'imgkit';

Bun.serve({
port: 3000,
async fetch(req) {
const url = new URL(req.url);

if (url.pathname === '/resize') {
const imageUrl = url.searchParams.get('url');
const width = parseInt(url.searchParams.get('w') || '400');

const response = await fetch(imageUrl!);
const buffer = Buffer.from(await response.arrayBuffer());

const resized = await resize(buffer, { width });
const webp = await toWebp(resized, { quality: 85 });

return new Response(webp, {
headers: { 'Content-Type': 'image/webp' }
});
}

return new Response('Not Found', { status: 404 });
}
});
`