imgtune 0.1.0 → 0.3.0

package/dist/resources/pool.js

@@ -0,0 +1,47 @@
+// A bounded pool for the resource jobs of a scan. A job is started in phase 1 (while the next pages are measured) and read
+// back when its page is analysed. `admit` waits until fewer than `limit` jobs are pending, so the jobs in flight, and the
+// page data they hold, stay bounded. A job that throws is reported and gives undefined: it never fails its page or the others.
+export class ResourcePool {
+    limit;
+    onError;
+    pending = new Set();
+    waiters = [];
+    constructor(limit, onError = () => undefined) {
+        this.limit = limit;
+        this.onError = onError;
+        if (!Number.isInteger(limit) || limit < 1)
+            throw new RangeError(`ResourcePool limit must be a positive integer, got ${limit}`);
+    }
+    /** Resolves when a slot is free. Call before start, so the number of pending jobs never exceeds the limit. */
+    async admit() {
+        while (this.pending.size >= this.limit)
+            await new Promise((resolve) => this.waiters.push(resolve));
+    }
+    /** Starts a job now (after admit). The returned promise resolves to the job's value, or undefined when it throws. */
+    start(job) {
+        const run = (async () => {
+            try {
+                return await job();
+            }
+            catch (error) {
+                this.onError(error);
+                return undefined;
+            }
+        })();
+        this.pending.add(run);
+        void run.finally(() => {
+            this.pending.delete(run);
+            this.waiters.shift()?.();
+        });
+        return run;
+    }
+    /** Resolves once every started job has settled. */
+    async drain() {
+        while (this.pending.size > 0)
+            await Promise.all([...this.pending]);
+    }
+    /** The number of jobs not yet settled. */
+    get size() {
+        return this.pending.size;
+    }
+}

package/dist/resources/report.js

@@ -0,0 +1,57 @@
+/** Rows shown per page in the text output; the JSON has all of them. */
+export const RESOURCE_TEXT_ROWS = 8;
+const kb = (bytes) => `${(bytes / 1024).toFixed(0)} KB`;
+/** A finding's saving smaller than this, for a kind that is weak for its cost, is a lead (see labelFinding in phase.ts). */
+export const LEAD_BYTES = 5 * 1024;
+/**
+ * The order and the totals of a finding: 0 a first-party saving (the headline), 1 a third-party saving (ask the vendor),
+ * 2 a lead (a small saving of a weak-for-cost kind), 3 informational (no saving). Sorting and totals both read this.
+ */
+export function findingTier(f) {
+    if (f.savedBytes <= 0)
+        return 3;
+    if (f.details?.lead === true)
+        return 2;
+    return f.details?.thirdParty === true ? 1 : 0;
+}
+/**
+ * The totals of a page's findings: first-party savings (their count and bytes per view, marked when part of it is an
+ * estimate), third-party savings apart, leads and informational findings counted apart. None of the rest adds to the
+ * headline saving.
+ */
+export function resourceTotalsLine(findings) {
+    if (findings.length === 0)
+        return undefined;
+    const of = (tier) => findings.filter((f) => findingTier(f) === tier);
+    const first = of(0);
+    const third = of(1);
+    const leads = of(2);
+    const informational = of(3).length;
+    const sumOf = (list) => list.reduce((sum, f) => sum + f.savedBytes, 0);
+    const estimated = first.some((f) => f.estimate);
+    let head;
+    if (first.length > 0)
+        head = `resources: ${first.length} finding(s), saves ~${kb(sumOf(first))}/view${estimated ? " (est. in part)" : ""}`;
+    else
+        head = third.length > 0 || leads.length > 0 ? "resources: no first-party saving" : "resources: no saving";
+    const thirdPart = third.length > 0 ? `; third-party ${third.length} finding(s) ~${kb(sumOf(third))}/view (ask the vendor)` : "";
+    const leadPart = leads.length > 0 ? `; ${leads.length} lead(s) ~${kb(sumOf(leads))}/view (small)` : "";
+    const info = informational > 0 ? `, ${informational} informational` : "";
+    return `${head}${thirdPart}${leadPart}${info}, not in the image totals`;
+}
+/** Text lines for a page's resource findings: the totals, then one row per finding and its first fix line. */
+export function resourceLinesOf(findings, text) {
+    const total = resourceTotalsLine(findings);
+    if (total === undefined)
+        return [];
+    const lines = [`  ${total}`];
+    for (const finding of findings.slice(0, RESOURCE_TEXT_ROWS)) {
+        const saved = finding.savedBytes > 0 ? `  saves ${kb(finding.savedBytes)}/view${finding.estimate ? " (est.)" : ""}` : "";
+        lines.push(`    ${finding.kind}: ${text(finding.title)}${saved}`);
+        if (finding.fix[0] !== undefined)
+            lines.push(`      fix: ${text(finding.fix[0])}`);
+    }
+    if (findings.length > RESOURCE_TEXT_ROWS)
+        lines.push(`    ... ${findings.length - RESOURCE_TEXT_ROWS} more in the JSON (resources)`);
+    return lines;
+}

package/dist/resources/sfnt.js

@@ -0,0 +1,305 @@
+// Reads just enough of a font file for the font analyzer: its container format, a WOFF/WOFF2/EOT unwrap to plain sfnt
+// bytes, and the tables the checks need (maxp, head, OS/2, name, cmap, fvar). Nothing is rendered or fully parsed.
+// Every function returns null (or an empty result) on malformed input; none of them throws.
+import { inflateSync } from "node:zlib";
+import * as wawoff2 from "wawoff2";
+export function detectFormat(buf) {
+    if (buf.length < 4)
+        return "unknown";
+    const tag = buf.toString("latin1", 0, 4);
+    if (tag === "wOF2")
+        return "woff2";
+    if (tag === "wOFF")
+        return "woff";
+    if (tag === "ttcf")
+        return "collection";
+    if (tag === "OTTO" || tag === "true" || buf.readUInt32BE(0) === 0x00010000)
+        return "sfnt";
+    if (buf.length >= 36 && buf.readUInt16LE(34) === 0x504c)
+        return "eot";
+    return "unknown";
+}
+/** Plain sfnt bytes for a font file, or null when it cannot be unwrapped. */
+export async function toSfnt(buf, format) {
+    try {
+        switch (format) {
+            case "sfnt":
+                return buf;
+            case "woff2":
+                return Buffer.from(await wawoff2.decompress(buf));
+            case "woff":
+                return woff1ToSfnt(buf);
+            case "eot":
+                return eotToSfnt(buf);
+            default:
+                return null;
+        }
+    }
+    catch {
+        return null;
+    }
+}
+/** WOFF 1.0: each table is zlib-deflated when its compressed length is smaller. Rebuild the sfnt table directory. */
+function woff1ToSfnt(buf) {
+    const flavor = buf.readUInt32BE(4);
+    const numTables = buf.readUInt16BE(12);
+    const tables = [];
+    for (let i = 0; i < numTables; i++) {
+        const at = 44 + i * 20;
+        const offset = buf.readUInt32BE(at + 4);
+        const compLength = buf.readUInt32BE(at + 8);
+        const origLength = buf.readUInt32BE(at + 12);
+        const raw = buf.subarray(offset, offset + compLength);
+        if (raw.length !== compLength)
+            return null;
+        const data = compLength < origLength ? inflateSync(raw) : raw;
+        if (data.length !== origLength)
+            return null;
+        tables.push({ tag: buf.subarray(at, at + 4), data });
+    }
+    return buildSfnt(flavor, tables);
+}
+/** EOT without MTX compression or XOR obfuscation is the sfnt font data at the end of the header. */
+function eotToSfnt(buf) {
+    const eotSize = buf.readUInt32LE(0);
+    const fontDataSize = buf.readUInt32LE(4);
+    const flags = buf.readUInt32LE(12);
+    if (flags & 0x4)
+        return null; // MicroType Express compressed
+    if (eotSize > buf.length || fontDataSize > eotSize)
+        return null;
+    const data = Buffer.from(buf.subarray(eotSize - fontDataSize, eotSize));
+    if (flags & 0x10000000)
+        for (let i = 0; i < data.length; i++)
+            data[i] ^= 0x50;
+    return detectFormat(data) === "sfnt" ? data : null;
+}
+function buildSfnt(flavor, tables) {
+    const n = tables.length;
+    const entrySelector = Math.floor(Math.log2(n));
+    const searchRange = 2 ** entrySelector * 16;
+    const header = Buffer.alloc(12 + n * 16);
+    header.writeUInt32BE(flavor, 0);
+    header.writeUInt16BE(n, 4);
+    header.writeUInt16BE(searchRange, 6);
+    header.writeUInt16BE(entrySelector, 8);
+    header.writeUInt16BE(n * 16 - searchRange, 10);
+    const body = [];
+    let offset = header.length;
+    tables.forEach((t, i) => {
+        const at = 12 + i * 16;
+        t.tag.copy(header, at);
+        header.writeUInt32BE(0, at + 4); // checksum: not verified by any reader used here
+        header.writeUInt32BE(offset, at + 8);
+        header.writeUInt32BE(t.data.length, at + 12);
+        const padded = Buffer.alloc((t.data.length + 3) & ~3);
+        t.data.copy(padded);
+        body.push(padded);
+        offset += padded.length;
+    });
+    return Buffer.concat([header, ...body]);
+}
+function readTables(buf) {
+    if (buf.length < 12)
+        return null;
+    const numTables = buf.readUInt16BE(4);
+    const tables = new Map();
+    for (let i = 0; i < numTables; i++) {
+        const at = 12 + i * 16;
+        const tag = buf.toString("latin1", at, at + 4);
+        const offset = buf.readUInt32BE(at + 8);
+        const length = buf.readUInt32BE(at + 12);
+        if (offset + length <= buf.length)
+            tables.set(tag, { offset, length });
+    }
+    return tables;
+}
+/** Reads the tables the checks need from a plain sfnt. Returns null for a malformed or unsupported file. */
+export function parseSfnt(buf) {
+    try {
+        if (detectFormat(buf) !== "sfnt")
+            return null;
+        const tables = readTables(buf);
+        if (!tables)
+            return null;
+        const maxp = tables.get("maxp");
+        const cmap = tables.get("cmap");
+        if (!maxp || !cmap)
+            return null;
+        const numGlyphs = buf.readUInt16BE(maxp.offset + 4);
+        const head = tables.get("head");
+        const macStyle = head ? buf.readUInt16BE(head.offset + 44) : 0;
+        const os2 = tables.get("OS/2");
+        const weightClass = os2 ? buf.readUInt16BE(os2.offset + 4) : undefined;
+        const fsSelection = os2 && os2.length >= 64 ? buf.readUInt16BE(os2.offset + 62) : 0;
+        const ranges = readCmap(buf, cmap);
+        const codepoints = ranges.reduce((sum, [a, b]) => sum + (b - a + 1), 0);
+        const fvar = tables.get("fvar");
+        const name = tables.get("name");
+        return {
+            numGlyphs,
+            families: name ? familyNames(buf, name) : [],
+            weightClass,
+            italic: Boolean(fsSelection & 1) || Boolean(macStyle & 2),
+            axes: fvar ? readAxes(buf, fvar) : [],
+            ranges,
+            codepoints,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function readAxes(buf, fvar) {
+    const axesOffset = buf.readUInt16BE(fvar.offset + 4);
+    const axisCount = buf.readUInt16BE(fvar.offset + 8);
+    const axisSize = buf.readUInt16BE(fvar.offset + 10);
+    const axes = [];
+    for (let i = 0; i < axisCount; i++) {
+        const at = fvar.offset + axesOffset + i * axisSize;
+        axes.push({
+            tag: buf.toString("latin1", at, at + 4),
+            min: buf.readInt32BE(at + 4) / 65536,
+            default: buf.readInt32BE(at + 8) / 65536,
+            max: buf.readInt32BE(at + 12) / 65536,
+        });
+    }
+    return axes;
+}
+/** Name IDs 16 then 1, from the Windows (UTF-16BE) records, else the Mac (Latin-1) records. */
+function familyNames(buf, name) {
+    const count = buf.readUInt16BE(name.offset + 2);
+    const stringOffset = name.offset + buf.readUInt16BE(name.offset + 4);
+    const found = new Map();
+    for (let i = 0; i < count; i++) {
+        const at = name.offset + 6 + i * 12;
+        const platform = buf.readUInt16BE(at);
+        const nameId = buf.readUInt16BE(at + 6);
+        if (nameId !== 1 && nameId !== 16)
+            continue;
+        const length = buf.readUInt16BE(at + 8);
+        const start = stringOffset + buf.readUInt16BE(at + 10);
+        const raw = buf.subarray(start, start + length);
+        const text = decodeName(platform, raw);
+        // A Windows record wins over a Mac one for the same ID.
+        if (!found.has(nameId) || platform === 3)
+            found.set(nameId, text.trim());
+    }
+    return [found.get(16), found.get(1)].filter((s) => Boolean(s));
+}
+function decodeName(platform, raw) {
+    if (platform === 3 || platform === 0) {
+        // UTF-16BE: copy the even-length prefix, swap to little-endian for Node's decoder.
+        return Buffer.from(raw.subarray(0, raw.length & ~1)).swap16().toString("utf16le");
+    }
+    return raw.toString("latin1");
+}
+/** Unicode code point ranges from the best Unicode cmap subtable (3,10 then 3,1 then any platform 0, then 3,0). */
+function readCmap(buf, cmap) {
+    const count = buf.readUInt16BE(cmap.offset + 2);
+    const subtables = [];
+    for (let i = 0; i < count; i++) {
+        const at = cmap.offset + 4 + i * 8;
+        subtables.push({
+            platform: buf.readUInt16BE(at),
+            encoding: buf.readUInt16BE(at + 2),
+            offset: cmap.offset + buf.readUInt32BE(at + 4),
+        });
+    }
+    const pick = subtables.find((s) => s.platform === 3 && s.encoding === 10) ??
+        subtables.find((s) => s.platform === 3 && s.encoding === 1) ??
+        subtables.find((s) => s.platform === 0) ??
+        subtables.find((s) => s.platform === 3 && s.encoding === 0);
+    if (!pick)
+        return [];
+    const format = buf.readUInt16BE(pick.offset);
+    const raw = format === 4 ? format4Codes(buf, pick.offset) : format === 12 ? format12Groups(buf, pick.offset) : [];
+    return mergeCodes(raw);
+}
+function format4Codes(buf, sub) {
+    const segCount = buf.readUInt16BE(sub + 6) / 2;
+    const endAt = sub + 14;
+    const startAt = endAt + segCount * 2 + 2;
+    const deltaAt = startAt + segCount * 2;
+    const rangeAt = deltaAt + segCount * 2;
+    const out = [];
+    for (let s = 0; s < segCount; s++) {
+        const end = buf.readUInt16BE(endAt + s * 2);
+        const start = buf.readUInt16BE(startAt + s * 2);
+        const delta = buf.readUInt16BE(deltaAt + s * 2);
+        const rangeOffset = buf.readUInt16BE(rangeAt + s * 2);
+        for (let c = start; c <= end && c < 0xffff; c++) {
+            let glyph;
+            if (rangeOffset === 0) {
+                glyph = (c + delta) & 0xffff;
+            }
+            else {
+                glyph = buf.readUInt16BE(rangeAt + s * 2 + rangeOffset + (c - start) * 2);
+                if (glyph !== 0)
+                    glyph = (glyph + delta) & 0xffff;
+            }
+            if (glyph !== 0)
+                out.push([c, c]);
+        }
+    }
+    return out;
+}
+function format12Groups(buf, sub) {
+    const groups = buf.readUInt32BE(sub + 12);
+    const out = [];
+    for (let g = 0; g < groups; g++) {
+        const at = sub + 16 + g * 12;
+        out.push([buf.readUInt32BE(at), buf.readUInt32BE(at + 4)]);
+    }
+    return out;
+}
+/** Sorts and merges inclusive ranges, and drops anything above U+10FFFF. */
+export function mergeCodes(input) {
+    const sorted = input
+        .map(([a, b]) => [a, Math.min(b, 0x10ffff)])
+        .filter(([a, b]) => a <= b)
+        .sort((x, y) => x[0] - y[0]);
+    const out = [];
+    for (const [a, b] of sorted) {
+        const last = out[out.length - 1];
+        if (last && a <= last[1] + 1)
+            last[1] = Math.max(last[1], b);
+        else
+            out.push([a, b]);
+    }
+    return out;
+}
+/** Intersection of two sorted, merged range lists. */
+export function intersectRanges(a, b) {
+    const out = [];
+    let i = 0;
+    let j = 0;
+    while (i < a.length && j < b.length) {
+        const lo = Math.max(a[i][0], b[j][0]);
+        const hi = Math.min(a[i][1], b[j][1]);
+        if (lo <= hi)
+            out.push([lo, hi]);
+        if (a[i][1] < b[j][1])
+            i++;
+        else
+            j++;
+    }
+    return out;
+}
+export function countRanges(ranges) {
+    return ranges.reduce((sum, [a, b]) => sum + (b - a + 1), 0);
+}
+export function inRanges(ranges, cp) {
+    let lo = 0;
+    let hi = ranges.length - 1;
+    while (lo <= hi) {
+        const mid = (lo + hi) >> 1;
+        if (cp < ranges[mid][0])
+            hi = mid - 1;
+        else if (cp > ranges[mid][1])
+            lo = mid + 1;
+        else
+            return true;
+    }
+    return false;
+}

package/dist/resources/svg.js

@@ -0,0 +1,178 @@
+import { createHash } from "node:crypto";
+import sharp from "sharp";
+import { optimize } from "svgo";
+import { brotliSize } from "./brotli.js";
+import { digestOf, heavyValue } from "./cache.js";
+import { score } from "../metric.js";
+/** SVGs under this size are not worth an optimiser pass. */
+const MIN_BYTES = 2048;
+/** SVGs over this size are skipped: the pass and the render would take too long for the phase budget. */
+const MAX_BYTES = 5 * 1024 * 1024;
+/** A finding needs at least this share of the brotli size saved by SVGO. */
+const MIN_SAVING_SHARE = 0.2;
+/** Fidelity bar: SSIMULACRA2 of the optimised render against the original, both at half of RENDER_PX. */
+export const FIDELITY_BAR = 70;
+const RENDER_PX = 512;
+const SCORE_PX = 256;
+/** Embedded rasters: `<image href="data:image/…;base64,…">`. */
+const EMBEDDED_RASTER = /<image\b[^>]*?\s(?:xlink:)?href\s*=\s*["']data:image\/([a-z0-9.+-]+);base64,([^"']*)["']/gi;
+const kb = (n) => `${(n / 1024).toFixed(n < 10 * 1024 ? 1 : 0)} KB`;
+const shortHash = (url) => createHash("sha1").update(url).digest("hex").slice(0, 10);
+const basename = (url) => {
+    const path = url.replace(/[?#].*$/, "");
+    const raw = path.slice(path.lastIndexOf("/") + 1) || url;
+    try {
+        return decodeURIComponent(raw);
+    }
+    catch {
+        return raw;
+    }
+};
+/**
+ * Above this size mergePaths is switched off: on a 700 KB export it takes ~7 s and gains about 1% of the brotli size.
+ */
+export const MERGE_PATHS_MAX_BYTES = 256 * 1024;
+/** Optimises with the default preset at floatPrecision 2 (the plan's setting; the fidelity check guards it). */
+export function optimizeSvg(text) {
+    const overrides = text.length > MERGE_PATHS_MAX_BYTES ? { mergePaths: false } : {};
+    const result = optimize(text, {
+        multipass: false,
+        plugins: [{ name: "preset-default", params: { floatPrecision: 2, overrides } }],
+    });
+    return result.data;
+}
+function scaleTo(w, h, px) {
+    const k = px / Math.max(w, h);
+    return { width: Math.max(1, Math.round(w * k)), height: Math.max(1, Math.round(h * k)) };
+}
+/** Rasterises the SVG so its longer side is `px` pixels (aspect kept), RGBA, non-premultiplied. */
+async function render(svg, px, size) {
+    const meta = await sharp(svg, { density: 72 }).metadata();
+    const intrinsicW = meta.width && meta.width > 0 ? meta.width : 300;
+    const intrinsicH = meta.height && meta.height > 0 ? meta.height : 300;
+    const target = size ?? scaleTo(intrinsicW, intrinsicH, px);
+    // The density makes the SVG rasterise at the target width directly, so the downscale is small.
+    const density = Math.min(3000, Math.max(1, Math.round((72 * target.width) / intrinsicW)));
+    const { data, info } = await sharp(svg, { density })
+        .resize(target.width, target.height, { fit: "fill", background: { r: 0, g: 0, b: 0, alpha: 0 } })
+        .ensureAlpha()
+        .raw()
+        .toBuffer({ resolveWithObject: true });
+    return { data: new Uint8Array(data.buffer, data.byteOffset, data.byteLength), width: info.width, height: info.height };
+}
+/** Downscales a raw RGBA image to `px` on the longer side. */
+async function half(img, px) {
+    const size = scaleTo(img.width, img.height, px);
+    const { data, info } = await sharp(Buffer.from(img.data), { raw: { width: img.width, height: img.height, channels: 4 } })
+        .resize(size.width, size.height, { fit: "fill" })
+        .raw()
+        .toBuffer({ resolveWithObject: true });
+    return { data: new Uint8Array(data.buffer, data.byteOffset, data.byteLength), width: info.width, height: info.height };
+}
+/** SSIMULACRA2 of the optimised SVG against the original, both rendered at RENDER_PX and compared at SCORE_PX. */
+export async function fidelity(original, optimised) {
+    const ref = await render(original, RENDER_PX);
+    const test = await render(optimised, RENDER_PX, { width: ref.width, height: ref.height });
+    const [a, b] = await Promise.all([half(ref, SCORE_PX), half(test, SCORE_PX)]);
+    return score("ssimulacra2", a, b);
+}
+function embeddedRasters(text) {
+    const out = [];
+    for (const m of text.matchAll(EMBEDDED_RASTER)) {
+        const b64 = m[2] ?? "";
+        const padding = b64.endsWith("==") ? 2 : b64.endsWith("=") ? 1 : 0;
+        out.push({ format: (m[1] ?? "").toLowerCase(), bytes: Math.floor((b64.length * 3) / 4) - padding });
+    }
+    return out;
+}
+/** The measurement of one SVG: its optimised length and both brotli sizes, and the render's fidelity when the saving is worth a look. */
+async function measureSvg(body, text) {
+    const optimised = optimizeSvg(text);
+    const before = brotliSize(body);
+    const after = brotliSize(Buffer.from(optimised));
+    const saved = before.bytes - after.bytes;
+    // A saving under the bar is not worth the render: the fidelity is not computed (quality 0 reads as no claim).
+    const quality = saved < before.bytes * MIN_SAVING_SHARE ? 0 : await fidelity(body, Buffer.from(optimised));
+    return { before, after, quality, optimisedBytes: optimised.length, saved };
+}
+async function analyzeOne(record, body) {
+    const url = record.url;
+    const name = basename(url);
+    const id = `svg:${shortHash(url)}`;
+    const findings = [];
+    const text = body.toString("utf8");
+    const rasters = embeddedRasters(text);
+    if (rasters.length > 0) {
+        const total = rasters.reduce((s, r) => s + r.bytes, 0);
+        findings.push({
+            id: `${id}:raster`,
+            kind: "svg",
+            url,
+            bytes: body.length,
+            savedBytes: 0,
+            estimate: false,
+            title: `svg ${name}: ${rasters.length} embedded raster${rasters.length === 1 ? "" : "s"}, ${kb(total)} decoded`,
+            fix: [
+                "replace each embedded raster with a separate file at its display size (AVIF or WebP, see the image hints), or redraw it as vector",
+                "an embedded data URI costs about a third more than the file it holds",
+            ],
+            details: { rasters: rasters.map((r) => ({ format: r.format, bytes: r.bytes })) },
+        });
+    }
+    // The measurement (SVGO, both brotli sizes, the render) is heavy and depends only on the content: once per run, and not at
+    // all once the run's resource budget is spent (then the file is not measured and claims no saving).
+    const measured = await heavyValue(`svg:measure:${digestOf(body)}`, () => measureSvg(body, text));
+    if (measured === undefined)
+        return findings;
+    const { before, after, quality, optimisedBytes } = measured;
+    const saved = before.bytes - after.bytes;
+    if (saved < before.bytes * MIN_SAVING_SHARE || !(quality >= FIDELITY_BAR))
+        return findings;
+    findings.unshift({
+        id,
+        kind: "svg",
+        url,
+        bytes: body.length,
+        savedBytes: saved,
+        estimate: false,
+        title: `svg ${name}: SVGO (floatPrecision 2) ${kb(body.length)} → ${kb(optimisedBytes)}, brotli ${kb(before.bytes)} → ${kb(after.bytes)}, render SSIMULACRA2 ${quality.toFixed(1)}`,
+        fix: [
+            `npx svgo --precision=2 <file>.svg -o <file>.min.svg  (default preset; check the render at display size)`,
+            `expected brotli ${kb(after.bytes)} (now ${kb(before.bytes)}); serve the optimised file, keep the original under version control`,
+        ],
+        details: {
+            rawBefore: body.length,
+            rawAfter: optimisedBytes,
+            brotliBefore: before.bytes,
+            brotliAfter: after.bytes,
+            ssimulacra2: quality,
+            ...(before.estimate || after.estimate ? { brotliEstimate: true } : {}),
+        },
+    });
+    return findings;
+}
+export const analyzer = {
+    kind: "svg",
+    wants(r) {
+        // The size cap is applied on the body in analyze(): a chunked response has no length before it is read.
+        if (r.bytes < MIN_BYTES)
+            return false;
+        return /image\/svg\+xml/.test(r.contentType) || (/\.svg(?:[?#]|$)/i.test(r.url) && /xml|octet-stream/.test(r.contentType));
+    },
+    async analyze(records, _ctx) {
+        const out = [];
+        const seen = new Set();
+        for (const r of records) {
+            if (r.body === undefined || seen.has(r.url) || r.body.length > MAX_BYTES || r.body.length < MIN_BYTES)
+                continue;
+            seen.add(r.url);
+            try {
+                out.push(...(await analyzeOne(r, r.body)));
+            }
+            catch {
+                // Never throws: an SVG that svgo or sharp cannot handle yields no findings.
+            }
+        }
+        return out;
+    },
+};

package/dist/resources/types.js

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

package/dist/resources/zip.js

@@ -0,0 +1,67 @@
+import { inflateRawSync } from "node:zlib";
+/** Largest entry the reader will inflate (a lottie animation or a raster). */
+export const ZIP_MAX_ENTRY_BYTES = 50 * 1024 * 1024;
+/**
+ * Reads the central directory of a zip archive (no zip64). Never throws: returns [] for anything it does not understand.
+ */
+export function readZip(buf) {
+    try {
+        const eocd = findEocd(buf);
+        if (eocd < 0)
+            return [];
+        const count = buf.readUInt16LE(eocd + 10);
+        let p = buf.readUInt32LE(eocd + 16);
+        const entries = [];
+        for (let i = 0; i < count; i++) {
+            if (p + 46 > buf.length || buf.readUInt32LE(p) !== 0x02014b50)
+                break;
+            const method = buf.readUInt16LE(p + 10);
+            const compressedSize = buf.readUInt32LE(p + 20);
+            const size = buf.readUInt32LE(p + 24);
+            const nameLen = buf.readUInt16LE(p + 28);
+            const extraLen = buf.readUInt16LE(p + 30);
+            const commentLen = buf.readUInt16LE(p + 32);
+            const local = buf.readUInt32LE(p + 42);
+            const name = buf.toString("utf8", p + 46, p + 46 + nameLen);
+            entries.push({
+                name,
+                method,
+                compressedSize,
+                size,
+                data: () => readEntry(buf, local, method, compressedSize, size),
+            });
+            p += 46 + nameLen + extraLen + commentLen;
+        }
+        return entries;
+    }
+    catch {
+        return [];
+    }
+}
+function findEocd(buf) {
+    const min = Math.max(0, buf.length - 22 - 0xffff);
+    for (let i = buf.length - 22; i >= min; i--) {
+        if (buf.readUInt32LE(i) === 0x06054b50)
+            return i;
+    }
+    return -1;
+}
+function readEntry(buf, local, method, compressedSize, size) {
+    if (size > ZIP_MAX_ENTRY_BYTES || local + 30 > buf.length || buf.readUInt32LE(local) !== 0x04034b50)
+        return undefined;
+    const start = local + 30 + buf.readUInt16LE(local + 26) + buf.readUInt16LE(local + 28);
+    const raw = buf.subarray(start, start + compressedSize);
+    if (raw.length !== compressedSize)
+        return undefined;
+    if (method === 0)
+        return raw;
+    if (method === 8) {
+        try {
+            return inflateRawSync(raw, { maxOutputLength: ZIP_MAX_ENTRY_BYTES });
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return undefined;
+}