@graphty/graph-io 0.3.18 → 0.3.20

package/src/common/options.ts

@@ -455,7 +455,7 @@ function encodingOption(value: unknown): string | null {
  * @param value - the value
  * @returns the JSON text of a primitive, or the type name otherwise
  */
-function describe(value: unknown): string {
+export function describe(value: unknown): string {
     switch (typeof value) {
         case "string":
             return JSON.stringify(value);

package/src/common/xml.ts

@@ -72,6 +72,38 @@ export class XmlSyntaxError extends Error {
     }
 }
 
+/**
+ * Opt-in repairs of two defects the Cytoscape XGMML writer is known to produce (research note
+ * `research-xgmml.md` 3.8 and 5). Each is off unless its callback is given; GEXF and GraphML never
+ * pass them, so their documents stay strictly well-formed. The callback is told the line of each
+ * repair, so the importer can warn per occurrence.
+ */
+export interface XmlRepairs {
+    /**
+     * Read an `&` that is not followed by a `;` within the next 7 characters as `&` (Cytoscape's
+     * `cytoscape.xgmml.repair.bare.ampersands` lookahead); an `&name;` that does end in time is
+     * still decoded, and still fatal when the entity is unknown. A complete numeric character
+     * reference is decoded whatever its length (`😀`), where Cytoscape's byte lookahead
+     * would turn it into text.
+     */
+    readonly bareAmpersand?: ((line: number) => void) | undefined;
+    /**
+     * Join a high-surrogate character reference immediately followed by a low-surrogate one
+     * (`��`, which XML 1.0 forbids but Cytoscape writes for astral characters) into
+     * the one character they encode; a lone surrogate stays fatal.
+     */
+    readonly surrogatePair?: ((line: number) => void) | undefined;
+}
+
+/** How far Cytoscape's bare-ampersand repair looks for the `;` that ends an entity reference. */
+const BARE_AMPERSAND_LOOKAHEAD = 7;
+
+/** A numeric character reference at the start of a text: `{` or ``. */
+const CHAR_REFERENCE = /^&#(?:[xX]([0-9a-fA-F]{1,6})|([0-9]{1,7}));/;
+
+/** A numeric character reference at the end of a text. */
+const TRAILING_CHAR_REFERENCE = /&#(?:[xX]([0-9a-fA-F]{1,6})|([0-9]{1,7}));$/;
+
 const NAMED_ENTITIES: Readonly<Record<string, string>> = {
     lt: "<",
     gt: ">",
@@ -280,9 +312,10 @@ function isXmlChar(cp: number): boolean {
  * Decode the predefined entities and character references of a text.
  * @param raw - the text as written
  * @param line - the line, for errors
+ * @param repairs - the opt-in repairs (XGMML only); none by default
  * @returns the decoded text
  */
-export function decodeEntities(raw: string, line: number): string {
+export function decodeEntities(raw: string, line: number, repairs?: XmlRepairs): string {
     let amp = raw.indexOf("&");
     if (amp < 0) {
         return raw;
@@ -292,6 +325,18 @@ export function decodeEntities(raw: string, line: number): string {
     while (amp >= 0) {
         out += raw.slice(start, amp);
         const semi = raw.indexOf(";", amp + 1);
+        if (
+            repairs?.bareAmpersand !== undefined &&
+            (semi < 0 || semi - amp > BARE_AMPERSAND_LOOKAHEAD) &&
+            // a well-formed character reference longer than the lookahead (&#128512;) is not bare
+            !CHAR_REFERENCE.test(raw.slice(amp, amp + 12))
+        ) {
+            repairs.bareAmpersand(lineAt(raw, amp, line));
+            out += "&";
+            start = amp + 1;
+            amp = raw.indexOf("&", start);
+            continue;
+        }
         if (semi < 0) {
             throw new XmlSyntaxError("unterminated entity reference", line);
         }
@@ -301,6 +346,14 @@ export function decodeEntities(raw: string, line: number): string {
             const digits = name.slice(hex ? 2 : 1);
             const ok = hex ? /^[0-9a-fA-F]{1,6}$/.test(digits) : /^[0-9]{1,7}$/.test(digits);
             const cp = ok ? Number.parseInt(digits, hex ? 16 : 10) : -1;
+            const low = cp >= 0xd800 && cp <= 0xdbff ? lowSurrogateAfter(raw, semi + 1, repairs) : null;
+            if (low !== null) {
+                repairs?.surrogatePair?.(lineAt(raw, amp, line));
+                out += String.fromCharCode(cp, low.unit);
+                start = low.end;
+                amp = raw.indexOf("&", start);
+                continue;
+            }
             if (cp < 0 || !isXmlChar(cp)) {
                 throw new XmlSyntaxError(`invalid character reference &${name};`, line);
             }
@@ -318,6 +371,45 @@ export function decodeEntities(raw: string, line: number): string {
     return out + raw.slice(start);
 }
 
+/**
+ * The line of a position inside a text that starts on a known line.
+ * @param raw - the text
+ * @param at - the position
+ * @param line - the line the text starts on
+ * @returns the line of the position
+ */
+function lineAt(raw: string, at: number, line: number): number {
+    let n = line;
+    for (let i = raw.indexOf("\n"); i >= 0 && i < at; i = raw.indexOf("\n", i + 1)) {
+        n++;
+    }
+    return n;
+}
+
+/**
+ * The low-surrogate character reference that may follow a high-surrogate one, when the
+ * surrogate-pair repair is on.
+ * @param raw - the text
+ * @param at - where the next reference would start
+ * @param repairs - the repairs in force
+ * @returns the low surrogate code unit and the index after its reference, or null
+ */
+function lowSurrogateAfter(
+    raw: string,
+    at: number,
+    repairs: XmlRepairs | undefined,
+): { readonly unit: number; readonly end: number } | null {
+    if (repairs?.surrogatePair === undefined || raw.charCodeAt(at) !== 38) {
+        return null;
+    }
+    const match = CHAR_REFERENCE.exec(raw.slice(at, at + 12));
+    if (match === null) {
+        return null;
+    }
+    const unit = match[1] === undefined ? Number.parseInt(match[2], 10) : Number.parseInt(match[1], 16);
+    return unit >= 0xdc00 && unit <= 0xdfff ? { unit, end: at + match[0].length } : null;
+}
+
 /**
  * Whether a text is whitespace only.
  * @param text - the text
@@ -347,9 +439,14 @@ export function localName(name: string): string {
  * malformed input; any error the handler throws propagates unchanged.
  * @param chunks - the text (already UTF-8 decoded, BOM removed)
  * @param handler - the event sink
+ * @param repairs - the opt-in repairs (XGMML only); none by default
  */
-export async function tokenizeXml(chunks: AsyncIterable<string>, handler: XmlHandler): Promise<void> {
-    const tokenizer = new XmlTokenizer(handler);
+export async function tokenizeXml(
+    chunks: AsyncIterable<string>,
+    handler: XmlHandler,
+    repairs?: XmlRepairs,
+): Promise<void> {
+    const tokenizer = new XmlTokenizer(handler, repairs);
     for await (const chunk of chunks) {
         tokenizer.push(chunk);
     }
@@ -435,12 +532,16 @@ export class XmlTokenizer {
 
     private rootClosed = false;
 
+    private readonly repairs: XmlRepairs | undefined;
+
     /**
      * Create a tokenizer.
      * @param handler - the event sink
+     * @param repairs - the opt-in repairs (XGMML only); none by default
      */
-    constructor(handler: XmlHandler) {
+    constructor(handler: XmlHandler, repairs?: XmlRepairs) {
         this.handler = handler;
+        this.repairs = repairs;
     }
 
     /**
@@ -677,6 +778,9 @@ export class XmlTokenizer {
                     if (amp >= pos && amp >= length - MAX_ENTITY_LENGTH && buffer.indexOf(";", amp) < 0) {
                         end = amp;
                     }
+                    if (this.repairs?.surrogatePair !== undefined) {
+                        end = this.holdHighSurrogate(pos, end);
+                    }
                 }
                 this.takeText(pos, end);
                 pos = end;
@@ -928,7 +1032,7 @@ export class XmlTokenizer {
                     this.line,
                 );
             }
-            attrs.set(attrName, decodeEntities(normalizeAttributeValue(raw), this.line));
+            attrs.set(attrName, decodeEntities(normalizeAttributeValue(raw), this.line, this.repairs));
             i = close + 1;
         }
     }
@@ -962,6 +1066,23 @@ export class XmlTokenizer {
         return j >= length && !this.final ? -1 : j;
     }
 
+    /**
+     * Under the surrogate-pair repair, hold back a high-surrogate character reference that ends
+     * the text taken so far, so it is decoded together with the low one the next chunk may start with.
+     * @param pos - the start of the text
+     * @param end - the end of the text that would be taken
+     * @returns the end to take up to
+     */
+    private holdHighSurrogate(pos: number, end: number): number {
+        const tail = this.buffer.slice(Math.max(pos, end - 12), end);
+        const match = TRAILING_CHAR_REFERENCE.exec(tail);
+        if (match === null) {
+            return end;
+        }
+        const unit = match[1] === undefined ? Number.parseInt(match[2], 10) : Number.parseInt(match[1], 16);
+        return unit >= 0xd800 && unit <= 0xdbff ? end - match[0].length : end;
+    }
+
     /**
      * Move text from the buffer into the current run.
      * @param start - the start index
@@ -978,7 +1099,7 @@ export class XmlTokenizer {
         if (hasIllegalXmlChar(raw)) {
             throw new XmlSyntaxError("a character XML 1.0 forbids appears in character data", this.line);
         }
-        this.text += decodeEntities(raw, this.line);
+        this.text += decodeEntities(raw, this.line, this.repairs);
         this.advanceLine(start, end);
     }
 

package/src/common/zip.ts

@@ -0,0 +1,472 @@
+/**
+ * A zip reader with no dependency (design `design/graph-io/cytoscape-and-obo/design.md` section
+ * 3.3; PKWARE APPNOTE 6.3.10, https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT), for
+ * the Cytoscape session importer.
+ *
+ * The whole archive is in memory: every Cytoscape-written entry has a data descriptor and zero
+ * sizes in its local header, so the sizes come from the central directory at the end. The end
+ * record is searched in the last 65,557 bytes (a comment can be 65,535 bytes long); the zip64
+ * locator and the `0x0001` extra field are followed; bytes prepended to the archive (a
+ * self-extracting stub) are tolerated by the shift between the directory's stated and actual
+ * offsets. Deflate (method 8) is inflated by wrapping the raw deflate bytes in a gzip member
+ * (header, data, the directory's CRC-32 and size) and passing it to `DecompressionStream("gzip")`,
+ * which every supported runtime has (Node 18, unlike `"deflate-raw"`) and which checks the CRC and
+ * the length itself; stored entries (method 0) are checked against a CRC-32 table here. Every
+ * other method, and encryption, is refused by name. Entry names are decoded by `decodeEntryName()`
+ * (the one place bytes become text) and are matching keys only, never paths.
+ */
+
+import { decodeEntryName, throwIfAborted } from "./input.js";
+
+/** Why a zip could not be read; the importer maps each kind to its own issue code. */
+type ZipErrorKind = "not-zip" | "corrupt" | "unsupported" | "too-large";
+
+/** A zip that cannot be read, or an entry that cannot be inflated. */
+export class ZipError extends Error {
+    /** What went wrong. */
+    readonly kind: ZipErrorKind;
+
+    /**
+     * Create the error.
+     * @param kind - what went wrong
+     * @param message - a plain-ASCII message
+     */
+    constructor(kind: ZipErrorKind, message: string) {
+        super(message);
+        this.name = "ZipError";
+        this.kind = kind;
+    }
+}
+
+/** One entry of the central directory. */
+export interface ZipEntry {
+    /** The name, decoded, as the central directory spells it. */
+    readonly name: string;
+    /** The compression method (0 stored, 8 deflate, ...). */
+    readonly method: number;
+    /** The general purpose bit flags. */
+    readonly flags: number;
+    /** The CRC-32 of the uncompressed data. */
+    readonly crc32: number;
+    /** The compressed size in bytes. */
+    readonly compressedSize: number;
+    /** The uncompressed size in bytes. */
+    readonly size: number;
+    /** The offset of the local header in the archive bytes (the prepended-data shift applied). */
+    readonly localOffset: number;
+    /** The name ends in `/`: a directory entry, which holds no data. */
+    readonly directory: boolean;
+}
+
+/** How one entry is read. */
+export interface ReadEntryOptions {
+    /** The cancellation signal. */
+    readonly signal?: AbortSignal | null | undefined;
+    /** Called with the bytes inflated so far by this call. */
+    readonly onBytes?: ((inflated: number) => void) | undefined;
+    /** The most uncompressed bytes this entry may have (the import's remaining budget). */
+    readonly maxBytes: number;
+    /** The largest uncompressed-to-compressed ratio allowed (above `RATIO_FLOOR` bytes). */
+    readonly maxRatio: number;
+}
+
+/** A per-entry size under which the ratio limit does not apply (tiny entries compress well). */
+export const RATIO_FLOOR = 1024 * 1024;
+
+const EOCD_SIGNATURE = 0x06054b50;
+const ZIP64_LOCATOR_SIGNATURE = 0x07064b50;
+const ZIP64_EOCD_SIGNATURE = 0x06064b50;
+const CENTRAL_SIGNATURE = 0x02014b50;
+const LOCAL_SIGNATURE = 0x04034b50;
+const EOCD_SIZE = 22;
+const MAX_COMMENT = 65535;
+const CENTRAL_SIZE = 46;
+const LOCAL_SIZE = 30;
+const ZIP64_EOCD_SIZE = 56;
+const ZIP64_LOCATOR_SIZE = 20;
+const U16_MAX = 0xffff;
+const U32_MAX = 0xffffffff;
+/** Bytes between two cancellation checks while a stored entry's CRC is computed. */
+const CRC_SLICE = 1024 * 1024;
+
+/** The compression methods other tools write, by number, for the refusal message. */
+const METHOD_NAMES: Readonly<Record<number, string>> = {
+    1: "shrink",
+    6: "implode",
+    9: "deflate64",
+    12: "bzip2",
+    14: "LZMA",
+    93: "zstd",
+    95: "xz",
+    96: "JPEG",
+    97: "WavPack",
+    98: "PPMd",
+    99: "AES encryption",
+};
+
+/**
+ * Whether bytes start with a local file header signature (`PK\x03\x04`).
+ * @param bytes - the bytes
+ * @returns true for the start of a zip
+ */
+export function startsLikeZip(bytes: Uint8Array): boolean {
+    return bytes.byteLength >= 4 && bytes[0] === 0x50 && bytes[1] === 0x4b && bytes[2] === 3 && bytes[3] === 4;
+}
+
+/**
+ * Read the central directory.
+ * @param bytes - the whole archive
+ * @returns the entries in directory order; ZipError "not-zip" when there is no end record and the
+ * bytes do not start like a zip, "corrupt" for an end record or directory that does not fit,
+ * "unsupported" for a split archive
+ */
+export function readZipDirectory(bytes: Uint8Array): ZipEntry[] {
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const eocd = findEndRecord(bytes, view);
+    if (eocd < 0) {
+        throw startsLikeZip(bytes)
+            ? new ZipError("corrupt", "the archive has no end of central directory record (truncated?)")
+            : new ZipError("not-zip", "the input is not a zip archive");
+    }
+    let disk = view.getUint16(eocd + 4, true);
+    let directoryDisk = view.getUint16(eocd + 6, true);
+    let count = view.getUint16(eocd + 10, true);
+    let directorySize = view.getUint32(eocd + 12, true);
+    let directoryOffset = view.getUint32(eocd + 16, true);
+    let directoryEnd = eocd;
+    const locator = eocd - ZIP64_LOCATOR_SIZE;
+    if (locator >= 0 && view.getUint32(locator, true) === ZIP64_LOCATOR_SIGNATURE) {
+        const record = zip64EndRecord(view, locator);
+        disk = view.getUint32(record + 16, true);
+        directoryDisk = view.getUint32(record + 20, true);
+        count = readU64(view, record + 32);
+        directorySize = readU64(view, record + 40);
+        directoryOffset = readU64(view, record + 48);
+        directoryEnd = record;
+    } else if (count === U16_MAX || directorySize === U32_MAX || directoryOffset === U32_MAX) {
+        throw new ZipError("corrupt", "the end record needs a zip64 record the archive does not have");
+    }
+    if (disk !== 0 || directoryDisk !== 0) {
+        throw new ZipError("unsupported", "a split (multi-disk) archive cannot be read");
+    }
+    const start = directoryEnd - directorySize;
+    if (start < 0 || directoryOffset > bytes.byteLength) {
+        throw new ZipError("corrupt", "the central directory lies outside the archive");
+    }
+    // data prepended to the archive moves every offset by the same amount
+    const shift = start - directoryOffset;
+    if (shift < 0) {
+        throw new ZipError("corrupt", "the central directory offset does not match its position");
+    }
+    const entries: ZipEntry[] = [];
+    let at = start;
+    for (let i = 0; i < count; i++) {
+        if (at + CENTRAL_SIZE > directoryEnd || view.getUint32(at, true) !== CENTRAL_SIGNATURE) {
+            throw new ZipError("corrupt", `central directory entry ${i + 1} of ${count} is damaged`);
+        }
+        const nameLength = view.getUint16(at + 28, true);
+        const extraLength = view.getUint16(at + 30, true);
+        const commentLength = view.getUint16(at + 32, true);
+        const next = at + CENTRAL_SIZE + nameLength + extraLength + commentLength;
+        if (next > directoryEnd) {
+            throw new ZipError("corrupt", `central directory entry ${i + 1} runs past the directory`);
+        }
+        const name = decodeEntryName(bytes.subarray(at + CENTRAL_SIZE, at + CENTRAL_SIZE + nameLength));
+        let compressedSize = view.getUint32(at + 20, true);
+        let size = view.getUint32(at + 24, true);
+        let localOffset = view.getUint32(at + 42, true);
+        if (compressedSize === U32_MAX || size === U32_MAX || localOffset === U32_MAX) {
+            ({ compressedSize, size, localOffset } = zip64Extra(view, at + CENTRAL_SIZE + nameLength, extraLength, {
+                compressedSize,
+                size,
+                localOffset,
+            }));
+        }
+        entries.push(
+            Object.freeze({
+                name,
+                method: view.getUint16(at + 10, true),
+                flags: view.getUint16(at + 8, true),
+                crc32: view.getUint32(at + 16, true),
+                compressedSize,
+                size,
+                localOffset: localOffset + shift,
+                directory: name.endsWith("/"),
+            }),
+        );
+        at = next;
+    }
+    return entries;
+}
+
+/**
+ * The position of the end of central directory record: the last signature whose comment length
+ * fits the archive, else the last signature at all (an archive with bytes after its comment).
+ * @param bytes - the archive
+ * @param view - a view of it
+ * @returns the offset, or -1
+ */
+function findEndRecord(bytes: Uint8Array, view: DataView): number {
+    const lowest = Math.max(0, bytes.byteLength - EOCD_SIZE - MAX_COMMENT);
+    let fallback = -1;
+    for (let at = bytes.byteLength - EOCD_SIZE; at >= lowest; at--) {
+        if (view.getUint32(at, true) !== EOCD_SIGNATURE) {
+            continue;
+        }
+        if (at + EOCD_SIZE + view.getUint16(at + 20, true) === bytes.byteLength) {
+            return at;
+        }
+        if (fallback < 0) {
+            fallback = at;
+        }
+    }
+    return fallback;
+}
+
+/**
+ * The zip64 end of central directory record a locator points at (or, when the archive has bytes
+ * prepended, the one right before the locator).
+ * @param view - the archive
+ * @param locator - the locator's offset
+ * @returns the record's offset
+ */
+function zip64EndRecord(view: DataView, locator: number): number {
+    const stated = readU64(view, locator + 8);
+    for (const at of [stated, locator - ZIP64_EOCD_SIZE]) {
+        if (at >= 0 && at + ZIP64_EOCD_SIZE <= locator && view.getUint32(at, true) === ZIP64_EOCD_SIGNATURE) {
+            return at;
+        }
+    }
+    throw new ZipError("corrupt", "the zip64 end record the locator names is missing");
+}
+
+/**
+ * The zip64 extended information extra field (header id 0x0001) of a central entry: the 64-bit
+ * values of the fields whose 32-bit slot is 0xFFFFFFFF, in the order APPNOTE 4.5.3 gives.
+ * @param view - the archive
+ * @param at - the start of the extra field
+ * @param length - its length
+ * @param fields - the 32-bit values
+ * @param fields.compressedSize - the compressed size slot
+ * @param fields.size - the uncompressed size slot
+ * @param fields.localOffset - the local header offset slot
+ * @returns the resolved values
+ */
+function zip64Extra(
+    view: DataView,
+    at: number,
+    length: number,
+    fields: { compressedSize: number; size: number; localOffset: number },
+): { compressedSize: number; size: number; localOffset: number } {
+    const out = { ...fields };
+    for (let p = at; p + 4 <= at + length; ) {
+        const id = view.getUint16(p, true);
+        const dataLength = view.getUint16(p + 2, true);
+        if (id === 1) {
+            let q = p + 4;
+            const end = q + dataLength;
+            for (const key of ["size", "compressedSize", "localOffset"] as const) {
+                if (fields[key] === U32_MAX) {
+                    if (q + 8 > end) {
+                        throw new ZipError("corrupt", "a zip64 extra field is too short");
+                    }
+                    out[key] = readU64(view, q);
+                    q += 8;
+                }
+            }
+            return out;
+        }
+        p += 4 + dataLength;
+    }
+    throw new ZipError("corrupt", "an entry needs a zip64 extra field it does not have");
+}
+
+/**
+ * An unsigned 64-bit little-endian integer as a number (exact up to 2^53).
+ * @param view - the bytes
+ * @param at - the offset
+ * @returns the value; ZipError "unsupported" beyond 2^53
+ */
+function readU64(view: DataView, at: number): number {
+    const high = view.getUint32(at + 4, true);
+    if (high >= 0x200000) {
+        throw new ZipError("unsupported", "a zip64 size or offset beyond 2^53 cannot be read");
+    }
+    return high * 0x100000000 + view.getUint32(at, true);
+}
+
+/**
+ * Read one entry's data: stored entries are sliced and CRC-checked, deflated ones inflated.
+ * @param bytes - the whole archive
+ * @param entry - the entry
+ * @param options - cancellation, progress and the size limits
+ * @returns the uncompressed bytes; ZipError for a damaged, encrypted, unsupported or oversized entry
+ */
+export async function readZipEntry(bytes: Uint8Array, entry: ZipEntry, options: ReadEntryOptions): Promise<Uint8Array> {
+    if ((entry.flags & 1) !== 0 || entry.method === 99) {
+        throw new ZipError("unsupported", `${entry.name}: the entry is encrypted`);
+    }
+    if (entry.method !== 0 && entry.method !== 8) {
+        const name = METHOD_NAMES[entry.method] ?? `method ${entry.method}`;
+        throw new ZipError(
+            "unsupported",
+            `${entry.name}: compression ${name} is not supported (only stored and deflate)`,
+        );
+    }
+    if (entry.size > options.maxBytes) {
+        throw new ZipError(
+            "too-large",
+            `${entry.name}: ${entry.size} uncompressed bytes exceed the limit of ${options.maxBytes}`,
+        );
+    }
+    if (entry.size > RATIO_FLOOR && entry.size > options.maxRatio * Math.max(entry.compressedSize, 1)) {
+        throw new ZipError(
+            "too-large",
+            `${entry.name}: ${entry.size} bytes from ${entry.compressedSize} is a compression ratio above ${options.maxRatio}:1`,
+        );
+    }
+    const data = entryData(bytes, entry);
+    if (entry.method === 0) {
+        if (data.byteLength !== entry.size) {
+            throw new ZipError("corrupt", `${entry.name}: a stored entry's sizes disagree`);
+        }
+        let crc = 0xffffffff;
+        for (let at = 0; at < data.byteLength; at += CRC_SLICE) {
+            throwIfAborted(options.signal);
+            crc = crcUpdate(crc, data.subarray(at, Math.min(at + CRC_SLICE, data.byteLength)));
+            options.onBytes?.(Math.min(at + CRC_SLICE, data.byteLength));
+        }
+        if ((crc ^ 0xffffffff) >>> 0 !== entry.crc32) {
+            throw new ZipError("corrupt", `${entry.name}: the data does not match its CRC-32`);
+        }
+        return data;
+    }
+    return inflate(data, entry, options);
+}
+
+/**
+ * The compressed bytes of an entry, located through its local header (whose name and extra
+ * lengths can differ from the central directory's).
+ * @param bytes - the archive
+ * @param entry - the entry
+ * @returns exactly compressedSize bytes
+ */
+function entryData(bytes: Uint8Array, entry: ZipEntry): Uint8Array {
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const at = entry.localOffset;
+    if (at + LOCAL_SIZE > bytes.byteLength || view.getUint32(at, true) !== LOCAL_SIGNATURE) {
+        throw new ZipError("corrupt", `${entry.name}: the local header is missing`);
+    }
+    const start = at + LOCAL_SIZE + view.getUint16(at + 26, true) + view.getUint16(at + 28, true);
+    const end = start + entry.compressedSize;
+    if (end > bytes.byteLength) {
+        throw new ZipError("corrupt", `${entry.name}: the entry's data runs past the end of the archive (truncated?)`);
+    }
+    return bytes.subarray(start, end);
+}
+
+/**
+ * Inflate a deflate stream through `DecompressionStream("gzip")`, wrapped in a gzip member that
+ * carries the directory's CRC-32 and size, so the platform checks both.
+ * @param data - the raw deflate bytes
+ * @param entry - the entry
+ * @param options - cancellation, progress and limits
+ * @returns the bytes
+ */
+async function inflate(data: Uint8Array, entry: ZipEntry, options: ReadEntryOptions): Promise<Uint8Array> {
+    if (typeof DecompressionStream !== "function") {
+        throw new ZipError(
+            "unsupported",
+            "this runtime has no DecompressionStream, so deflated entries cannot be read",
+        );
+    }
+    const member = new Uint8Array(10 + data.byteLength + 8);
+    member.set([0x1f, 0x8b, 8, 0, 0, 0, 0, 0, 0, 0xff]);
+    member.set(data, 10);
+    const trailer = new DataView(member.buffer, 10 + data.byteLength, 8);
+    trailer.setUint32(0, entry.crc32, true);
+    trailer.setUint32(4, entry.size % 0x100000000, true);
+    const source = new ReadableStream<BufferSource>({
+        start(controller): void {
+            controller.enqueue(member);
+            controller.close();
+        },
+    });
+    const reader = source.pipeThrough(new DecompressionStream("gzip")).getReader();
+    const parts: Uint8Array[] = [];
+    let total = 0;
+    try {
+        for (;;) {
+            throwIfAborted(options.signal);
+            let chunk: ReadableStreamReadResult<Uint8Array>;
+            try {
+                chunk = await reader.read();
+            } catch {
+                throw new ZipError(
+                    "corrupt",
+                    `${entry.name}: the deflate data is damaged or does not match its CRC-32 and size`,
+                );
+            }
+            if (chunk.done) {
+                break;
+            }
+            total += chunk.value.byteLength;
+            if (total > entry.size) {
+                throw new ZipError("corrupt", `${entry.name}: the data is longer than its directory size`);
+            }
+            parts.push(chunk.value);
+            options.onBytes?.(total);
+        }
+    } finally {
+        await reader.cancel().catch(() => undefined);
+    }
+    if (total !== entry.size) {
+        throw new ZipError("corrupt", `${entry.name}: the data is shorter than its directory size`);
+    }
+    if (parts.length === 1) {
+        return parts[0];
+    }
+    const out = new Uint8Array(total);
+    let at = 0;
+    for (const part of parts) {
+        out.set(part, at);
+        at += part.byteLength;
+    }
+    return out;
+}
+
+/** The CRC-32 table (polynomial 0xEDB88320). */
+const CRC_TABLE = ((): Uint32Array => {
+    const table = new Uint32Array(256);
+    for (let n = 0; n < 256; n++) {
+        let c = n;
+        for (let k = 0; k < 8; k++) {
+            c = (c & 1) === 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+        }
+        table[n] = c >>> 0;
+    }
+    return table;
+})();
+
+/**
+ * Continue a CRC-32 over more bytes.
+ * @param crc - the running value (start with 0xFFFFFFFF)
+ * @param bytes - the bytes
+ * @returns the running value (XOR with 0xFFFFFFFF to finish)
+ */
+function crcUpdate(crc: number, bytes: Uint8Array): number {
+    let c = crc;
+    for (const byte of bytes) {
+        c = CRC_TABLE[(c ^ byte) & 0xff] ^ (c >>> 8);
+    }
+    return c >>> 0;
+}
+
+/**
+ * The CRC-32 of bytes.
+ * @param bytes - the bytes
+ * @returns the checksum
+ */
+export function crc32(bytes: Uint8Array): number {
+    return (crcUpdate(0xffffffff, bytes) ^ 0xffffffff) >>> 0;
+}