@crewhaus/tool-media 0.7.0

package/dist/lib/imageops.js

@@ -0,0 +1,236 @@
+/**
+ * Pixel operations on decoded RGBA: resampling, cropping, comparison and a
+ * perceptual hash.
+ *
+ * Everything here is integer-deterministic. Resampling rounds with
+ * `Math.round` on a value computed in the same order every time, so two
+ * runs on the same pixels produce byte-identical output — which is the
+ * whole point of a screenshot-regression primitive.
+ */
+import { MediaFormatError } from "./bytes";
+import { luma } from "./png";
+/** A blank image, fully transparent. */
+export function blankImage(width, height) {
+    return { width, height, data: new Uint8Array(width * height * 4) };
+}
+/**
+ * Resize to exactly `width` x `height`.
+ *
+ * `nearest` preserves exact colours (right for pixel art, palettes and QR
+ * codes); `bilinear` averages the four neighbours (right for photographs,
+ * and the only one of the two that does not alias badly when shrinking by
+ * a large factor — though neither does the area-averaging a proper
+ * downscaler would, which is stated rather than hidden).
+ */
+export function resizeImage(image, width, height, method) {
+    if (width <= 0 || height <= 0) {
+        throw new MediaFormatError(`cannot resize to ${width}x${height}`);
+    }
+    const out = new Uint8Array(width * height * 4);
+    const src = image.data;
+    const sw = image.width;
+    const sh = image.height;
+    const xRatio = sw / width;
+    const yRatio = sh / height;
+    if (method === "nearest") {
+        for (let y = 0; y < height; y++) {
+            const sy = Math.min(sh - 1, Math.floor((y + 0.5) * yRatio));
+            for (let x = 0; x < width; x++) {
+                const sx = Math.min(sw - 1, Math.floor((x + 0.5) * xRatio));
+                const s = (sy * sw + sx) * 4;
+                const d = (y * width + x) * 4;
+                out[d] = src[s];
+                out[d + 1] = src[s + 1];
+                out[d + 2] = src[s + 2];
+                out[d + 3] = src[s + 3];
+            }
+        }
+        return { width, height, data: out };
+    }
+    for (let y = 0; y < height; y++) {
+        const fy = Math.min(sh - 1, Math.max(0, (y + 0.5) * yRatio - 0.5));
+        const y0 = Math.floor(fy);
+        const y1 = Math.min(sh - 1, y0 + 1);
+        const wy = fy - y0;
+        for (let x = 0; x < width; x++) {
+            const fx = Math.min(sw - 1, Math.max(0, (x + 0.5) * xRatio - 0.5));
+            const x0 = Math.floor(fx);
+            const x1 = Math.min(sw - 1, x0 + 1);
+            const wx = fx - x0;
+            const p00 = (y0 * sw + x0) * 4;
+            const p01 = (y0 * sw + x1) * 4;
+            const p10 = (y1 * sw + x0) * 4;
+            const p11 = (y1 * sw + x1) * 4;
+            const d = (y * width + x) * 4;
+            for (let c = 0; c < 4; c++) {
+                const top = src[p00 + c] * (1 - wx) + src[p01 + c] * wx;
+                const bottom = src[p10 + c] * (1 - wx) + src[p11 + c] * wx;
+                out[d + c] = Math.round(top * (1 - wy) + bottom * wy);
+            }
+        }
+    }
+    return { width, height, data: out };
+}
+/** The size that fits `width`/`height` while preserving the aspect ratio. */
+export function fitDimensions(source, wanted) {
+    const { width, height } = wanted;
+    if (width !== undefined && height !== undefined)
+        return { width, height };
+    if (width !== undefined) {
+        return { width, height: Math.max(1, Math.round((width * source.height) / source.width)) };
+    }
+    if (height !== undefined) {
+        return { width: Math.max(1, Math.round((height * source.width) / source.height)), height };
+    }
+    return { width: source.width, height: source.height };
+}
+/** Cut a rectangle out. The rectangle must lie entirely inside the image. */
+export function cropImage(image, x, y, width, height) {
+    if (width <= 0 || height <= 0)
+        throw new MediaFormatError(`cannot crop to ${width}x${height}`);
+    if (x < 0 || y < 0 || x + width > image.width || y + height > image.height) {
+        throw new MediaFormatError(`crop ${width}x${height}+${x}+${y} is not inside the ${image.width}x${image.height} image`);
+    }
+    const out = new Uint8Array(width * height * 4);
+    for (let row = 0; row < height; row++) {
+        const from = ((y + row) * image.width + x) * 4;
+        out.set(image.data.subarray(from, from + width * 4), row * width * 4);
+    }
+    return { width, height, data: out };
+}
+/** Round to six decimal places, so a fraction is stable across runs. */
+function round6(value) {
+    return Math.round(value * 1e6) / 1e6;
+}
+/**
+ * Compare two same-sized images. A pixel counts as differing when any of its
+ * four channels differs by more than `threshold` (0 means exact equality).
+ */
+export function diffImages(a, b, threshold) {
+    if (a.width !== b.width || a.height !== b.height) {
+        throw new MediaFormatError(`cannot compare a ${a.width}x${a.height} image with a ${b.width}x${b.height} one`);
+    }
+    let differing = 0;
+    let maxDelta = 0;
+    let deltaSum = 0;
+    let minX = a.width;
+    let minY = a.height;
+    let maxX = -1;
+    let maxY = -1;
+    const total = a.width * a.height;
+    for (let i = 0; i < total; i++) {
+        const o = i * 4;
+        let pixelMax = 0;
+        for (let c = 0; c < 4; c++) {
+            const delta = Math.abs(a.data[o + c] - b.data[o + c]);
+            deltaSum += delta;
+            if (delta > pixelMax)
+                pixelMax = delta;
+        }
+        if (pixelMax > maxDelta)
+            maxDelta = pixelMax;
+        if (pixelMax > threshold) {
+            differing++;
+            const x = i % a.width;
+            const y = (i - x) / a.width;
+            if (x < minX)
+                minX = x;
+            if (x > maxX)
+                maxX = x;
+            if (y < minY)
+                minY = y;
+            if (y > maxY)
+                maxY = y;
+        }
+    }
+    return {
+        width: a.width,
+        height: a.height,
+        totalPixels: total,
+        differingPixels: differing,
+        fraction: round6(differing / total),
+        maxChannelDelta: maxDelta,
+        meanChannelDelta: round6(deltaSum / (total * 4)),
+        boundingBox: maxX < 0 ? null : { x: minX, y: minY, width: maxX - minX + 1, height: maxY - minY + 1 },
+    };
+}
+/**
+ * A 64-bit difference hash: reduce to 9x8 greyscale, then emit one bit per
+ * adjacent horizontal pair saying whether the left sample is brighter.
+ * Robust to scaling and mild compression, which is what makes it the right
+ * "are these the same picture?" signal when the pixels are not identical.
+ *
+ * Returned as 16 lowercase hex digits, most significant bit first.
+ */
+export function differenceHash(image) {
+    const small = resizeImage(image, 9, 8, "bilinear");
+    let hex = "";
+    for (let y = 0; y < 8; y++) {
+        let rowBits = 0;
+        for (let x = 0; x < 8; x++) {
+            const l = (y * 9 + x) * 4;
+            const r = (y * 9 + x + 1) * 4;
+            const left = luma(small.data[l], small.data[l + 1], small.data[l + 2]);
+            const right = luma(small.data[r], small.data[r + 1], small.data[r + 2]);
+            rowBits = (rowBits << 1) | (left > right ? 1 : 0);
+        }
+        hex += rowBits.toString(16).padStart(2, "0");
+    }
+    return hex;
+}
+/** Bits that differ between two hex hashes of equal length. */
+export function hammingDistance(a, b) {
+    if (a.length !== b.length) {
+        throw new MediaFormatError(`cannot compare a ${a.length}-digit hash with a ${b.length}-digit one`);
+    }
+    let distance = 0;
+    for (let i = 0; i < a.length; i++) {
+        let x = Number.parseInt(a[i], 16) ^ Number.parseInt(b[i], 16);
+        while (x > 0) {
+            distance += x & 1;
+            x >>= 1;
+        }
+    }
+    return distance;
+}
+/** Per-channel mean and extremes, for `PngRead`'s statistics mode. */
+export function imageStats(image) {
+    const sums = [0, 0, 0, 0];
+    const mins = [255, 255, 255, 255];
+    const maxs = [0, 0, 0, 0];
+    let opaque = 0;
+    const distinct = new Set();
+    const CAP = 4096;
+    let capped = false;
+    const total = image.width * image.height;
+    for (let i = 0; i < total; i++) {
+        const o = i * 4;
+        for (let c = 0; c < 4; c++) {
+            const v = image.data[o + c];
+            sums[c] = sums[c] + v;
+            if (v < mins[c])
+                mins[c] = v;
+            if (v > maxs[c])
+                maxs[c] = v;
+        }
+        if (image.data[o + 3] === 255)
+            opaque++;
+        if (!capped) {
+            const key = (image.data[o] << 16) |
+                (image.data[o + 1] << 8) |
+                image.data[o + 2];
+            distinct.add(key);
+            if (distinct.size >= CAP)
+                capped = true;
+        }
+    }
+    const at = (i) => round6(sums[i] / total);
+    return {
+        mean: { r: at(0), g: at(1), b: at(2), a: at(3) },
+        min: { r: mins[0], g: mins[1], b: mins[2], a: mins[3] },
+        max: { r: maxs[0], g: maxs[1], b: maxs[2], a: maxs[3] },
+        opaquePixels: opaque,
+        distinctColorsCapped: distinct.size,
+        capped,
+    };
+}

package/dist/lib/jpeg.d.ts

@@ -0,0 +1,81 @@
+/** One marker segment, located in the original file. */
+export type JpegSegment = {
+    /** The marker byte after the `0xFF`, e.g. `0xE1` for `APP1`. */
+    readonly marker: number;
+    /** Conventional name: `"APP1"`, `"SOF0"`, `"DQT"`, … */
+    readonly name: string;
+    /** Offset of the `0xFF` that starts the segment. */
+    readonly offset: number;
+    /** Total bytes including the marker and the two length bytes. */
+    readonly length: number;
+    /** The payload, excluding the marker and the length field. */
+    readonly payload: Uint8Array;
+};
+/**
+ * Every marker segment from `SOI` up to and including `SOS`, plus the
+ * offset at which the entropy-coded scan data begins. Everything from that
+ * offset to the end of the file is opaque and is copied verbatim by
+ * `stripJpegMetadata` rather than parsed.
+ */
+export declare function readJpegSegments(bytes: Uint8Array): {
+    segments: JpegSegment[];
+    scanStart: number;
+};
+export type GpsFix = {
+    readonly latitude: number;
+    readonly longitude: number;
+    readonly altitudeMeters?: number;
+    /** `YYYY:MM:DD HH:MM:SS` as the tags record it, if both parts are present. */
+    readonly timestampUtc?: string;
+};
+export type ExifData = {
+    readonly byteOrder: "little-endian" | "big-endian";
+    readonly make?: string;
+    readonly model?: string;
+    readonly lens?: string;
+    readonly software?: string;
+    readonly orientation?: number;
+    readonly orientationDescription?: string;
+    readonly dateTimeOriginal?: string;
+    readonly dateTimeDigitized?: string;
+    readonly dateTime?: string;
+    readonly exposureTimeSeconds?: number;
+    readonly fNumber?: number;
+    readonly isoSpeed?: number;
+    readonly focalLengthMm?: number;
+    readonly focalLength35mm?: number;
+    readonly pixelWidth?: number;
+    readonly pixelHeight?: number;
+    readonly hasGps: boolean;
+    readonly gps?: GpsFix;
+    /** Tags present that this reader recognises but did not fit above. */
+    readonly otherTagCount: number;
+};
+/** Parse an `APP1` payload that begins `Exif\0\0`. */
+export declare function parseExif(payload: Uint8Array): ExifData;
+/** Find the `APP1` segment carrying EXIF, if there is one. */
+export declare function findExifSegment(segments: ReadonlyArray<JpegSegment>): JpegSegment | undefined;
+export type StripOptions = {
+    /**
+     * Keep the `APP2` ICC colour profile. On by default: a profile is not
+     * metadata about the photographer, it is what tells a display how to
+     * interpret the colours, and dropping it visibly shifts the image.
+     */
+    readonly keepIccProfile?: boolean;
+    /** Keep the `APP0` JFIF header. On by default; it carries no identity. */
+    readonly keepJfif?: boolean;
+};
+export type StripResult = {
+    readonly bytes: Uint8Array;
+    readonly removed: ReadonlyArray<{
+        name: string;
+        bytes: number;
+    }>;
+    readonly bytesRemoved: number;
+};
+/**
+ * A JPEG with its metadata segments dropped. The scan data is copied
+ * verbatim — nothing is re-encoded, so the image is bit-for-bit the same
+ * picture, just without the record of who took it and where.
+ */
+export declare function stripJpegMetadata(bytes: Uint8Array, options?: StripOptions): StripResult;

package/dist/lib/jpeg.js

@@ -0,0 +1,388 @@
+/**
+ * JPEG at the segment level: walking the marker segments, reading the EXIF
+ * that hides in one of them, and writing a copy without the metadata.
+ *
+ * ## What this reads
+ *
+ * The TIFF structure inside an `APP1` segment whose payload begins
+ * `Exif\0\0`: IFD0, the Exif sub-IFD it points at, and the GPS sub-IFD.
+ * Both byte orders. Rationals, ASCII, shorts and longs. That covers the
+ * capture time, camera, lens, exposure and — the one that matters most for
+ * anything about to be published — the location.
+ *
+ * ## What this does not read
+ *
+ * MakerNotes (vendor-private, undocumented, and different per camera),
+ * IFD1 thumbnails, XMP, IPTC, and EXIF carried in a TIFF or HEIC rather
+ * than a JPEG. Each would be a separate parser; none is approximated.
+ */
+import { ByteReader, MediaFormatError, asciiAt, startsWith } from "./bytes";
+function markerName(marker) {
+    if (marker >= 0xe0 && marker <= 0xef)
+        return `APP${marker - 0xe0}`;
+    if (marker >= 0xc0 && marker <= 0xcf && marker !== 0xc4 && marker !== 0xc8 && marker !== 0xcc) {
+        return `SOF${marker - 0xc0}`;
+    }
+    switch (marker) {
+        case 0xc4:
+            return "DHT";
+        case 0xcc:
+            return "DAC";
+        case 0xd8:
+            return "SOI";
+        case 0xd9:
+            return "EOI";
+        case 0xda:
+            return "SOS";
+        case 0xdb:
+            return "DQT";
+        case 0xdd:
+            return "DRI";
+        case 0xfe:
+            return "COM";
+        default:
+            return `FF${marker.toString(16).toUpperCase().padStart(2, "0")}`;
+    }
+}
+/**
+ * Every marker segment from `SOI` up to and including `SOS`, plus the
+ * offset at which the entropy-coded scan data begins. Everything from that
+ * offset to the end of the file is opaque and is copied verbatim by
+ * `stripJpegMetadata` rather than parsed.
+ */
+export function readJpegSegments(bytes) {
+    if (!startsWith(bytes, [0xff, 0xd8])) {
+        throw new MediaFormatError("not a JPEG: the file does not start with FFD8 (SOI)");
+    }
+    const segments = [];
+    const reader = new ByteReader(bytes);
+    reader.seek(2);
+    while (reader.remaining >= 2) {
+        const start = reader.offset;
+        let marker = reader.u8();
+        if (marker !== 0xff) {
+            throw new MediaFormatError(`expected a marker at offset ${start}, found 0x${marker.toString(16)}`);
+        }
+        marker = reader.u8();
+        while (marker === 0xff && reader.remaining > 0)
+            marker = reader.u8(); // fill bytes
+        if (marker === 0x01 || (marker >= 0xd0 && marker <= 0xd7)) {
+            segments.push({
+                marker,
+                name: markerName(marker),
+                offset: start,
+                length: reader.offset - start,
+                payload: new Uint8Array(0),
+            });
+            continue;
+        }
+        if (marker === 0xd9) {
+            segments.push({ marker, name: "EOI", offset: start, length: 2, payload: new Uint8Array(0) });
+            return { segments, scanStart: reader.offset };
+        }
+        const length = reader.u16be();
+        if (length < 2) {
+            throw new MediaFormatError(`segment ${markerName(marker)} declares a length of ${length}`);
+        }
+        const payload = reader.take(length - 2);
+        segments.push({
+            marker,
+            name: markerName(marker),
+            offset: start,
+            length: reader.offset - start,
+            payload,
+        });
+        if (marker === 0xda)
+            return { segments, scanStart: reader.offset };
+    }
+    throw new MediaFormatError("the file ends before the start-of-scan marker");
+}
+// --- EXIF ----------------------------------------------------------------
+const TYPE_SIZES = {
+    1: 1,
+    2: 1,
+    3: 2,
+    4: 4,
+    5: 8,
+    6: 1,
+    7: 1,
+    8: 2,
+    9: 4,
+    10: 8,
+    11: 4,
+    12: 8,
+};
+/** Cap on entries per IFD, so a corrupt count cannot drive a long loop. */
+const MAX_IFD_ENTRIES = 512;
+class TiffReader {
+    view;
+    little;
+    bytes;
+    constructor(bytes, little) {
+        this.bytes = bytes;
+        this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        this.little = little;
+    }
+    u16(at) {
+        if (at + 2 > this.bytes.length)
+            throw new MediaFormatError(`TIFF read past the end at ${at}`);
+        return this.view.getUint16(at, this.little);
+    }
+    u32(at) {
+        if (at + 4 > this.bytes.length)
+            throw new MediaFormatError(`TIFF read past the end at ${at}`);
+        return this.view.getUint32(at, this.little);
+    }
+    i32(at) {
+        if (at + 4 > this.bytes.length)
+            throw new MediaFormatError(`TIFF read past the end at ${at}`);
+        return this.view.getInt32(at, this.little);
+    }
+}
+function readTagValue(tiff, type, count, valueAt) {
+    const size = TYPE_SIZES[type];
+    if (size === undefined)
+        throw new MediaFormatError(`TIFF type ${type} is not defined`);
+    const total = size * count;
+    const at = total <= 4 ? valueAt : tiff.u32(valueAt);
+    if (at + total > tiff.bytes.length) {
+        throw new MediaFormatError(`tag value of ${total} bytes at ${at} runs past the EXIF block`);
+    }
+    if (type === 2) {
+        let out = "";
+        for (let i = 0; i < count; i++) {
+            const byte = tiff.bytes[at + i];
+            if (byte === 0)
+                break;
+            out += String.fromCharCode(byte);
+        }
+        return out.trim();
+    }
+    const values = [];
+    for (let i = 0; i < count; i++) {
+        const p = at + i * size;
+        switch (type) {
+            case 1:
+            case 7:
+                values.push(tiff.bytes[p]);
+                break;
+            case 3:
+                values.push(tiff.u16(p));
+                break;
+            case 4:
+                values.push(tiff.u32(p));
+                break;
+            case 5: {
+                const denominator = tiff.u32(p + 4);
+                values.push(denominator === 0 ? 0 : tiff.u32(p) / denominator);
+                break;
+            }
+            case 9:
+                values.push(tiff.i32(p));
+                break;
+            case 10: {
+                const denominator = tiff.i32(p + 4);
+                values.push(denominator === 0 ? 0 : tiff.i32(p) / denominator);
+                break;
+            }
+            case 6:
+                values.push(tiff.view.getInt8(p));
+                break;
+            case 8:
+                values.push(tiff.view.getInt16(p, tiff.little));
+                break;
+            case 11:
+                values.push(tiff.view.getFloat32(p, tiff.little));
+                break;
+            case 12:
+                values.push(tiff.view.getFloat64(p, tiff.little));
+                break;
+            default:
+                break;
+        }
+    }
+    return values.length === 1 ? values[0] : values;
+}
+function readIfd(tiff, at) {
+    const out = new Map();
+    const count = tiff.u16(at);
+    if (count > MAX_IFD_ENTRIES) {
+        throw new MediaFormatError(`an IFD claims ${count} entries, over the ${MAX_IFD_ENTRIES} cap`);
+    }
+    for (let i = 0; i < count; i++) {
+        const entry = at + 2 + i * 12;
+        if (entry + 12 > tiff.bytes.length)
+            break;
+        const tag = tiff.u16(entry);
+        const type = tiff.u16(entry + 2);
+        const length = tiff.u32(entry + 4);
+        if (length > 1_000_000)
+            continue; // a count this large is corruption
+        try {
+            out.set(tag, readTagValue(tiff, type, length, entry + 8));
+        }
+        catch {
+            // One unreadable tag should not lose the rest of the block.
+        }
+    }
+    return out;
+}
+const ORIENTATIONS = {
+    1: "normal",
+    2: "mirrored horizontally",
+    3: "rotated 180 degrees",
+    4: "mirrored vertically",
+    5: "mirrored horizontally then rotated 90 degrees counter-clockwise",
+    6: "rotated 90 degrees clockwise",
+    7: "mirrored horizontally then rotated 90 degrees clockwise",
+    8: "rotated 90 degrees counter-clockwise",
+};
+function dms(value) {
+    if (!Array.isArray(value) || value.length < 3)
+        return undefined;
+    const [d, m, s] = value;
+    if (d === undefined || m === undefined || s === undefined)
+        return undefined;
+    return d + m / 60 + s / 3600;
+}
+function str(value) {
+    if (typeof value !== "string")
+        return undefined;
+    return value === "" ? undefined : value;
+}
+function n(value) {
+    if (typeof value !== "number")
+        return undefined;
+    return Number.isFinite(value) ? value : undefined;
+}
+/** Parse an `APP1` payload that begins `Exif\0\0`. */
+export function parseExif(payload) {
+    if (!asciiAt(payload, 0, "Exif") || payload[4] !== 0x00 || payload[5] !== 0x00) {
+        throw new MediaFormatError('the APP1 payload does not begin with the "Exif\\0\\0" identifier');
+    }
+    const tiffBytes = payload.subarray(6);
+    const order = (tiffBytes[0] << 8) | tiffBytes[1];
+    const little = order === 0x4949;
+    if (!little && order !== 0x4d4d) {
+        throw new MediaFormatError("the TIFF header carries neither the II nor the MM byte-order mark");
+    }
+    const tiff = new TiffReader(tiffBytes, little);
+    if (tiff.u16(2) !== 42)
+        throw new MediaFormatError("the TIFF header is missing its 42 magic number");
+    const ifd0 = readIfd(tiff, tiff.u32(4));
+    const exifOffset = ifd0.get(0x8769);
+    const exif = typeof exifOffset === "number" ? readIfd(tiff, exifOffset) : new Map();
+    const gpsOffset = ifd0.get(0x8825);
+    const gpsIfd = typeof gpsOffset === "number" ? readIfd(tiff, gpsOffset) : new Map();
+    let gps;
+    const latitude = dms(gpsIfd.get(0x0002));
+    const longitude = dms(gpsIfd.get(0x0004));
+    if (latitude !== undefined && longitude !== undefined) {
+        const latRef = str(gpsIfd.get(0x0001)) ?? "N";
+        const lonRef = str(gpsIfd.get(0x0003)) ?? "E";
+        const altitude = n(gpsIfd.get(0x0006));
+        const altitudeRef = n(gpsIfd.get(0x0005)) ?? 0;
+        const time = gpsIfd.get(0x0007);
+        const date = str(gpsIfd.get(0x001d));
+        let timestampUtc;
+        if (date !== undefined && Array.isArray(time) && time.length >= 3) {
+            const pad = (v) => String(Math.floor(v)).padStart(2, "0");
+            timestampUtc = `${date} ${pad(time[0])}:${pad(time[1])}:${pad(time[2])}`;
+        }
+        gps = {
+            latitude: Math.round((latRef.toUpperCase().startsWith("S") ? -latitude : latitude) * 1e6) / 1e6,
+            longitude: Math.round((lonRef.toUpperCase().startsWith("W") ? -longitude : longitude) * 1e6) / 1e6,
+            ...(altitude !== undefined
+                ? { altitudeMeters: Math.round((altitudeRef === 1 ? -altitude : altitude) * 100) / 100 }
+                : {}),
+            ...(timestampUtc !== undefined ? { timestampUtc } : {}),
+        };
+    }
+    const orientation = n(ifd0.get(0x0112));
+    const known = new Set([0x010f, 0x0110, 0x0112, 0x0131, 0x0132, 0x8769, 0x8825]);
+    const otherTagCount = [...ifd0.keys()].filter((t) => !known.has(t)).length + exif.size + gpsIfd.size;
+    return {
+        byteOrder: little ? "little-endian" : "big-endian",
+        ...(str(ifd0.get(0x010f)) !== undefined ? { make: str(ifd0.get(0x010f)) } : {}),
+        ...(str(ifd0.get(0x0110)) !== undefined ? { model: str(ifd0.get(0x0110)) } : {}),
+        ...(str(exif.get(0xa434)) !== undefined ? { lens: str(exif.get(0xa434)) } : {}),
+        ...(str(ifd0.get(0x0131)) !== undefined ? { software: str(ifd0.get(0x0131)) } : {}),
+        ...(orientation !== undefined
+            ? {
+                orientation,
+                orientationDescription: ORIENTATIONS[orientation] ?? `unknown (${orientation})`,
+            }
+            : {}),
+        ...(str(exif.get(0x9003)) !== undefined
+            ? { dateTimeOriginal: str(exif.get(0x9003)) }
+            : {}),
+        ...(str(exif.get(0x9004)) !== undefined
+            ? { dateTimeDigitized: str(exif.get(0x9004)) }
+            : {}),
+        ...(str(ifd0.get(0x0132)) !== undefined ? { dateTime: str(ifd0.get(0x0132)) } : {}),
+        ...(n(exif.get(0x829a)) !== undefined
+            ? { exposureTimeSeconds: n(exif.get(0x829a)) }
+            : {}),
+        ...(n(exif.get(0x829d)) !== undefined ? { fNumber: n(exif.get(0x829d)) } : {}),
+        ...(n(exif.get(0x8827)) !== undefined ? { isoSpeed: n(exif.get(0x8827)) } : {}),
+        ...(n(exif.get(0x920a)) !== undefined ? { focalLengthMm: n(exif.get(0x920a)) } : {}),
+        ...(n(exif.get(0xa405)) !== undefined
+            ? { focalLength35mm: n(exif.get(0xa405)) }
+            : {}),
+        ...(n(exif.get(0xa002)) !== undefined ? { pixelWidth: n(exif.get(0xa002)) } : {}),
+        ...(n(exif.get(0xa003)) !== undefined ? { pixelHeight: n(exif.get(0xa003)) } : {}),
+        hasGps: gps !== undefined,
+        ...(gps !== undefined ? { gps } : {}),
+        otherTagCount,
+    };
+}
+/** Find the `APP1` segment carrying EXIF, if there is one. */
+export function findExifSegment(segments) {
+    return segments.find((s) => s.marker === 0xe1 && asciiAt(s.payload, 0, "Exif"));
+}
+/** A segment name that `stripJpegMetadata` removes, given these options. */
+function isMetadata(segment, options) {
+    const { marker, payload } = segment;
+    if (marker === 0xfe)
+        return true; // COM
+    if (marker === 0xe0)
+        return options.keepJfif === false;
+    if (marker === 0xe2) {
+        // APP2 is the ICC profile in practice; anything else there is metadata.
+        const isIcc = asciiAt(payload, 0, "ICC_PROFILE");
+        return isIcc ? options.keepIccProfile === false : true;
+    }
+    // Every other APPn: EXIF and XMP (APP1), Meta (APP3), IPTC/Photoshop
+    // (APP13), Ducky (APP12), and the rest.
+    return marker >= 0xe1 && marker <= 0xef;
+}
+/**
+ * A JPEG with its metadata segments dropped. The scan data is copied
+ * verbatim — nothing is re-encoded, so the image is bit-for-bit the same
+ * picture, just without the record of who took it and where.
+ */
+export function stripJpegMetadata(bytes, options = {}) {
+    const { segments, scanStart } = readJpegSegments(bytes);
+    const kept = [new Uint8Array([0xff, 0xd8])];
+    const removed = [];
+    for (const segment of segments) {
+        if (segment.marker === 0xd8)
+            continue;
+        if (isMetadata(segment, options)) {
+            removed.push({ name: segment.name, bytes: segment.length });
+            continue;
+        }
+        kept.push(bytes.subarray(segment.offset, segment.offset + segment.length));
+    }
+    kept.push(bytes.subarray(scanStart));
+    let total = 0;
+    for (const part of kept)
+        total += part.length;
+    const out = new Uint8Array(total);
+    let at = 0;
+    for (const part of kept) {
+        out.set(part, at);
+        at += part.length;
+    }
+    return { bytes: out, removed, bytesRemoved: bytes.length - out.length };
+}