safe-upload 0.0.0-stage → 0.1.0

package/dist/types.d.ts

@@ -0,0 +1,80 @@
+/** What kind of information a piece of metadata gives away. */
+export type Category = 'location' | 'time' | 'device' | 'people' | 'author' | 'descriptions' | 'software' | 'history' | 'thumbnail' | 'hidden' | 'ai' | 'provenance' | 'settings' | 'other';
+export type Risk = 'high' | 'medium' | 'low';
+export type Format = 'jpeg' | 'png' | 'webp' | 'heic' | 'avif' | 'unknown';
+/** Where in the file a finding lives. */
+export type Source = 'exif' | 'xmp' | 'iptc' | 'jpeg' | 'png' | 'webp' | 'heif' | 'icc';
+export interface Finding {
+    category: Category;
+    source: Source;
+    /** Stable machine key, e.g. "exif.GPSLatitude". */
+    key: string;
+    /** Human label, e.g. "GPS latitude". */
+    label: string;
+    /** Human-readable value, truncated for very long data. */
+    value: string;
+    /** False when this format cannot drop it without re-encoding the picture. */
+    removable: boolean;
+}
+export interface GpsPoint {
+    latitude: number;
+    longitude: number;
+    altitude?: number;
+    /** Compass direction the camera was facing, degrees. */
+    direction?: number;
+}
+export interface HiddenMedia {
+    kind: 'video' | 'image' | 'data';
+    mime: string;
+    /** Short description such as "Motion photo video". */
+    label: string;
+    bytes: Uint8Array;
+}
+export interface Report {
+    format: Format;
+    mime: string;
+    size: number;
+    width?: number;
+    height?: number;
+    /** EXIF orientation 1..8 when present. */
+    orientation?: number;
+    findings: Finding[];
+    /** Categories with at least one finding, in display order. */
+    categories: Category[];
+    /** Convenience summaries for the most revealing items. */
+    summary: {
+        gps?: GpsPoint;
+        capturedAt?: string;
+        timeZone?: string;
+        device?: string;
+        serialNumbers: string[];
+        /** People tagged as appearing in the photo. */
+        people: string[];
+        /** Owner, artist, photographer and creator names. */
+        names: string[];
+        software: string[];
+        aiPrompt?: string;
+    };
+    /** Embedded preview pictures (EXIF/IPTC/XMP thumbnails). */
+    thumbnails: Uint8Array[];
+    /** Extra pictures or video stored in the file next to the main image. */
+    hidden: HiddenMedia[];
+    notes: string[];
+}
+export interface StripOptions {
+    /** Categories to remove. Defaults to every category whose `defaultRemove` is true. */
+    remove?: Category[] | 'all';
+}
+export interface StripResult {
+    bytes: Uint8Array;
+    mime: string;
+    format: Format;
+    /** True when only metadata changed and the picture data is byte-identical. */
+    lossless: true;
+    /** Categories that were present and are now gone. */
+    removed: Category[];
+    /** Findings that were requested for removal but could not be removed in this format. */
+    retained: Finding[];
+    notes: string[];
+}
+export type Input = Uint8Array | ArrayBuffer | Blob;

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/webp.d.ts

@@ -0,0 +1,6 @@
+import { Collector } from './collect.js';
+import type { FormatStrip } from './jpeg.js';
+import type { Category } from './types.js';
+export declare function isWebp(b: Uint8Array): boolean;
+export declare function inspectWebp(b: Uint8Array, c: Collector): void;
+export declare function stripWebp(b: Uint8Array, remove: Set<Category>): FormatStrip;

package/dist/webp.js

@@ -0,0 +1,123 @@
+import { concat, encodeAscii, latin1, putU32le, startsWith, u32le } from './bytes.js';
+import { Collector } from './collect.js';
+import { buildTiff, parseTiff, tiffCategories } from './exif.js';
+import { analyzeXmp } from './xmp.js';
+export function isWebp(b) {
+    return b.length >= 16 && startsWith(b, 0, 'RIFF') && startsWith(b, 8, 'WEBP');
+}
+function chunks(b) {
+    const out = [];
+    const riffEnd = Math.min(b.length, 8 + u32le(b, 4));
+    let p = 12;
+    while (p + 8 <= riffEnd) {
+        const fourcc = latin1(b, p, p + 4);
+        const size = u32le(b, p + 4);
+        const dataEnd = p + 8 + size;
+        if (dataEnd > b.length)
+            throw new Error('Corrupt WebP: chunk runs past the end of the file');
+        const end = dataEnd + (size & 1);
+        out.push({ fourcc, start: p, end: Math.min(end, b.length), data: b.subarray(p + 8, dataEnd) });
+        p = end;
+    }
+    return out;
+}
+const tiffOf = (d) => (startsWith(d, 0, 'Exif\0\0') ? d.subarray(6) : d);
+export function inspectWebp(b, c) {
+    for (const ch of chunks(b)) {
+        const d = ch.data;
+        if (ch.fourcc === 'VP8X' && d.length >= 10) {
+            c.report.width = 1 + (d[4] | (d[5] << 8) | (d[6] << 16));
+            c.report.height = 1 + (d[7] | (d[8] << 8) | (d[9] << 16));
+        }
+        else if (ch.fourcc === 'VP8 ' && d.length >= 10 && !c.report.width) {
+            c.report.width = (d[6] | (d[7] << 8)) & 0x3fff;
+            c.report.height = (d[8] | (d[9] << 8)) & 0x3fff;
+        }
+        else if (ch.fourcc === 'VP8L' && d.length >= 5 && !c.report.width) {
+            const bits = d[1] | (d[2] << 8) | (d[3] << 16) | (d[4] << 24);
+            c.report.width = (bits & 0x3fff) + 1;
+            c.report.height = ((bits >> 14) & 0x3fff) + 1;
+        }
+        else if (ch.fourcc === 'EXIF')
+            c.tiff(tiffOf(d), 'exif');
+        else if (ch.fourcc === 'XMP ')
+            c.xmp(d, 'xmp');
+        else if (!['VP8 ', 'VP8L', 'VP8X', 'ALPH', 'ANIM', 'ANMF', 'ICCP'].includes(ch.fourcc)) {
+            c.add({ category: 'other', source: 'webp', key: `webp.${ch.fourcc.trim()}`, label: `Extra chunk "${ch.fourcc.trim()}"`, value: `${d.length.toLocaleString('en')} bytes`, removable: true });
+        }
+    }
+}
+function chunkBytes(fourcc, data) {
+    const pad = data.length & 1;
+    const out = new Uint8Array(8 + data.length + pad);
+    out.set(encodeAscii(fourcc), 0);
+    putU32le(out, 4, data.length);
+    out.set(data, 8);
+    return out;
+}
+export function stripWebp(b, remove) {
+    const removed = new Set();
+    const notes = [];
+    const kept = [];
+    let vp8x;
+    let hasExif = false;
+    let hasXmp = false;
+    for (const ch of chunks(b)) {
+        const raw = b.subarray(ch.start, ch.end);
+        if (ch.fourcc === 'VP8X') {
+            vp8x = { index: kept.length, data: ch.data.slice() };
+            kept.push(raw);
+        }
+        else if (ch.fourcc === 'EXIF') {
+            const tiff = parseTiff(tiffOf(ch.data));
+            if (!tiff) {
+                if (remove.has('other'))
+                    removed.add('other');
+                else {
+                    kept.push(raw);
+                    hasExif = true;
+                }
+                continue;
+            }
+            if (![...tiffCategories(tiff)].some((c) => remove.has(c))) {
+                kept.push(raw);
+                hasExif = true;
+                continue;
+            }
+            const r = buildTiff(tiff, { remove });
+            r.removed.forEach((c) => removed.add(c));
+            notes.push(...r.notes);
+            if (r.bytes) {
+                kept.push(chunkBytes('EXIF', r.bytes));
+                hasExif = true;
+            }
+        }
+        else if (ch.fourcc === 'XMP ') {
+            const hits = [...analyzeXmp(new TextDecoder().decode(ch.data)).categories].filter((c) => remove.has(c));
+            if (hits.length) {
+                hits.forEach((c) => removed.add(c));
+                notes.push('The XMP metadata block was removed as a whole.');
+            }
+            else {
+                kept.push(raw);
+                hasXmp = true;
+            }
+        }
+        else if (!['VP8 ', 'VP8L', 'ALPH', 'ANIM', 'ANMF', 'ICCP'].includes(ch.fourcc) && remove.has('other')) {
+            removed.add('other');
+        }
+        else
+            kept.push(raw);
+    }
+    if (vp8x) {
+        const d = vp8x.data;
+        d[0] = (d[0] & ~0x0c) | (hasExif ? 0x08 : 0) | (hasXmp ? 0x04 : 0);
+        kept[vp8x.index] = chunkBytes('VP8X', d);
+    }
+    const body = concat(kept);
+    const head = new Uint8Array(12);
+    head.set(encodeAscii('RIFF'), 0);
+    putU32le(head, 4, 4 + body.length);
+    head.set(encodeAscii('WEBP'), 8);
+    return { bytes: concat([head, body]), removed, retained: [], notes };
+}

package/dist/xmp.d.ts

@@ -0,0 +1,25 @@
+import type { Category, Finding, GpsPoint, Source } from './types.js';
+export interface XmpProperty {
+    ns: string;
+    name: string;
+    value: string;
+    category: Category;
+}
+export interface XmpAnalysis {
+    properties: XmpProperty[];
+    categories: Set<Category>;
+    gps?: GpsPoint;
+    people: string[];
+    names: string[];
+    software: string[];
+    motionPhoto: boolean;
+    /** Byte length of the motion-photo video at the end of the file, when declared. */
+    motionVideoLength?: number;
+    aiPrompt?: string;
+}
+export declare function classifyXmp(ns: string, name: string): Category | 'technical';
+/** Parse an XMP packet into top-level properties with categories and a few summaries. */
+export declare function analyzeXmp(xml: string): XmpAnalysis;
+export declare function xmpFindings(a: XmpAnalysis, source: Source, removable?: boolean): Finding[];
+/** An empty but valid XMP packet, padded with spaces to an exact byte length when possible. */
+export declare function emptyXmpPacket(length: number): Uint8Array;

package/dist/xmp.js

@@ -0,0 +1,364 @@
+/** Namespace URI → per-property classification. '*' is the namespace default. */
+const NS = {
+    'http://ns.adobe.com/exif/1.0/': {
+        '*': 'settings',
+        DateTimeOriginal: 'time',
+        DateTimeDigitized: 'time',
+        OffsetTime: 'time',
+        OffsetTimeOriginal: 'time',
+        OffsetTimeDigitized: 'time',
+        SubSecTimeOriginal: 'time',
+        GPSTimeStamp: 'time',
+        UserComment: 'descriptions',
+        PixelXDimension: 'technical',
+        PixelYDimension: 'technical',
+        ColorSpace: 'technical',
+        ExifVersion: 'technical',
+        ImageUniqueID: 'device',
+        CameraOwnerName: 'author',
+        BodySerialNumber: 'device',
+        LensSerialNumber: 'device',
+        LensMake: 'device',
+        LensModel: 'device',
+    },
+    'http://cipa.jp/exif/1.0/': {
+        '*': 'settings',
+        BodySerialNumber: 'device',
+        LensSerialNumber: 'device',
+        LensMake: 'device',
+        LensModel: 'device',
+        LensSpecification: 'device',
+        CameraOwnerName: 'author',
+        Photographer: 'author',
+        ImageUniqueID: 'device',
+        OffsetTime: 'time',
+        OffsetTimeOriginal: 'time',
+    },
+    'http://ns.adobe.com/tiff/1.0/': {
+        '*': 'technical',
+        Make: 'device',
+        Model: 'device',
+        DateTime: 'time',
+        Artist: 'author',
+        Copyright: 'author',
+        Software: 'software',
+        ImageDescription: 'descriptions',
+    },
+    'http://ns.adobe.com/exif/1.0/aux/': {
+        '*': 'device',
+        OwnerName: 'author',
+        ApproximateFocusDistance: 'settings',
+        Firmware: 'device',
+    },
+    'http://ns.adobe.com/xap/1.0/': {
+        '*': 'other',
+        CreateDate: 'time',
+        ModifyDate: 'time',
+        MetadataDate: 'time',
+        CreatorTool: 'software',
+        Rating: 'descriptions',
+        Label: 'descriptions',
+        Nickname: 'author',
+        Thumbnails: 'thumbnail',
+    },
+    'http://ns.adobe.com/xap/1.0/mm/': { '*': 'history' },
+    'http://ns.adobe.com/xap/1.0/sType/ResourceEvent#': { '*': 'history' },
+    'http://ns.adobe.com/camera-raw-settings/1.0/': { '*': 'history' },
+    'http://ns.adobe.com/lightroom/1.0/': { '*': 'descriptions' },
+    'http://ns.adobe.com/photoshop/1.0/': {
+        '*': 'other',
+        City: 'location',
+        State: 'location',
+        Country: 'location',
+        DateCreated: 'time',
+        DocumentAncestors: 'history',
+        History: 'history',
+        AuthorsPosition: 'author',
+        CaptionWriter: 'author',
+        Credit: 'author',
+        Source: 'author',
+        Headline: 'descriptions',
+        Instructions: 'descriptions',
+        TransmissionReference: 'descriptions',
+        Category: 'descriptions',
+        SupplementalCategories: 'descriptions',
+        ColorMode: 'technical',
+        ICCProfile: 'technical',
+    },
+    'http://purl.org/dc/elements/1.1/': {
+        '*': 'descriptions',
+        creator: 'author',
+        rights: 'author',
+        publisher: 'author',
+        contributor: 'author',
+        format: 'technical',
+    },
+    'http://ns.adobe.com/xap/1.0/rights/': { '*': 'author' },
+    'http://ns.useplus.org/ldf/xmp/1.0/': { '*': 'author' },
+    'http://iptc.org/std/Iptc4xmpCore/1.0/xmlns/': {
+        '*': 'descriptions',
+        Location: 'location',
+        CountryCode: 'location',
+        CreatorContactInfo: 'author',
+    },
+    'http://iptc.org/std/Iptc4xmpExt/2008-02-29/': {
+        '*': 'descriptions',
+        LocationCreated: 'location',
+        LocationShown: 'location',
+        PersonInImage: 'people',
+        PersonInImageWDetails: 'people',
+        ArtworkOrObject: 'descriptions',
+        DigitalSourceType: 'ai',
+    },
+    'http://www.metadataworkinggroup.com/schemas/regions/': { '*': 'people' },
+    'http://ns.microsoft.com/photo/1.2/': { '*': 'people' },
+    'http://ns.microsoft.com/photo/1.0/': { '*': 'descriptions' },
+    'http://ns.google.com/photos/1.0/camera/': { '*': 'hidden' },
+    'http://ns.google.com/photos/1.0/container/': { '*': 'hidden' },
+    'http://ns.google.com/photos/1.0/container/item/': { '*': 'hidden' },
+    'http://ns.google.com/photos/1.0/depthmap/': { '*': 'hidden' },
+    'http://ns.google.com/photos/1.0/image/': { '*': 'hidden' },
+    'http://ns.google.com/photos/1.0/panorama/': { '*': 'settings' },
+    'http://ns.adobe.com/hdr-gain-map/1.0/': { '*': 'hidden' },
+    'http://ns.apple.com/HDRGainMap/1.0/': { '*': 'hidden' },
+    'http://ns.apple.com/ImageIO/1.0/': { '*': 'other' },
+    'http://ns.apple.com/pixeldatainfo/1.0/': { '*': 'hidden' },
+    'http://ns.adobe.com/xmp/1.0/DynamicMedia/': { '*': 'other' },
+    'http://ns.adobe.com/pdf/1.3/': { '*': 'software', Keywords: 'descriptions' },
+    'http://ns.adobe.com/xmp/note/': { '*': 'technical' },
+    'http://c2pa.org/': { '*': 'provenance' },
+};
+/** Container namespaces whose elements are structure, not properties. */
+const STRUCTURAL = new Set(['http://www.w3.org/1999/02/22-rdf-syntax-ns#', 'adobe:ns:meta/', 'http://www.w3.org/XML/1998/namespace']);
+function decodeEntities(s) {
+    return s
+        .replace(/&#x([0-9a-f]+);/gi, (_, h) => String.fromCodePoint(parseInt(h, 16)))
+        .replace(/&#(\d+);/g, (_, d) => String.fromCodePoint(parseInt(d, 10)))
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&apos;/g, "'")
+        .replace(/&amp;/g, '&');
+}
+function* tokenize(xml) {
+    const re = /<!--[\s\S]*?-->|<\?[\s\S]*?\?>|<!\[CDATA\[([\s\S]*?)\]\]>|<!DOCTYPE[^>]*>|<\/\s*([^\s>]+)\s*>|<([^\s/>]+)((?:\s+[^\s=/>]+\s*=\s*(?:"[^"]*"|'[^']*'))*)\s*(\/?)>|([^<]+)/g;
+    let m;
+    while ((m = re.exec(xml))) {
+        if (m[1] !== undefined)
+            yield { kind: 'text', text: m[1] };
+        else if (m[2])
+            yield { kind: 'close', name: m[2] };
+        else if (m[3]) {
+            const attrs = {};
+            const ar = /([^\s=/>]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
+            let a;
+            while ((a = ar.exec(m[4] ?? '')))
+                attrs[a[1]] = decodeEntities(a[2] ?? a[3] ?? '');
+            yield { kind: 'open', name: m[3], attrs, selfClosing: m[5] === '/' };
+        }
+        else if (m[6] !== undefined)
+            yield { kind: 'text', text: decodeEntities(m[6]) };
+    }
+}
+export function classifyXmp(ns, name) {
+    const map = NS[ns];
+    if (!map)
+        return 'other';
+    return map[name] ?? map['*'] ?? 'other';
+}
+/** Parse an XMP packet into top-level properties with categories and a few summaries. */
+export function analyzeXmp(xml) {
+    const prefixes = new Map([['xml', 'http://www.w3.org/XML/1998/namespace']]);
+    for (const m of xml.matchAll(/xmlns:([A-Za-z_][\w.-]*)\s*=\s*(?:"([^"]*)"|'([^']*)')/g))
+        prefixes.set(m[1], m[2] ?? m[3] ?? '');
+    const split = (q) => {
+        const i = q.indexOf(':');
+        if (i < 0)
+            return ['', q];
+        return [prefixes.get(q.slice(0, i)) ?? 'urn:unknown:' + q.slice(0, i), q.slice(i + 1)];
+    };
+    const out = { properties: [], categories: new Set(), people: [], names: [], software: [], motionPhoto: false };
+    const add = (ns, name, value) => {
+        if (STRUCTURAL.has(ns))
+            return;
+        const cls = classifyXmp(ns, name);
+        if (cls === 'technical')
+            return;
+        out.properties.push({ ns, name, value, category: cls });
+        out.categories.add(cls);
+    };
+    const stack = [];
+    const currentProp = () => {
+        for (let i = stack.length - 1; i >= 0; i--)
+            if (stack[i].prop)
+                return stack[i].prop;
+        return undefined;
+    };
+    const finish = (p) => {
+        const texts = p.texts.map((t) => t.trim()).filter(Boolean);
+        let value = texts.join(', ');
+        if (p.items > 1 && texts.length === 0)
+            value = `${p.items} entries`;
+        else if (p.items > 3 && value.length > 160)
+            value = `${p.items} entries: ${value.slice(0, 160)}…`;
+        else if (value.length > 300)
+            value = value.slice(0, 300) + '…';
+        add(p.ns, p.name, value);
+        collect(p.ns, p.name, texts);
+    };
+    const collect = (ns, name, texts) => {
+        const cls = classifyXmp(ns, name);
+        if (cls === 'people')
+            out.people.push(...texts.filter((t) => t.length < 120));
+        if (cls === 'author' && (name === 'creator' || name === 'Artist' || name === 'OwnerName' || name === 'CameraOwnerName'))
+            out.names.push(...texts);
+        if (name === 'CreatorTool' || (ns === 'http://ns.adobe.com/tiff/1.0/' && name === 'Software'))
+            out.software.push(...texts);
+        if (ns === 'http://ns.google.com/photos/1.0/camera/') {
+            if ((name === 'MotionPhoto' || name === 'MicroVideo') && texts[0] === '1')
+                out.motionPhoto = true;
+            if (name === 'MicroVideoOffset') {
+                const n = Number(texts[0]);
+                if (n > 0)
+                    out.motionVideoLength = n;
+            }
+        }
+    };
+    for (const tok of tokenize(xml)) {
+        if (tok.kind === 'text') {
+            const p = currentProp();
+            if (p && tok.text && tok.text.trim())
+                p.texts.push(tok.text);
+            continue;
+        }
+        if (tok.kind === 'close') {
+            const f = stack.pop();
+            if (f?.prop && f.role === 'prop')
+                finish(f.prop);
+            continue;
+        }
+        const q = tok.name;
+        const [ns, local] = split(q);
+        const parent = stack[stack.length - 1];
+        let frame;
+        if (ns === 'http://www.w3.org/1999/02/22-rdf-syntax-ns#' && local === 'RDF')
+            frame = { q, role: 'rdf' };
+        else if (ns === 'http://www.w3.org/1999/02/22-rdf-syntax-ns#' && local === 'Description' && parent?.role === 'rdf')
+            frame = { q, role: 'desc' };
+        else if (parent?.role === 'desc')
+            frame = { q, role: 'prop', prop: { ns, name: local, texts: [], items: 0 } };
+        else
+            frame = { q, role: 'inner' };
+        // Attributes: on a top-level description they are properties; deeper they are values.
+        for (const [k, v] of Object.entries(tok.attrs ?? {})) {
+            if (k.startsWith('xmlns') || k === 'rdf:about' || k === 'rdf:parseType' || k === 'xml:lang' || k.startsWith('x:'))
+                continue;
+            const [ans, alocal] = split(k);
+            if (frame.role === 'desc') {
+                add(ans, alocal, v.length > 300 ? v.slice(0, 300) + '…' : v);
+                collect(ans, alocal, [v]);
+            }
+            else {
+                const p = frame.prop ?? currentProp();
+                if (p && v)
+                    p.texts.push(`${alocal}: ${v}`);
+                if (ans === 'http://ns.google.com/photos/1.0/container/item/' && alocal === 'Length') {
+                    const mime = tok.attrs?.[Object.keys(tok.attrs).find((x) => x.endsWith(':Mime')) ?? ''];
+                    if (mime?.startsWith('video/'))
+                        out.motionVideoLength = Number(v) || out.motionVideoLength;
+                }
+            }
+        }
+        if (q.endsWith(':li')) {
+            const p = currentProp();
+            if (p)
+                p.items++;
+        }
+        if (tok.selfClosing) {
+            if (frame.prop)
+                finish(frame.prop);
+            continue;
+        }
+        stack.push(frame);
+    }
+    // GPS from exif:GPSLatitude="12,58.1234N"
+    const gpsVal = (name) => out.properties.find((p) => p.ns === 'http://ns.adobe.com/exif/1.0/' && p.name === name)?.value;
+    const lat = parseXmpCoord(gpsVal('GPSLatitude'));
+    const lon = parseXmpCoord(gpsVal('GPSLongitude'));
+    if (lat !== undefined && lon !== undefined)
+        out.gps = { latitude: lat, longitude: lon };
+    for (const p of out.properties)
+        if (p.ns === 'http://ns.adobe.com/exif/1.0/' && p.name.startsWith('GPS') && p.name !== 'GPSTimeStamp') {
+            p.category = 'location';
+            out.categories.add('location');
+        }
+    return out;
+}
+function parseXmpCoord(v) {
+    if (!v)
+        return undefined;
+    const m = /^\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)(?:\s*,\s*(\d+(?:\.\d+)?))?\s*([NSEW])\s*$/i.exec(v);
+    if (!m)
+        return undefined;
+    let deg = Number(m[1]) + Number(m[2]) / 60 + (m[3] ? Number(m[3]) / 3600 : 0);
+    if (/[SW]/i.test(m[4]))
+        deg = -deg;
+    return deg;
+}
+const PRETTY = {
+    CreatorTool: 'Created with',
+    CreateDate: 'Created',
+    ModifyDate: 'Modified',
+    MetadataDate: 'Metadata modified',
+    History: 'Edit history',
+    DocumentID: 'Document ID',
+    InstanceID: 'Instance ID',
+    OriginalDocumentID: 'Original document ID',
+    DerivedFrom: 'Derived from',
+    DocumentAncestors: 'Source documents',
+    creator: 'Creator',
+    rights: 'Rights',
+    title: 'Title',
+    description: 'Description',
+    subject: 'Keywords',
+    MotionPhoto: 'Motion photo',
+    MicroVideo: 'Motion photo (legacy)',
+    MicroVideoOffset: 'Motion video size',
+    MotionPhotoPresentationTimestampUs: 'Motion photo frame time',
+    Directory: 'Embedded items',
+    Regions: 'Face regions',
+    RegionInfo: 'Tagged regions',
+    PersonInImage: 'People in image',
+    SerialNumber: 'Camera serial number',
+    LensSerialNumber: 'Lens serial number',
+    City: 'City',
+    State: 'State',
+    Country: 'Country',
+    Location: 'Location',
+    GPSLatitude: 'GPS latitude',
+    GPSLongitude: 'GPS longitude',
+    GPSAltitude: 'GPS altitude',
+};
+export function xmpFindings(a, source, removable = true) {
+    return a.properties.map((p) => ({
+        category: p.category,
+        source,
+        key: `xmp.${p.name}`,
+        label: PRETTY[p.name] ?? p.name.replace(/([a-z])([A-Z])/g, '$1 $2'),
+        value: p.value || '(present)',
+        removable,
+    }));
+}
+/** An empty but valid XMP packet, padded with spaces to an exact byte length when possible. */
+export function emptyXmpPacket(length) {
+    const head = "<?xpacket begin='' id='W5M0MpCehiHzreSzNTczkc9d'?><x:xmpmeta xmlns:x='adobe:ns:meta/'/>";
+    const tail = "<?xpacket end='w'?>";
+    const min = head.length + tail.length;
+    if (length < min)
+        return new Uint8Array(length).fill(0x20);
+    const s = head + ' '.repeat(length - min) + tail;
+    const out = new Uint8Array(length);
+    for (let i = 0; i < s.length; i++)
+        out[i] = s.charCodeAt(i);
+    return out;
+}