safe-upload 0.0.0-stage → 0.1.0

package/dist/browser/objects.d.ts

@@ -0,0 +1,29 @@
+import { type Box } from './mediapipe.js';
+export interface DetectedObject extends Box {
+    /** COCO class name, e.g. "laptop", "car", "person". */
+    label: string;
+    score: number;
+}
+export interface ObjectDetectionOptions {
+    /** Folder holding MediaPipe's vision_wasm_internal.{js,wasm} (self-host it). */
+    wasmBaseUrl: string;
+    /** EfficientDet-Lite .tflite model (self-host it). */
+    modelAssetUrl: string;
+    /** Minimum confidence, 0..1. Default 0.35. */
+    minScore?: number;
+}
+/** Find everyday objects on-device (80 COCO classes). Coordinates are in the source's pixel space. */
+export declare function detectObjects(source: ImageBitmap | HTMLImageElement | HTMLCanvasElement, options: ObjectDetectionOptions): Promise<DetectedObject[]>;
+export type HintKind = 'screen' | 'document' | 'vehicle' | 'people' | 'home' | 'street' | 'travel' | 'time' | 'pet';
+export interface ObjectHint {
+    kind: HintKind;
+    /** e.g. "2 screens" */
+    title: string;
+    /** What it can give away, in plain words. */
+    hint: string;
+    /** True when hiding the area is a sensible suggestion. */
+    redactable: boolean;
+    objects: DetectedObject[];
+}
+/** Turn detected objects into privacy hints, most important first. */
+export declare function objectHints(objects: DetectedObject[]): ObjectHint[];

package/dist/browser/objects.js

@@ -0,0 +1,69 @@
+import { ctx2d, makeCanvas } from './canvas.js';
+import { clampBox } from './faces.js';
+import { containment, iou, loadVision, sizeOf, tiles } from './mediapipe.js';
+let cached;
+async function getDetector(o) {
+    const key = `${o.wasmBaseUrl}|${o.modelAssetUrl}|${o.minScore ?? 0.35}`;
+    if (cached?.key === key)
+        return cached.detector;
+    const detector = (async () => {
+        const { vision, fileset } = await loadVision(o.wasmBaseUrl);
+        return (await vision.ObjectDetector.createFromOptions(fileset, {
+            baseOptions: { modelAssetPath: o.modelAssetUrl, delegate: 'CPU' },
+            runningMode: 'IMAGE',
+            scoreThreshold: o.minScore ?? 0.35,
+            maxResults: 40,
+        }));
+    })();
+    cached = { key, detector };
+    detector.catch(() => (cached = undefined));
+    return detector;
+}
+/** Find everyday objects on-device (80 COCO classes). Coordinates are in the source's pixel space. */
+export async function detectObjects(source, options) {
+    const det = await getDetector(options);
+    const { W, H } = sizeOf(source);
+    const found = [];
+    for (const t of tiles(W, H)) {
+        const scale = Math.min(1, 1024 / Math.max(t.width, t.height));
+        const cw = Math.max(1, Math.round(t.width * scale));
+        const ch = Math.max(1, Math.round(t.height * scale));
+        const ctx = ctx2d(makeCanvas(cw, ch));
+        ctx.drawImage(source, t.x, t.y, t.width, t.height, 0, 0, cw, ch);
+        for (const d of det.detect(ctx.getImageData(0, 0, cw, ch)).detections) {
+            const bb = d.boundingBox;
+            const c = d.categories[0];
+            if (bb && c)
+                found.push({ label: c.categoryName, score: c.score, x: t.x + bb.originX / scale, y: t.y + bb.originY / scale, width: bb.width / scale, height: bb.height / scale });
+        }
+    }
+    found.sort((a, b) => b.score - a.score);
+    const kept = [];
+    for (const f of found)
+        if (!kept.some((k) => k.label === f.label && (iou(k, f) > 0.45 || containment(k, f) > 0.75)))
+            kept.push(f);
+    return kept.map((f) => clampBox(f, W, H));
+}
+/** Per-group confidence bars: lower where a miss is costly (screens, people), higher where false alarms are likely. */
+const GROUPS = [
+    { kind: 'screen', labels: ['laptop', 'tv', 'cell phone'], one: 'screen', many: 'screens', hint: 'Screens can show messages, emails, maps, names or an address. Zoom in and hide anything readable.', redactable: true, min: 0.45 },
+    { kind: 'document', labels: ['book'], one: 'book or printed page', many: 'books or printed pages', hint: 'Letters, labels and printed pages can carry names, addresses and account numbers.', redactable: true, min: 0.55 },
+    { kind: 'vehicle', labels: ['car', 'truck', 'bus', 'motorcycle'], one: 'vehicle', many: 'vehicles', hint: 'Number plates identify a vehicle and its owner, and their format gives away the country or state.', redactable: true, min: 0.45 },
+    { kind: 'people', labels: ['person'], one: 'person', many: 'people', hint: 'Faces are covered by the face scan, but tattoos, uniforms, name badges and school logos can still identify people.', redactable: false, min: 0.4 },
+    { kind: 'home', labels: ['bed', 'couch', 'dining table', 'toilet', 'refrigerator', 'oven', 'microwave', 'sink', 'potted plant'], one: 'household item', many: 'household items', hint: 'This looks like the inside of a home. Rooms and the view from a window are often enough to find an address.', redactable: false, min: 0.55 },
+    { kind: 'street', labels: ['stop sign', 'traffic light', 'fire hydrant', 'parking meter', 'bench'], one: 'street sign or fixture', many: 'street signs and fixtures', hint: 'Street signs and fixtures differ by country and city; together with buildings they can pin down the street.', redactable: false, min: 0.5 },
+    { kind: 'travel', labels: ['airplane', 'train', 'boat', 'suitcase'], one: 'travel item', many: 'travel items', hint: 'Travel scenes show that you are away from home.', redactable: false, min: 0.55 },
+    { kind: 'time', labels: ['clock'], one: 'clock', many: 'clocks', hint: 'A visible clock shows the time the photo was taken.', redactable: false, min: 0.55 },
+    { kind: 'pet', labels: ['dog', 'cat', 'bird', 'horse'], one: 'pet or animal', many: 'pets or animals', hint: "Pets' names are common password and security-question answers; avoid naming them in the caption.", redactable: false, min: 0.6 },
+];
+/** Turn detected objects into privacy hints, most important first. */
+export function objectHints(objects) {
+    const out = [];
+    for (const g of GROUPS) {
+        const objs = objects.filter((o) => g.labels.includes(o.label) && o.score >= g.min);
+        if (!objs.length)
+            continue;
+        out.push({ kind: g.kind, title: `${objs.length} ${objs.length === 1 ? g.one : g.many}`, hint: g.hint, redactable: g.redactable, objects: objs });
+    }
+    return out;
+}

package/dist/browser/redact.d.ts

@@ -0,0 +1,29 @@
+import type { Input, StripOptions } from '../types.js';
+import type { Box } from './mediapipe.js';
+export type RedactStyle = 'pixelate' | 'blur' | 'solid';
+export interface RedactOptions extends StripOptions {
+    style?: RedactStyle;
+    /** Output type. Defaults to JPEG, or PNG when the input is PNG. */
+    type?: 'image/jpeg' | 'image/png' | 'image/webp';
+    quality?: number;
+    /**
+     * Largest canvas area used at once. Bigger JPEG photos are processed in strips and encoded with
+     * @jsquash/jpeg (WASM), keeping full resolution. Default: 16,777,216, the iOS Safari limit.
+     */
+    maxCanvasPixels?: number;
+}
+export interface RedactResult {
+    blob: Blob;
+    width: number;
+    height: number;
+    /** The picture was processed in strips because it exceeds maxCanvasPixels. */
+    tiled: boolean;
+    /** The output is smaller than the original because the browser could not handle full size. */
+    downscaled: boolean;
+}
+/**
+ * Hide regions (faces, plates, screens) and re-encode the photo on-device. Kept EXIF categories
+ * are copied into the new file; everything else is gone. Region coordinates are in the upright
+ * picture's pixel space (as shown by an <img> element).
+ */
+export declare function redact(input: Input, regions: Box[], options?: RedactOptions): Promise<RedactResult>;

package/dist/browser/redact.js

@@ -0,0 +1,147 @@
+import { carryExif, toBytes } from '../api.js';
+import { ctx2d, decodeImage, encode, IOS_CANVAS_LIMIT, makeCanvas } from './canvas.js';
+function shape(ctx, b) {
+    ctx.beginPath();
+    const r = Math.min(b.width, b.height) * 0.3;
+    if ('roundRect' in ctx)
+        ctx.roundRect(b.x, b.y, b.width, b.height, r);
+    else
+        ctx.rect(b.x, b.y, b.width, b.height);
+}
+/** Hide one area of a canvas in place. */
+function applyRegion(ctx, canvas, b, style) {
+    const x = Math.floor(b.x);
+    const y = Math.floor(b.y);
+    const w = Math.max(1, Math.ceil(b.width));
+    const h = Math.max(1, Math.ceil(b.height));
+    ctx.save();
+    shape(ctx, { x, y, width: w, height: h });
+    ctx.clip();
+    if (style === 'solid') {
+        ctx.fillStyle = '#000';
+        ctx.fillRect(x, y, w, h);
+    }
+    else {
+        // Downscaling destroys detail irreversibly; upscale either blocky (pixelate) or smooth (blur).
+        const factor = style === 'pixelate' ? Math.max(8, Math.round(Math.max(w, h) / 7)) : Math.max(12, Math.round(Math.max(w, h) / 5));
+        const sw = Math.max(1, Math.round(w / factor));
+        const sh = Math.max(1, Math.round(h / factor));
+        const small = makeCanvas(sw, sh);
+        const sctx = ctx2d(small);
+        sctx.imageSmoothingEnabled = true;
+        sctx.drawImage(canvas, x, y, w, h, 0, 0, sw, sh);
+        ctx.imageSmoothingEnabled = style === 'blur';
+        if (style === 'blur')
+            ctx.imageSmoothingQuality = 'high';
+        ctx.drawImage(small, 0, 0, sw, sh, x, y, w, h);
+    }
+    ctx.restore();
+}
+/** Whole-picture path: one canvas. Used when the picture fits the canvas limit. */
+async function singleCanvas(img, regions, style, type, quality, scale = 1) {
+    const width = Math.max(1, Math.round(img.width * scale));
+    const height = Math.max(1, Math.round(img.height * scale));
+    const canvas = makeCanvas(width, height);
+    const ctx = ctx2d(canvas);
+    ctx.drawImage(img.source, 0, 0, width, height);
+    for (const r of regions)
+        applyRegion(ctx, canvas, { x: r.x * scale, y: r.y * scale, width: r.width * scale, height: r.height * scale }, style);
+    const blob = await encode(canvas, type, quality);
+    return { bytes: new Uint8Array(await blob.arrayBuffer()), width, height };
+}
+/**
+ * Strip path: render each hidden area once as a patch, then build the picture strip by strip
+ * (each strip within the canvas limit), copy the pixels into one buffer and encode with mozjpeg.
+ */
+async function strips(img, regions, style, quality, max) {
+    const { width: W, height: H } = img;
+    const { default: encodeJpeg } = await import('@jsquash/jpeg/encode');
+    const patches = regions.map((r) => {
+        const rx = Math.max(0, Math.floor(r.x));
+        const ry = Math.max(0, Math.floor(r.y));
+        const rw = Math.min(W - rx, Math.ceil(r.width));
+        const rh = Math.min(H - ry, Math.ceil(r.height));
+        const s = Math.min(1, Math.sqrt(max / Math.max(1, rw * rh)));
+        const pw = Math.max(1, Math.round(rw * s));
+        const ph = Math.max(1, Math.round(rh * s));
+        const canvas = makeCanvas(pw, ph);
+        const ctx = ctx2d(canvas);
+        ctx.drawImage(img.source, rx, ry, rw, rh, 0, 0, pw, ph);
+        applyRegion(ctx, canvas, { x: 0, y: 0, width: pw, height: ph }, style);
+        return { canvas, rx, ry, rw, rh, pw, ph };
+    });
+    const stripH = Math.max(1, Math.min(H, Math.floor(max / W)));
+    const data = new Uint8ClampedArray(W * H * 4);
+    let canvas = makeCanvas(W, stripH);
+    let ctx = ctx2d(canvas);
+    for (let y = 0; y < H; y += stripH) {
+        const h = Math.min(stripH, H - y);
+        if (h !== canvas.height) {
+            canvas = makeCanvas(W, h);
+            ctx = ctx2d(canvas);
+        }
+        ctx.clearRect(0, 0, W, h);
+        ctx.drawImage(img.source, 0, y, W, h, 0, 0, W, h);
+        for (const p of patches) {
+            if (p.ry >= y + h || p.ry + p.rh <= y)
+                continue;
+            ctx.imageSmoothingEnabled = true;
+            ctx.drawImage(p.canvas, 0, 0, p.pw, p.ph, p.rx, p.ry - y, p.rw, p.rh);
+        }
+        data.set(ctx.getImageData(0, 0, W, h).data, y * W * 4);
+    }
+    const out = await encodeJpeg({ data, width: W, height: H, colorSpace: 'srgb' }, { quality: Math.round(quality * 100) });
+    return { bytes: new Uint8Array(out), width: W, height: H };
+}
+/**
+ * Hide regions (faces, plates, screens) and re-encode the photo on-device. Kept EXIF categories
+ * are copied into the new file; everything else is gone. Region coordinates are in the upright
+ * picture's pixel space (as shown by an <img> element).
+ */
+export async function redact(input, regions, options = {}) {
+    const bytes = await toBytes(input);
+    const blobIn = input instanceof Blob ? input : new Blob([bytes]);
+    const img = await decodeImage(blobIn);
+    const style = options.style ?? 'pixelate';
+    const quality = options.quality ?? 0.92;
+    const isPng = bytes[0] === 0x89 && bytes[1] === 0x50;
+    const type = options.type ?? (isPng ? 'image/png' : 'image/jpeg');
+    const max = options.maxCanvasPixels ?? IOS_CANVAS_LIMIT;
+    let result;
+    let tiled = false;
+    let downscaled = false;
+    try {
+        if (img.width * img.height <= max) {
+            try {
+                result = await singleCanvas(img, regions, style, type, quality);
+            }
+            catch (err) {
+                if (type !== 'image/jpeg')
+                    throw err;
+                // The browser refused a canvas this size even though it is under the limit: use strips.
+                result = await strips(img, regions, style, quality, Math.min(max, IOS_CANVAS_LIMIT / 4));
+                tiled = true;
+            }
+        }
+        else if (type === 'image/jpeg') {
+            try {
+                result = await strips(img, regions, style, quality, max);
+                tiled = true;
+            }
+            catch {
+                // Encoder missing or out of memory: fall back to the largest picture the canvas allows.
+                result = await singleCanvas(img, regions, style, type, quality, Math.sqrt(max / (img.width * img.height)) * 0.999);
+                downscaled = true;
+            }
+        }
+        else {
+            result = await singleCanvas(img, regions, style, type, quality, Math.sqrt(max / (img.width * img.height)) * 0.999);
+            downscaled = true;
+        }
+    }
+    finally {
+        img.close();
+    }
+    const merged = type === 'image/webp' ? result.bytes : await carryExif(bytes, result.bytes, { remove: options.remove, width: result.width, height: result.height });
+    return { blob: new Blob([merged], { type }), width: result.width, height: result.height, tiled, downscaled };
+}

package/dist/bytes.d.ts

@@ -0,0 +1,22 @@
+/** Small byte helpers shared by every format parser. No platform APIs beyond TextDecoder. */
+export declare function u16be(b: Uint8Array, o: number): number;
+export declare function u32be(b: Uint8Array, o: number): number;
+export declare function u16le(b: Uint8Array, o: number): number;
+export declare function u32le(b: Uint8Array, o: number): number;
+export declare function u64be(b: Uint8Array, o: number): number;
+export declare function putU16be(b: Uint8Array, o: number, v: number): void;
+export declare function putU32be(b: Uint8Array, o: number, v: number): void;
+export declare function putU32le(b: Uint8Array, o: number, v: number): void;
+/** Latin-1 decode; safe for 4CCs, marker identifiers and ASCII tag values. */
+export declare function latin1(b: Uint8Array, start?: number, end?: number): string;
+export declare function utf8(b: Uint8Array): string;
+export declare function encodeAscii(s: string): Uint8Array;
+export declare function startsWith(b: Uint8Array, offset: number, ascii: string): boolean;
+export declare function indexOfAscii(b: Uint8Array, ascii: string, from?: number, to?: number): number;
+export declare function concat(parts: Uint8Array[]): Uint8Array;
+/** Trim trailing NULs and whitespace from a decoded string. */
+export declare function clean(s: string): string;
+export declare function crc32(b: Uint8Array, start?: number, end?: number): number;
+/** zlib inflate via the Compression Streams API (browsers, workers, Node >= 18, Deno, Bun). */
+export declare function inflate(data: Uint8Array): Promise<Uint8Array>;
+export declare function toHex(n: number, width?: number): string;

package/dist/bytes.js

@@ -0,0 +1,109 @@
+/** Small byte helpers shared by every format parser. No platform APIs beyond TextDecoder. */
+export function u16be(b, o) {
+    return (b[o] << 8) | b[o + 1];
+}
+export function u32be(b, o) {
+    return ((b[o] << 24) | (b[o + 1] << 16) | (b[o + 2] << 8) | b[o + 3]) >>> 0;
+}
+export function u16le(b, o) {
+    return b[o] | (b[o + 1] << 8);
+}
+export function u32le(b, o) {
+    return (b[o] | (b[o + 1] << 8) | (b[o + 2] << 16) | (b[o + 3] << 24)) >>> 0;
+}
+export function u64be(b, o) {
+    return u32be(b, o) * 0x1_0000_0000 + u32be(b, o + 4);
+}
+export function putU16be(b, o, v) {
+    b[o] = (v >>> 8) & 0xff;
+    b[o + 1] = v & 0xff;
+}
+export function putU32be(b, o, v) {
+    b[o] = (v >>> 24) & 0xff;
+    b[o + 1] = (v >>> 16) & 0xff;
+    b[o + 2] = (v >>> 8) & 0xff;
+    b[o + 3] = v & 0xff;
+}
+export function putU32le(b, o, v) {
+    b[o] = v & 0xff;
+    b[o + 1] = (v >>> 8) & 0xff;
+    b[o + 2] = (v >>> 16) & 0xff;
+    b[o + 3] = (v >>> 24) & 0xff;
+}
+/** Latin-1 decode; safe for 4CCs, marker identifiers and ASCII tag values. */
+export function latin1(b, start = 0, end = b.length) {
+    let s = '';
+    for (let i = start; i < end; i++)
+        s += String.fromCharCode(b[i]);
+    return s;
+}
+const utf8Decoder = new TextDecoder('utf-8', { fatal: false });
+export function utf8(b) {
+    return utf8Decoder.decode(b);
+}
+export function encodeAscii(s) {
+    const out = new Uint8Array(s.length);
+    for (let i = 0; i < s.length; i++)
+        out[i] = s.charCodeAt(i) & 0xff;
+    return out;
+}
+export function startsWith(b, offset, ascii) {
+    if (offset < 0 || offset + ascii.length > b.length)
+        return false;
+    for (let i = 0; i < ascii.length; i++)
+        if (b[offset + i] !== ascii.charCodeAt(i))
+            return false;
+    return true;
+}
+export function indexOfAscii(b, ascii, from = 0, to = b.length) {
+    const first = ascii.charCodeAt(0);
+    const last = Math.min(to, b.length) - ascii.length;
+    for (let i = from; i <= last; i++) {
+        if (b[i] === first && startsWith(b, i, ascii))
+            return i;
+    }
+    return -1;
+}
+export function concat(parts) {
+    let len = 0;
+    for (const p of parts)
+        len += p.length;
+    const out = new Uint8Array(len);
+    let o = 0;
+    for (const p of parts) {
+        out.set(p, o);
+        o += p.length;
+    }
+    return out;
+}
+/** Trim trailing NULs and whitespace from a decoded string. */
+export function clean(s) {
+    return s.replace(/[\u0000\s]+$/u, '').replace(/^\s+/u, '');
+}
+let crcTable;
+export function crc32(b, start = 0, end = b.length) {
+    if (!crcTable) {
+        crcTable = new Uint32Array(256);
+        for (let n = 0; n < 256; n++) {
+            let c = n;
+            for (let k = 0; k < 8; k++)
+                c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+            crcTable[n] = c >>> 0;
+        }
+    }
+    let c = 0xffffffff;
+    for (let i = start; i < end; i++)
+        c = crcTable[(c ^ b[i]) & 0xff] ^ (c >>> 8);
+    return (c ^ 0xffffffff) >>> 0;
+}
+/** zlib inflate via the Compression Streams API (browsers, workers, Node >= 18, Deno, Bun). */
+export async function inflate(data) {
+    const DS = globalThis.DecompressionStream;
+    if (!DS)
+        throw new Error('DecompressionStream is not available in this runtime');
+    const stream = new Blob([data]).stream().pipeThrough(new DS('deflate'));
+    return new Uint8Array(await new Response(stream).arrayBuffer());
+}
+export function toHex(n, width = 4) {
+    return '0x' + n.toString(16).toUpperCase().padStart(width, '0');
+}

package/dist/categories.d.ts

@@ -0,0 +1,13 @@
+import type { Category, Risk } from './types.js';
+export interface CategoryInfo {
+    label: string;
+    risk: Risk;
+    description: string;
+    defaultRemove: boolean;
+}
+/** Display order, most revealing first. */
+export declare const CATEGORY_ORDER: Category[];
+export declare const CATEGORY_INFO: Record<Category, CategoryInfo>;
+export declare const DEFAULT_REMOVE: Category[];
+export declare function resolveRemove(remove: Category[] | 'all' | undefined): Set<Category>;
+export declare function sortCategories(set: Iterable<Category>): Category[];

package/dist/categories.js

@@ -0,0 +1,113 @@
+/** Display order, most revealing first. */
+export const CATEGORY_ORDER = [
+    'location',
+    'people',
+    'hidden',
+    'thumbnail',
+    'author',
+    'device',
+    'time',
+    'ai',
+    'descriptions',
+    'history',
+    'software',
+    'other',
+    'provenance',
+    'settings',
+];
+export const CATEGORY_INFO = {
+    location: {
+        label: 'Location',
+        risk: 'high',
+        description: 'GPS coordinates and place names of where the photo was taken.',
+        defaultRemove: true,
+    },
+    people: {
+        label: 'Named people',
+        risk: 'high',
+        description: 'Names of people tagged in the photo by photo apps.',
+        defaultRemove: true,
+    },
+    hidden: {
+        label: 'Hidden extra media',
+        risk: 'high',
+        description: 'Extra pictures or video stored after the main image, such as motion-photo clips, depth maps and HDR gain maps.',
+        defaultRemove: true,
+    },
+    thumbnail: {
+        label: 'Embedded preview',
+        risk: 'high',
+        description: 'A small copy of the picture stored inside the file. After cropping or editing it can still show the original.',
+        defaultRemove: true,
+    },
+    author: {
+        label: 'Names & copyright',
+        risk: 'high',
+        description: 'Owner, artist or photographer names, copyright notices and contact details.',
+        defaultRemove: true,
+    },
+    device: {
+        label: 'Camera & device',
+        risk: 'medium',
+        description: 'Phone or camera make and model, lens, and serial numbers that link photos to one device.',
+        defaultRemove: true,
+    },
+    time: {
+        label: 'Date & time',
+        risk: 'medium',
+        description: 'When the photo was taken or edited, including your time zone.',
+        defaultRemove: true,
+    },
+    ai: {
+        label: 'AI generation data',
+        risk: 'medium',
+        description: 'Prompts, settings and workflows saved by image generators.',
+        defaultRemove: true,
+    },
+    descriptions: {
+        label: 'Titles & comments',
+        risk: 'medium',
+        description: 'Captions, keywords, titles, ratings and comments written into the file.',
+        defaultRemove: true,
+    },
+    history: {
+        label: 'Edit history',
+        risk: 'medium',
+        description: 'Editing steps, editor settings and IDs of the documents this image was made from.',
+        defaultRemove: true,
+    },
+    software: {
+        label: 'Software',
+        risk: 'low',
+        description: 'Apps and versions used to create or edit the photo.',
+        defaultRemove: true,
+    },
+    other: {
+        label: 'Other metadata',
+        risk: 'low',
+        description: 'Vendor-specific or unrecognised metadata blocks.',
+        defaultRemove: true,
+    },
+    provenance: {
+        label: 'Content credentials',
+        risk: 'low',
+        description: 'C2PA provenance data describing how the image was made. Removing it is allowed but breaks verification.',
+        defaultRemove: false,
+    },
+    settings: {
+        label: 'Camera settings',
+        risk: 'low',
+        description: 'Exposure, aperture, ISO and focal length. Rarely sensitive.',
+        defaultRemove: false,
+    },
+};
+export const DEFAULT_REMOVE = CATEGORY_ORDER.filter((c) => CATEGORY_INFO[c].defaultRemove);
+export function resolveRemove(remove) {
+    if (remove === 'all')
+        return new Set(CATEGORY_ORDER);
+    return new Set(remove ?? DEFAULT_REMOVE);
+}
+export function sortCategories(set) {
+    const s = new Set(set);
+    return CATEGORY_ORDER.filter((c) => s.has(c));
+}

package/dist/collect.d.ts

@@ -0,0 +1,16 @@
+import { type Tiff } from './exif.js';
+import type { Category, Finding, Format, HiddenMedia, Report, Source } from './types.js';
+/** Accumulates findings from every metadata block of one file into a Report. */
+export declare class Collector {
+    findings: Finding[];
+    report: Report;
+    constructor(format: Format, mime: string, size: number);
+    add(f: Finding): void;
+    note(s: string): void;
+    hidden(h: HiddenMedia): void;
+    tiff(bytes: Uint8Array, source: Source, removable?: boolean): Tiff | null;
+    xmp(bytes: Uint8Array | string, source: Source, removable?: boolean): Set<Category>;
+    irb(bytes: Uint8Array, source: Source, removable?: boolean): Set<Category>;
+    finish(): Report;
+}
+export declare function categoriesOf(findings: Finding[]): Set<Category>;

package/dist/collect.js

@@ -0,0 +1,108 @@
+import { utf8 } from './bytes.js';
+import { sortCategories } from './categories.js';
+import { analyzeTiff, parseTiff } from './exif.js';
+import { analyzeIrb } from './iptc.js';
+import { analyzeXmp, xmpFindings } from './xmp.js';
+/** Accumulates findings from every metadata block of one file into a Report. */
+export class Collector {
+    findings = [];
+    report;
+    constructor(format, mime, size) {
+        this.report = {
+            format,
+            mime,
+            size,
+            findings: this.findings,
+            categories: [],
+            summary: { serialNumbers: [], people: [], names: [], software: [] },
+            thumbnails: [],
+            hidden: [],
+            notes: [],
+        };
+    }
+    add(f) {
+        this.findings.push(f);
+    }
+    note(s) {
+        if (!this.report.notes.includes(s))
+            this.report.notes.push(s);
+    }
+    hidden(h) {
+        this.report.hidden.push(h);
+    }
+    tiff(bytes, source, removable = true) {
+        const tiff = parseTiff(bytes);
+        if (!tiff) {
+            this.add({ category: 'other', source, key: 'exif.unreadable', label: 'Unreadable EXIF block', value: `${bytes.length} bytes`, removable });
+            return null;
+        }
+        const a = analyzeTiff(tiff, source, removable);
+        this.findings.push(...a.findings);
+        const s = this.report.summary;
+        if (a.gps && !s.gps)
+            s.gps = a.gps;
+        if (a.capturedAt && !s.capturedAt)
+            s.capturedAt = a.capturedAt;
+        if (a.timeZone && !s.timeZone)
+            s.timeZone = a.timeZone;
+        if (a.device && !s.device)
+            s.device = a.device;
+        s.serialNumbers.push(...a.serialNumbers);
+        s.names.push(...a.names);
+        s.software.push(...a.software);
+        if (a.orientation && !this.report.orientation)
+            this.report.orientation = a.orientation;
+        if (a.thumbnail)
+            this.report.thumbnails.push(a.thumbnail);
+        if (!this.report.width && a.width && a.height) {
+            this.report.width = a.width;
+            this.report.height = a.height;
+        }
+        for (const w of tiff.warnings.slice(0, 3))
+            this.note(`EXIF: ${w}`);
+        return tiff;
+    }
+    xmp(bytes, source, removable = true) {
+        const text = typeof bytes === 'string' ? bytes : utf8(bytes);
+        const a = analyzeXmp(text);
+        this.findings.push(...xmpFindings(a, source, removable));
+        const s = this.report.summary;
+        if (a.gps && !s.gps)
+            s.gps = a.gps;
+        s.names.push(...a.names);
+        s.people.push(...a.people);
+        s.software.push(...a.software);
+        if (a.motionPhoto)
+            this.note('The XMP block declares this is a motion photo with an embedded video.');
+        if (a.aiPrompt && !s.aiPrompt)
+            s.aiPrompt = a.aiPrompt;
+        return a.categories;
+    }
+    irb(bytes, source, removable = true) {
+        const a = analyzeIrb(bytes, source, removable);
+        this.findings.push(...a.findings);
+        this.report.summary.names.push(...a.names);
+        if (a.thumbnail)
+            this.report.thumbnails.push(a.thumbnail);
+        const cats = new Set(a.categories);
+        if (a.xmp)
+            for (const c of this.xmp(a.xmp, source, removable))
+                cats.add(c);
+        return cats;
+    }
+    finish() {
+        const s = this.report.summary;
+        s.serialNumbers = unique(s.serialNumbers);
+        s.people = unique(s.people);
+        s.names = unique(s.names).filter((n) => !s.people.includes(n));
+        s.software = unique(s.software);
+        this.report.categories = sortCategories(this.findings.map((f) => f.category));
+        return this.report;
+    }
+}
+function unique(a) {
+    return [...new Set(a.map((x) => x.trim()).filter(Boolean))];
+}
+export function categoriesOf(findings) {
+    return new Set(findings.map((f) => f.category));
+}