safe-upload 0.0.0-stage → 0.1.0

package/dist/heif.js

@@ -0,0 +1,299 @@
+import { latin1, u16be, u32be, u64be } from './bytes.js';
+import { Collector } from './collect.js';
+import { buildTiff, parseTiff, tiffCategories } from './exif.js';
+import { analyzeXmp, emptyXmpPacket } from './xmp.js';
+function boxes(b, from, to) {
+    const out = [];
+    let p = from;
+    while (p + 8 <= to) {
+        let size = u32be(b, p);
+        const type = latin1(b, p + 4, p + 8);
+        let body = p + 8;
+        if (size === 1) {
+            if (p + 16 > to)
+                break;
+            size = u64be(b, p + 8);
+            body = p + 16;
+        }
+        else if (size === 0)
+            size = to - p;
+        if (size < 8 || p + size > to)
+            break;
+        out.push({ type, start: p, body, end: p + size });
+        p += size;
+    }
+    return out;
+}
+const HEIC_BRANDS = new Set(['heic', 'heix', 'heim', 'heis', 'hevc', 'hevx', 'mif1', 'msf1', 'mif2', 'MiHE', 'MiHB']);
+export function heifFormat(b) {
+    if (b.length < 16 || latin1(b, 4, 8) !== 'ftyp')
+        return null;
+    const size = Math.min(u32be(b, 0), b.length);
+    const brands = [latin1(b, 8, 12)];
+    for (let p = 16; p + 4 <= size; p += 4)
+        brands.push(latin1(b, p, p + 4));
+    if (brands.some((x) => x === 'avif' || x === 'avis'))
+        return 'avif';
+    if (brands.some((x) => HEIC_BRANDS.has(x)))
+        return 'heic';
+    return null;
+}
+function parseHeif(b) {
+    const top = boxes(b, 0, b.length);
+    const meta = top.find((x) => x.type === 'meta');
+    if (!meta)
+        throw new Error('HEIF file has no meta box');
+    const kids = boxes(b, meta.body + 4, meta.end);
+    const h = { items: new Map(), refs: [], props: [], assoc: new Map() };
+    let idat;
+    for (const k of kids) {
+        if (k.type === 'pitm') {
+            const v = b[k.body];
+            h.primary = v === 0 ? u16be(b, k.body + 4) : u32be(b, k.body + 4);
+        }
+        else if (k.type === 'idat')
+            idat = k;
+        else if (k.type === 'iinf') {
+            const v = b[k.body];
+            const start = k.body + 4 + (v === 0 ? 2 : 4);
+            for (const infe of boxes(b, start, k.end)) {
+                if (infe.type !== 'infe')
+                    continue;
+                const iv = b[infe.body];
+                if (iv < 2)
+                    continue;
+                let p = infe.body + 4;
+                const id = iv === 2 ? u16be(b, p) : u32be(b, p);
+                p += iv === 2 ? 2 : 4;
+                p += 2; // protection index
+                const type = latin1(b, p, p + 4);
+                p += 4;
+                const nameEnd = b.indexOf(0, p);
+                const name = latin1(b, p, nameEnd < 0 || nameEnd > infe.end ? infe.end : nameEnd);
+                p = nameEnd + 1;
+                let contentType;
+                if (type === 'mime' && p < infe.end) {
+                    const ce = b.indexOf(0, p);
+                    contentType = latin1(b, p, ce < 0 || ce > infe.end ? infe.end : ce);
+                }
+                h.items.set(id, { id, type, name, contentType, extents: [] });
+            }
+        }
+        else if (k.type === 'iref') {
+            const v = b[k.body];
+            const idSize = v === 0 ? 2 : 4;
+            for (const r of boxes(b, k.body + 4, k.end)) {
+                let p = r.body;
+                const rd = (q) => (idSize === 2 ? u16be(b, q) : u32be(b, q));
+                const from = rd(p);
+                p += idSize;
+                const n = u16be(b, p);
+                p += 2;
+                const to = [];
+                for (let i = 0; i < n && p + idSize <= r.end; i++, p += idSize)
+                    to.push(rd(p));
+                h.refs.push({ type: r.type, from, to });
+            }
+        }
+        else if (k.type === 'iprp') {
+            for (const c of boxes(b, k.body, k.end)) {
+                if (c.type === 'ipco')
+                    for (const prop of boxes(b, c.body, c.end))
+                        h.props.push({ type: prop.type, data: b.subarray(prop.body, prop.end) });
+                else if (c.type === 'ipma') {
+                    const v = b[c.body];
+                    const flags = (b[c.body + 1] << 16) | (b[c.body + 2] << 8) | b[c.body + 3];
+                    let p = c.body + 4;
+                    const count = u32be(b, p);
+                    p += 4;
+                    for (let i = 0; i < count && p < c.end; i++) {
+                        const id = v < 1 ? u16be(b, p) : u32be(b, p);
+                        p += v < 1 ? 2 : 4;
+                        const n = b[p++];
+                        const list = [];
+                        for (let j = 0; j < n; j++) {
+                            if (flags & 1) {
+                                list.push(u16be(b, p) & 0x7fff);
+                                p += 2;
+                            }
+                            else
+                                list.push(b[p++] & 0x7f);
+                        }
+                        h.assoc.set(id, list);
+                    }
+                }
+            }
+        }
+    }
+    const iloc = kids.find((x) => x.type === 'iloc');
+    if (iloc) {
+        const v = b[iloc.body];
+        let p = iloc.body + 4;
+        const offsetSize = b[p] >> 4;
+        const lengthSize = b[p] & 15;
+        const baseSize = b[p + 1] >> 4;
+        const indexSize = v === 1 || v === 2 ? b[p + 1] & 15 : 0;
+        p += 2;
+        const rdN = (n) => {
+            const val = n === 0 ? 0 : n === 4 ? u32be(b, p) : n === 8 ? u64be(b, p) : n === 2 ? u16be(b, p) : 0;
+            p += n;
+            return val;
+        };
+        const count = v < 2 ? u16be(b, p) : u32be(b, p);
+        p += v < 2 ? 2 : 4;
+        for (let i = 0; i < count && p < iloc.end; i++) {
+            const id = v < 2 ? u16be(b, p) : u32be(b, p);
+            p += v < 2 ? 2 : 4;
+            let method = 0;
+            if (v === 1 || v === 2) {
+                method = u16be(b, p) & 15;
+                p += 2;
+            }
+            p += 2; // data reference index
+            const base = rdN(baseSize);
+            const ext = u16be(b, p);
+            p += 2;
+            const extents = [];
+            for (let e = 0; e < ext; e++) {
+                rdN(indexSize);
+                const off = rdN(offsetSize);
+                const len = rdN(lengthSize);
+                const fileBase = method === 1 && idat ? idat.body : 0;
+                if (method === 0 || method === 1)
+                    extents.push({ offset: fileBase + base + off, length: len });
+            }
+            const item = h.items.get(id);
+            if (item)
+                item.extents = extents;
+        }
+    }
+    return h;
+}
+function itemBytes(b, item) {
+    if (item.extents.length === 1) {
+        const e = item.extents[0];
+        return b.subarray(e.offset, Math.min(b.length, e.offset + e.length));
+    }
+    const total = item.extents.reduce((s, e) => s + e.length, 0);
+    const out = new Uint8Array(total);
+    let o = 0;
+    for (const e of item.extents) {
+        out.set(b.subarray(e.offset, e.offset + e.length), o);
+        o += e.length;
+    }
+    return out;
+}
+function writeItem(out, item, data) {
+    let o = 0;
+    for (const e of item.extents) {
+        out.set(data.subarray(o, o + e.length), e.offset);
+        o += e.length;
+    }
+}
+function auxType(h, id) {
+    for (const idx of h.assoc.get(id) ?? []) {
+        const prop = h.props[idx - 1];
+        if (prop?.type === 'auxC') {
+            const d = prop.data;
+            const end = d.indexOf(0, 4);
+            return latin1(d, 4, end < 0 ? d.length : end);
+        }
+    }
+    return undefined;
+}
+function isXmpItem(i) {
+    return i.type === 'mime' && /rdf\+xml|xmp/i.test(i.contentType ?? '');
+}
+function extras(h) {
+    const out = [];
+    const thumbs = h.refs.filter((r) => r.type === 'thmb');
+    if (thumbs.length)
+        out.push({ finding: { category: 'thumbnail', key: 'heif.thumbnail', label: 'Embedded thumbnail image', value: `${thumbs.length} preview image${thumbs.length > 1 ? 's' : ''}` } });
+    for (const r of h.refs.filter((x) => x.type === 'auxl')) {
+        const t = auxType(h, r.from) ?? '';
+        if (/alpha/i.test(t))
+            continue;
+        const label = /depth/i.test(t)
+            ? 'Depth map'
+            : /gainmap|gain-map|hdrgainmap/i.test(t)
+                ? 'HDR gain map'
+                : /matte/i.test(t)
+                    ? 'Portrait matte (person or skin mask)'
+                    : 'Auxiliary image';
+        out.push({ finding: { category: 'hidden', key: `heif.aux.${r.from}`, label, value: t || 'auxiliary image' } });
+    }
+    for (const i of h.items.values())
+        if (i.type === 'tmap')
+            out.push({ finding: { category: 'hidden', key: `heif.tmap.${i.id}`, label: 'HDR tone map image', value: 'ISO 21496 gain map' } });
+    return out;
+}
+export function inspectHeif(b, c) {
+    const h = parseHeif(b);
+    // Primary image size from its ispe property
+    if (h.primary !== undefined) {
+        for (const idx of h.assoc.get(h.primary) ?? []) {
+            const prop = h.props[idx - 1];
+            if (prop?.type === 'ispe' && prop.data.length >= 12) {
+                c.report.width = u32be(prop.data, 4);
+                c.report.height = u32be(prop.data, 8);
+            }
+        }
+    }
+    for (const item of h.items.values()) {
+        if (item.type === 'Exif' && item.extents.length) {
+            const d = itemBytes(b, item);
+            const skip = u32be(d, 0);
+            c.tiff(d.subarray(4 + skip), 'exif');
+        }
+        else if (isXmpItem(item) && item.extents.length)
+            c.xmp(itemBytes(b, item), 'xmp');
+    }
+    for (const e of extras(h))
+        c.add({ ...e.finding, source: 'heif', removable: false });
+    if (extras(h).length)
+        c.note('HEIC/AVIF embedded thumbnails and auxiliary images cannot be removed without converting the photo.');
+}
+const EMPTY_TIFF = new Uint8Array([0x4d, 0x4d, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]);
+export function stripHeif(b, remove) {
+    const h = parseHeif(b);
+    const out = b.slice();
+    const removed = new Set();
+    const notes = [];
+    for (const item of h.items.values()) {
+        if (!item.extents.length)
+            continue;
+        const d = itemBytes(b, item);
+        if (item.type === 'Exif') {
+            const skip = u32be(d, 0);
+            const tiffStart = 4 + skip;
+            const tiff = parseTiff(d.subarray(tiffStart));
+            if (!tiff || ![...tiffCategories(tiff)].some((c) => remove.has(c)))
+                continue;
+            const r = buildTiff(tiff, { remove });
+            r.removed.forEach((c) => removed.add(c));
+            notes.push(...r.notes);
+            const newTiff = r.bytes ?? EMPTY_TIFF;
+            const replacement = new Uint8Array(d.length);
+            replacement.set(d.subarray(0, tiffStart), 0);
+            if (tiffStart + newTiff.length > d.length)
+                throw new Error('Rewritten EXIF does not fit in place');
+            replacement.set(newTiff, tiffStart);
+            writeItem(out, item, replacement);
+        }
+        else if (isXmpItem(item)) {
+            const hits = [...analyzeXmp(new TextDecoder().decode(d)).categories].filter((c) => remove.has(c));
+            if (!hits.length)
+                continue;
+            hits.forEach((c) => removed.add(c));
+            writeItem(out, item, emptyXmpPacket(d.length));
+            notes.push('The XMP metadata block was emptied as a whole.');
+        }
+    }
+    const retained = [];
+    for (const e of extras(h))
+        if (remove.has(e.finding.category))
+            retained.push({ ...e.finding, source: 'heif', removable: false });
+    if (retained.length)
+        notes.push('Embedded previews and auxiliary images in HEIC/AVIF stay in place; convert the photo to remove them.');
+    return { bytes: out, removed, retained, notes };
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { inspect, strip, stripToBlob, carryExif, detectFormat, toBytes, UnsupportedFormatError, describeCategory } from './api.js';
+export { inspectFileName, neutralFileName } from './filename.js';
+export type { FileNameFinding, FileNameReport } from './filename.js';
+export { CATEGORY_INFO, CATEGORY_ORDER, DEFAULT_REMOVE } from './categories.js';
+export type { CategoryInfo } from './categories.js';
+export type { Category, Finding, Format, GpsPoint, HiddenMedia, Input, Report, Risk, Source, StripOptions, StripResult } from './types.js';

package/dist/index.js

@@ -0,0 +1,3 @@
+export { inspect, strip, stripToBlob, carryExif, detectFormat, toBytes, UnsupportedFormatError, describeCategory } from './api.js';
+export { inspectFileName, neutralFileName } from './filename.js';
+export { CATEGORY_INFO, CATEGORY_ORDER, DEFAULT_REMOVE } from './categories.js';

package/dist/iptc.d.ts

@@ -0,0 +1,11 @@
+import type { Category, Finding, Source } from './types.js';
+export interface IrbAnalysis {
+    findings: Finding[];
+    categories: Set<Category>;
+    names: string[];
+    thumbnail?: Uint8Array;
+    /** XMP stored inside the Photoshop resources (resource 0x0424). */
+    xmp?: Uint8Array;
+}
+/** Parse Photoshop image resources ("8BIM" blocks), optionally after a "Photoshop 3.0\0" header. */
+export declare function analyzeIrb(b: Uint8Array, source: Source, removable?: boolean): IrbAnalysis;

package/dist/iptc.js

@@ -0,0 +1,118 @@
+import { latin1, startsWith, u16be, u32be, utf8, clean } from './bytes.js';
+/** IIM record 2 datasets we classify. Unlisted datasets count as 'descriptions'. */
+const DATASETS = {
+    0: ['Record version', 'technical'],
+    5: ['Object name', 'descriptions'],
+    7: ['Edit status', 'descriptions'],
+    10: ['Urgency', 'descriptions'],
+    15: ['Category', 'descriptions'],
+    20: ['Supplemental category', 'descriptions'],
+    25: ['Keywords', 'descriptions'],
+    40: ['Special instructions', 'descriptions'],
+    55: ['Date created', 'time'],
+    60: ['Time created', 'time'],
+    62: ['Digital creation date', 'time'],
+    63: ['Digital creation time', 'time'],
+    65: ['Originating program', 'software'],
+    70: ['Program version', 'software'],
+    80: ['By-line', 'author'],
+    85: ['By-line title', 'author'],
+    90: ['City', 'location'],
+    92: ['Sub-location', 'location'],
+    95: ['Province/State', 'location'],
+    100: ['Country code', 'location'],
+    101: ['Country', 'location'],
+    103: ['Original transmission reference', 'descriptions'],
+    105: ['Headline', 'descriptions'],
+    110: ['Credit', 'author'],
+    115: ['Source', 'author'],
+    116: ['Copyright notice', 'author'],
+    118: ['Contact', 'author'],
+    120: ['Caption', 'descriptions'],
+    122: ['Caption writer', 'author'],
+};
+/** Parse Photoshop image resources ("8BIM" blocks), optionally after a "Photoshop 3.0\0" header. */
+export function analyzeIrb(b, source, removable = true) {
+    const out = { findings: [], categories: new Set(), names: [] };
+    let p = startsWith(b, 0, 'Photoshop 3.0\0') ? 14 : 0;
+    while (p + 12 <= b.length && startsWith(b, p, '8BIM')) {
+        const id = u16be(b, p + 4);
+        const nameLen = b[p + 6];
+        let q = p + 7 + nameLen;
+        if ((nameLen + 1) & 1)
+            q++;
+        if (q + 4 > b.length)
+            break;
+        const size = u32be(b, q);
+        const start = q + 4;
+        const end = Math.min(b.length, start + size);
+        const data = b.subarray(start, end);
+        if (id === 0x0404)
+            parseIim(data, source, removable, out);
+        else if (id === 0x040c || id === 0x0409) {
+            out.categories.add('thumbnail');
+            out.findings.push({ category: 'thumbnail', source, key: 'iptc.PhotoshopThumbnail', label: 'Photoshop thumbnail', value: `${Math.max(0, data.length - 28).toLocaleString('en')} byte preview`, removable });
+            if (data.length > 28 && data[28] === 0xff && data[29] === 0xd8)
+                out.thumbnail = data.subarray(28);
+        }
+        else if (id === 0x0424)
+            out.xmp = data;
+        else if (id === 0x0425) {
+            // IPTC digest: harmless checksum
+        }
+        else if (id === 0x040f || id === 0x0422 || id === 0x0423) {
+            // ICC profile / EXIF copies: EXIF copy is handled as 'other'
+            if (id !== 0x040f) {
+                out.categories.add('other');
+                out.findings.push({ category: 'other', source, key: `iptc.irb${id.toString(16)}`, label: 'Photoshop copy of EXIF data', value: `${data.length.toLocaleString('en')} bytes`, removable });
+            }
+        }
+        else if (id >= 0x07d0 && id <= 0x0bb6) {
+            out.categories.add('history');
+            out.findings.push({ category: 'history', source, key: 'iptc.paths', label: 'Photoshop paths', value: 'Clipping or work paths', removable });
+        }
+        p = end + (size & 1);
+    }
+    // Deduplicate path findings
+    const seen = new Set();
+    out.findings = out.findings.filter((f) => (seen.has(f.key + f.value) ? false : (seen.add(f.key + f.value), true)));
+    return out;
+}
+function parseIim(b, source, removable, out) {
+    let p = 0;
+    let isUtf8 = false;
+    const values = new Map();
+    while (p + 5 <= b.length && b[p] === 0x1c) {
+        const record = b[p + 1];
+        const dataset = b[p + 2];
+        let len = u16be(b, p + 3);
+        let start = p + 5;
+        if (len & 0x8000) {
+            const n = len & 0x7fff;
+            len = 0;
+            for (let i = 0; i < n; i++)
+                len = len * 256 + b[start + i];
+            start += n;
+        }
+        const data = b.subarray(start, Math.min(b.length, start + len));
+        if (record === 1 && dataset === 90 && latin1(data).includes('%G'))
+            isUtf8 = true;
+        if (record === 2) {
+            const s = clean(isUtf8 ? utf8(data) : latin1(data));
+            if (!values.has(dataset))
+                values.set(dataset, []);
+            values.get(dataset).push(s);
+        }
+        p = start + len;
+    }
+    for (const [ds, vals] of values) {
+        const [label, cls] = DATASETS[ds] ?? [`IPTC dataset 2:${ds}`, 'descriptions'];
+        if (cls === 'technical')
+            continue;
+        out.categories.add(cls);
+        const value = vals.join(', ');
+        out.findings.push({ category: cls, source, key: `iptc.2:${ds}`, label, value: value.length > 300 ? value.slice(0, 300) + '…' : value, removable });
+        if (cls === 'author' && (ds === 80 || ds === 122))
+            out.names.push(...vals);
+    }
+}

package/dist/jpeg.d.ts

@@ -0,0 +1,51 @@
+import { Collector } from './collect.js';
+import type { Category, Finding, HiddenMedia } from './types.js';
+type Kind = 'exif' | 'xmp' | 'xmpext' | 'iptc' | 'icc' | 'mpf' | 'jfif' | 'jfxx' | 'adobe' | 'jumbf' | 'com' | 'app' | 'image';
+export interface JpegSegment {
+    marker: number;
+    /** Offset of the 0xFF marker byte. */
+    start: number;
+    /** Offset after the segment. */
+    end: number;
+    /** Payload after the 2-byte length. */
+    payload: Uint8Array;
+    kind: Kind;
+}
+export interface ParsedJpeg {
+    /** Segments between SOI and the first SOS, in file order. */
+    head: JpegSegment[];
+    /** Offset of the first SOS marker. */
+    scanStart: number;
+    /** Offset just after the main image's EOI. */
+    imageEnd: number;
+    trailer: Uint8Array;
+    width?: number;
+    height?: number;
+}
+export declare function isJpeg(b: Uint8Array): boolean;
+/** Find the end (offset after EOI) of a JPEG starting at `from`, scanning through entropy-coded data. */
+export declare function findJpegEnd(b: Uint8Array, from: number): number;
+export declare function parseJpeg(b: Uint8Array): ParsedJpeg;
+/**
+ * Read the MPF index in an APP2 segment and return a label for each extra image, keyed by its
+ * absolute offset in the file. Offsets in the index count from the MPF TIFF header.
+ */
+export declare function mpfLabels(seg: JpegSegment): Map<number, string>;
+/** Split bytes after the main image into recognisable items (extra JPEGs, MP4/MOV video, vendor data). */
+export declare function splitTrailer(trailer: Uint8Array, motionVideoLength?: number, labelAt?: (relativeOffset: number) => string | undefined): HiddenMedia[];
+export declare function inspectJpeg(b: Uint8Array, c: Collector): void;
+export interface FormatStrip {
+    bytes: Uint8Array;
+    removed: Set<Category>;
+    retained: Finding[];
+    notes: string[];
+}
+/** Remove metadata categories from a JPEG without touching the compressed picture. */
+export declare function stripJpeg(b: Uint8Array, remove: Set<Category>, exifOverride?: {
+    orientation?: number;
+    dimensions?: {
+        width: number;
+        height: number;
+    };
+}): FormatStrip;
+export {};