brane 0.0.2 → 0.3.0

package/dist/files/codecs.js

@@ -0,0 +1,33 @@
+// The decompressors the Files view uses, all of them Node's own zlib. No
+// archive tool is ever shelled out to: `unzip` and `bsdtar` are C with CVE
+// histories, and bsdtar in particular auto-detects dozens of formats nobody
+// asked it to parse.
+import { createReadStream } from "node:fs";
+import { pipeline } from "node:stream";
+import * as zlib from "node:zlib";
+/** zstd arrived in Node 22.15 / 23.8. Below that, `.zst` files are simply
+ *  not archives, and open as the binary they are. */
+const createZstd = zlib
+    .createZstdDecompress;
+export const HAS_ZSTD = typeof createZstd === "function";
+function decompressor(codec) {
+    switch (codec) {
+        case "gzip": return zlib.createGunzip();
+        case "brotli": return zlib.createBrotliDecompress();
+        case "deflate-raw": return zlib.createInflateRaw();
+        case "zstd":
+            if (!createZstd)
+                throw new Error("zstd is not supported by this Node");
+            return createZstd();
+    }
+}
+/** Bytes of `path` (or of bytes [start, end] of it), decoded by `codec` —
+ *  or as they are, for null. The pipeline is torn down whole when the returned
+ *  stream is destroyed, so a reader that stops early leaves no handle behind. */
+export function openDecoded(path, codec, start, end) {
+    const src = createReadStream(path, start === undefined ? {} : { start, end });
+    if (codec === null)
+        return src;
+    return pipeline(src, decompressor(codec), () => { });
+}
+//# sourceMappingURL=codecs.js.map

package/dist/files/find.js

@@ -0,0 +1,212 @@
+// GET /api/files/find: search a file's bytes, all of them, for the hex view.
+//
+// 🔎 on a hex page used to search the text in the DOM, which knew only the
+// pages already loaded, split every string that wrapped a row, and read
+// `cffaedfe` as four letters rather than four bytes. This reads the bytes
+// themselves, through the same ByteSource the hex page does, so an archive
+// member or a `.gz` body is searched as it is shown.
+//
+// What it returns is bounded by *pages*, not by the file: hits from at most
+// the first FIND_PAGE_WINDOW hex pages that contain any. A one-byte query in
+// a 2 GB binary stops after a megabyte of hits instead of reading two
+// gigabytes to produce hits nobody will visit, and the reader asks for the
+// next window if they want it (`from`).
+import { HEX_PAGE_BYTES } from "../shared/hex-dump.js";
+import { MAX_FIND_MATCHES, isCaseSensitive } from "../shared/find-in-text.js";
+import { ReachError } from "./bytes.js";
+/** Distinct hex pages a search window may put hits on. 64 pages is 1 MB: as
+ *  much as the hex view will hold at once. */
+export const FIND_PAGE_WINDOW = 64;
+/** The longest needle, in bytes. */
+export const MAX_NEEDLE_BYTES = 256;
+/** How long one request may scan before it hands back a `next` offset. */
+export const FIND_TIME_BUDGET_MS = 30_000;
+/** How often a scan reports how far it has read. */
+export const FIND_PROGRESS_MS = 250;
+/** Scans running at once, daemon-wide. A new one past this supersedes the
+ *  oldest rather than being refused: the likeliest reason there are three is
+ *  a reader typing, whose earlier queries nobody is waiting on. */
+export const MAX_CONCURRENT_FINDS = 2;
+/** `cf fa ed fe`, `cffaedfe`, `0xCAFE`: an even run of hex digits, spaces
+ *  allowed between bytes. */
+const HEX_QUERY = /^\s*(?:0x)?((?:[0-9a-f]{2}\s*)+)$/i;
+/** What a query asks for, as bytes. Always its UTF-8 text, smart-case as 🔎 is
+ *  everywhere else; and, when it reads as hex, those bytes too — `cafe` is
+ *  both the word and 0xCA 0xFE, and the reader gets both. The query is not
+ *  trimmed, as in `findMatches`: a trailing space is part of what's asked. */
+export function parseByteQuery(query) {
+    if (!query)
+        return [];
+    const needles = [];
+    const caseless = !isCaseSensitive(query);
+    const text = Buffer.from(caseless ? asciiLower(query) : query, "utf8");
+    needles.push({ kind: "text", bytes: text, caseless });
+    const hex = HEX_QUERY.exec(query);
+    if (hex) {
+        // Never the same bytes as the text: 2n hex digits spell n bytes.
+        needles.push({ kind: "hex", bytes: Buffer.from(hex[1].replace(/\s+/g, ""), "hex"), caseless: false });
+    }
+    return needles;
+}
+/** Lowercase A–Z only. `toLowerCase` would fold `İ` into two code points and
+ *  shift every byte after it. */
+function asciiLower(s) {
+    return s.replace(/[A-Z]+/g, (m) => m.toLowerCase());
+}
+function foldAscii(buf) {
+    const out = Buffer.allocUnsafe(buf.length);
+    for (let i = 0; i < buf.length; i++) {
+        const b = buf[i];
+        out[i] = b >= 0x41 && b <= 0x5a ? b | 0x20 : b;
+    }
+    return out;
+}
+/** Search `source` from `from` for any of `needles`, reporting hits in offset
+ *  order. Hits of one needle don't overlap; hits of two needles may.
+ *
+ *  Order is exact even across the chunks the file is read in: a hit is
+ *  reported only once every needle that could start before it has been
+ *  seen whole, so the tail of each chunk (one byte short of the longest
+ *  needle) waits for the next. That's what lets the page count be a running
+ *  count, and `next` a place to resume that skips nothing. */
+export async function scanSource(source, needles, from, emit, opts = {}) {
+    const pageBytes = opts.pageBytes ?? HEX_PAGE_BYTES;
+    const maxPages = opts.maxPages ?? FIND_PAGE_WINDOW;
+    const maxHits = opts.maxHits ?? MAX_FIND_MATCHES;
+    const budgetMs = opts.budgetMs ?? FIND_TIME_BUDGET_MS;
+    const progressMs = opts.progressMs ?? FIND_PROGRESS_MS;
+    const now = opts.now ?? Date.now;
+    const started = now();
+    let lastProgress = started;
+    const done = (stop, scanned, next) => {
+        const event = { type: "done", stop, scanned, next };
+        emit(event);
+        return event;
+    };
+    if (needles.length === 0)
+        return done("eof", from, null);
+    const longest = Math.max(...needles.map((n) => n.bytes.length));
+    const anyCaseless = needles.some((n) => n.caseless);
+    // Per needle, where its next hit may start: the end of its last one.
+    const allowed = needles.map(() => from);
+    let hitCount = 0;
+    let pages = 0;
+    let lastPage = -1;
+    // `carry` holds the bytes at [base, readTo) not yet ruled out as the start
+    // of a hit.
+    let carry = Buffer.alloc(0);
+    let base = from;
+    let readTo = from;
+    /** Report the hits starting before `limit` in carry+chunk, or stop. */
+    const settle = (buf, limit) => {
+        const folded = anyCaseless ? foldAscii(buf) : null;
+        const found = [];
+        needles.forEach((needle, n) => {
+            const hay = needle.caseless ? folded : buf;
+            let i = Math.max(0, allowed[n] - base);
+            while (true) {
+                const at = hay.indexOf(needle.bytes, i);
+                if (at < 0 || base + at >= limit)
+                    break;
+                found.push({ at: base + at, len: needle.bytes.length, n });
+                i = at + needle.bytes.length;
+            }
+        });
+        found.sort((a, b) => a.at - b.at || a.n - b.n);
+        const hits = [];
+        let stop = null;
+        for (const f of found) {
+            if (f.at < allowed[f.n])
+                continue;
+            const first = Math.floor(f.at / pageBytes);
+            const last = Math.floor((f.at + f.len - 1) / pageBytes);
+            const added = (last > lastPage ? last - Math.max(first, lastPage + 1) + 1 : 0);
+            if (hitCount >= maxHits) {
+                stop = { type: "done", stop: "hits", scanned: readTo, next: f.at };
+                break;
+            }
+            if (pages + added > maxPages) {
+                stop = { type: "done", stop: "pages", scanned: readTo, next: f.at };
+                break;
+            }
+            pages += added;
+            lastPage = Math.max(lastPage, last);
+            hitCount++;
+            allowed[f.n] = f.at + f.len;
+            hits.push([f.at, f.len]);
+        }
+        if (hits.length)
+            emit({ type: "hits", hits });
+        if (stop)
+            emit(stop);
+        return stop;
+    };
+    try {
+        for await (const chunk of source.chunks(from)) {
+            // Resume where nothing has been ruled out yet: `carry` still holds
+            // bytes that may start a hit not reported.
+            if (opts.signal?.aborted)
+                return done("cancelled", readTo, base);
+            const buf = carry.length ? Buffer.concat([carry, chunk]) : chunk;
+            readTo += chunk.length;
+            // A hit starting at or past `limit` might not be whole yet.
+            const limit = readTo - (longest - 1);
+            const stop = settle(buf, limit);
+            if (stop)
+                return stop;
+            const keepFrom = Math.max(base, limit);
+            carry = buf.subarray(keepFrom - base);
+            base = keepFrom;
+            const t = now();
+            if (t - started >= budgetMs) {
+                return done("time", readTo, base);
+            }
+            if (t - lastProgress >= progressMs) {
+                lastProgress = t;
+                emit({ type: "progress", scanned: readTo });
+            }
+        }
+    }
+    catch (e) {
+        if (!(e instanceof ReachError))
+            throw e;
+        return settle(carry, readTo) ?? done("reach", readTo, null);
+    }
+    if (opts.signal?.aborted)
+        return done("cancelled", readTo, base);
+    return settle(carry, Infinity) ?? done("eof", readTo, null);
+}
+/** At most MAX_CONCURRENT_FINDS scans at once; admitting one past that
+ *  cancels the oldest. */
+export class FindSlots {
+    max;
+    running = new Set();
+    constructor(max = MAX_CONCURRENT_FINDS) {
+        this.max = max;
+    }
+    /** A signal for the new scan, and the release to call when it ends. */
+    admit() {
+        while (this.running.size >= this.max) {
+            const oldest = this.running.values().next().value;
+            this.running.delete(oldest);
+            oldest.abort();
+        }
+        const c = new AbortController();
+        this.running.add(c);
+        return { signal: c.signal, release: () => this.running.delete(c) };
+    }
+    get size() {
+        return this.running.size;
+    }
+}
+/** Parse `q`: the query, or why it can't be searched. */
+export function parseFindQuery(q) {
+    if (!q)
+        return { error: "q is required" };
+    const needles = parseByteQuery(q);
+    if (needles.some((n) => n.bytes.length > MAX_NEEDLE_BYTES)) {
+        return { error: `The query is longer than ${MAX_NEEDLE_BYTES} bytes` };
+    }
+    return needles;
+}
+//# sourceMappingURL=find.js.map

package/dist/files/tar.js

@@ -0,0 +1,223 @@
+// Tar, read as a stream of 512-byte headers with the data between them skipped
+// rather than kept. A `.tar` is read from the file directly; a `.tar.gz` (or
+// `.br`, `.zst`) from its decoder, which has to run the whole archive through
+// once to list it, since compressed tar has no index. The scan is bounded in
+// bytes and members, and a member's body is decoded only as far as a request
+// reaches (`bytes.ts`).
+//
+// Understood: ustar (with its name prefix), GNU long names and link names
+// (`L`, `K`), pax extended headers (`x`: path, linkpath, size, mtime), and
+// base-256 sizes. Everything else is listed as what it is and not opened.
+const BLOCK = 512;
+/** A long name or pax header bigger than this is not a name. */
+const MAX_META_BYTES = 64 * 1024;
+export class TarFormatError extends Error {
+}
+function cstr(b, start, len) {
+    const end = b.indexOf(0, start);
+    return b.toString("utf8", start, end < 0 || end > start + len ? start + len : end);
+}
+function octal(b, start, len) {
+    // Base-256: the high bit of the first byte set, big-endian after it.
+    if (b[start] & 0x80) {
+        let n = b[start] & 0x7f;
+        for (let i = 1; i < len; i++) {
+            n = n * 256 + b[start + i];
+            if (n > Number.MAX_SAFE_INTEGER)
+                throw new TarFormatError("size out of range");
+        }
+        return n;
+    }
+    const s = cstr(b, start, len).trim();
+    if (s === "")
+        return 0;
+    if (!/^[0-7]+$/.test(s))
+        throw new TarFormatError(`bad octal field "${s}"`);
+    return parseInt(s, 8);
+}
+function checksumOk(h) {
+    let sum = 0;
+    for (let i = 0; i < BLOCK; i++)
+        sum += i >= 148 && i < 156 ? 0x20 : h[i];
+    let stored;
+    try {
+        stored = octal(h, 148, 8);
+    }
+    catch {
+        return false;
+    }
+    return sum === stored;
+}
+function parsePax(body, into) {
+    let p = 0;
+    while (p < body.length) {
+        const sp = body.indexOf(0x20, p);
+        if (sp < 0)
+            break;
+        const len = parseInt(body.toString("utf8", p, sp), 10);
+        if (!Number.isFinite(len) || len <= 0 || p + len > body.length)
+            break;
+        const rec = body.toString("utf8", sp + 1, p + len - 1); // drop the "\n"
+        const eq = rec.indexOf("=");
+        if (eq > 0) {
+            const key = rec.slice(0, eq);
+            const value = rec.slice(eq + 1);
+            if (key === "path")
+                into.path = value;
+            else if (key === "linkpath")
+                into.linkpath = value;
+            else if (key === "size" && /^\d+$/.test(value))
+                into.size = Number(value);
+            else if (key === "mtime" && Number.isFinite(Number(value)))
+                into.mtimeMs = Number(value) * 1000;
+        }
+        p += len;
+    }
+}
+function kindOf(type) {
+    switch (type) {
+        case "0":
+        case "\0":
+        case "7": return "file";
+        case "5": return "dir";
+        case "2": return "symlink";
+        case "1": return "hardlink";
+        default: return "other";
+    }
+}
+/** Reads `stream` as tar, listing every member. The first header must pass
+ *  its checksum, so a file that isn't tar is refused at the first block. */
+export async function scanTar(stream, openBody, limits) {
+    const members = [];
+    let partial = false;
+    let pending = {};
+    // `buf` holds decoded bytes [pos, pos + buf.length): only ever what the next
+    // header or a pending metadata body still needs. Member data is never
+    // buffered; chunks that fall wholly inside it are dropped as they arrive.
+    let buf = Buffer.alloc(0);
+    let pos = 0;
+    let streamPos = 0;
+    /** Where the next header starts. */
+    let next = 0;
+    /** A metadata body (long name, pax) being collected, and what it is for. */
+    let meta = null;
+    let done = false;
+    const want = () => (meta ? meta.at : next);
+    try {
+        for await (const chunk of stream) {
+            const chunkStart = streamPos;
+            streamPos += chunk.length;
+            if (buf.length === 0) {
+                if (streamPos <= want()) {
+                    pos = streamPos;
+                    if (streamPos > limits.maxScanBytes) {
+                        partial = true;
+                        done = true;
+                        break;
+                    }
+                    continue;
+                }
+                const from = Math.max(0, want() - chunkStart);
+                buf = chunk.subarray(from);
+                pos = chunkStart + from;
+            }
+            else {
+                buf = Buffer.concat([buf, chunk]);
+            }
+            for (;;) {
+                if (meta) {
+                    const end = meta.at + meta.size;
+                    if (pos + buf.length < end)
+                        break;
+                    const body = buf.subarray(meta.at - pos, end - pos);
+                    if (meta.type === "x")
+                        parsePax(body, pending);
+                    else if (meta.type === "L")
+                        pending.path = cstr(body, 0, body.length);
+                    else if (meta.type === "K")
+                        pending.linkpath = cstr(body, 0, body.length);
+                    meta = null;
+                }
+                if (next > limits.maxScanBytes) {
+                    partial = true;
+                    done = true;
+                    break;
+                }
+                if (pos + buf.length < next + BLOCK)
+                    break;
+                const h = buf.subarray(next - pos, next - pos + BLOCK);
+                if (h.every((b) => b === 0)) {
+                    done = true;
+                    break;
+                }
+                if (!checksumOk(h)) {
+                    if (next === 0)
+                        throw new TarFormatError("not a tar archive");
+                    // A corrupt header mid-archive: what came before it still stands.
+                    partial = true;
+                    done = true;
+                    break;
+                }
+                const type = String.fromCharCode(h[156]);
+                const headerSize = octal(h, 124, 12);
+                const dataAt = next + BLOCK;
+                const isMeta = type === "x" || type === "L" || type === "K" || type === "g";
+                const size = isMeta ? headerSize : pending.size ?? headerSize;
+                next = dataAt + Math.ceil(size / BLOCK) * BLOCK;
+                if (type === "x" || type === "L" || type === "K") {
+                    if (size > MAX_META_BYTES)
+                        throw new TarFormatError("oversized extended header");
+                    meta = { type, size, at: dataAt };
+                }
+                else if (type === "g") {
+                    // Global pax header: nothing in it changes what we show.
+                }
+                else {
+                    if (members.length >= limits.maxEntries) {
+                        partial = true;
+                        done = true;
+                        break;
+                    }
+                    const magic = h.toString("latin1", 257, 262);
+                    const prefix = magic === "ustar" ? cstr(h, 345, 155) : "";
+                    const base = cstr(h, 0, 100);
+                    const name = pending.path ?? (prefix ? `${prefix}/${base}` : base);
+                    const kind = kindOf(type);
+                    const mtimeMs = pending.mtimeMs ?? octal(h, 136, 12) * 1000;
+                    const link = pending.linkpath ?? cstr(h, 157, 100);
+                    members.push({
+                        name,
+                        kind,
+                        size: kind === "file" ? size : null,
+                        mtimeMs,
+                        link: kind === "symlink" || kind === "hardlink" ? link : undefined,
+                        open: kind === "file" ? () => openBody(dataAt, size, mtimeMs) : undefined,
+                    });
+                    pending = {};
+                }
+                const keepFrom = want();
+                if (keepFrom >= pos + buf.length) {
+                    pos += buf.length;
+                    buf = Buffer.alloc(0);
+                    break;
+                }
+                buf = buf.subarray(keepFrom - pos);
+                pos = keepFrom;
+            }
+            if (done)
+                break;
+        }
+    }
+    finally {
+        stream.destroy();
+    }
+    if (!done) {
+        if (members.length === 0)
+            throw new TarFormatError("not a tar archive");
+        // Ended inside a member: the archive was cut short.
+        if (streamPos < next)
+            partial = true;
+    }
+    return { members, partial };
+}
+//# sourceMappingURL=tar.js.map

package/dist/files/zip.js

@@ -0,0 +1,209 @@
+// Zip, read from its central directory. The directory at the end of the file
+// lists every member with its size and where its bytes start, so a listing
+// decompresses nothing, and opening a member inflates that member alone.
+//
+// Nothing here trusts the file: every offset is checked against the file's
+// real size before it is read, sizes a member claims are only displayed, and
+// a member's body is inflated only as far as a request reaches.
+import { MAX_STREAM_REACH, deferredSource, fileSource, readAt, streamSource } from "./bytes.js";
+import { openDecoded } from "./codecs.js";
+const SIG_EOCD = 0x06054b50;
+const SIG_EOCD64 = 0x06064b50;
+const SIG_EOCD64_LOCATOR = 0x07064b50;
+const SIG_CENTRAL = 0x02014b50;
+const SIG_LOCAL = 0x04034b50;
+/** A central directory past this is refused rather than read into memory. At
+ *  ~80 bytes a record it is some 800,000 members. */
+const MAX_CENTRAL_DIR = 64 * 1024 * 1024;
+const EOCD_MIN = 22;
+const EOCD_SEARCH = EOCD_MIN + 0xffff;
+export class ZipFormatError extends Error {
+}
+export class MemberError extends Error {
+}
+async function findEocd(path, size) {
+    if (size < EOCD_MIN)
+        throw new ZipFormatError("too small to be a zip");
+    const tailLen = Math.min(size, EOCD_SEARCH);
+    const tailStart = size - tailLen;
+    const tail = await readAt(path, tailStart, tailLen);
+    for (let i = tail.length - EOCD_MIN; i >= 0; i--) {
+        if (tail.readUInt32LE(i) !== SIG_EOCD)
+            continue;
+        const commentLen = tail.readUInt16LE(i + 20);
+        if (i + EOCD_MIN + commentLen > tail.length)
+            continue;
+        const eocdPos = tailStart + i;
+        let entries = tail.readUInt16LE(i + 10);
+        let cdSize = tail.readUInt32LE(i + 12);
+        let cdOffset = tail.readUInt32LE(i + 16);
+        let recordEnd = eocdPos;
+        if (entries === 0xffff || cdSize === 0xffffffff || cdOffset === 0xffffffff) {
+            const z64 = await readZip64(path, eocdPos);
+            if (z64)
+                ({ entries, cdSize, cdOffset, recordEnd } = z64);
+        }
+        // In a well-formed zip the central directory ends where the end record
+        // (or its zip64 twin) begins. Past that is a prepended stub.
+        const shift = recordEnd - (cdOffset + cdSize);
+        if (shift < 0)
+            throw new ZipFormatError("central directory overruns the end record");
+        return { entries, cdSize, cdOffset, shift };
+    }
+    throw new ZipFormatError("no end-of-central-directory record");
+}
+async function readZip64(path, eocdPos) {
+    if (eocdPos < 20)
+        return null;
+    const loc = await readAt(path, eocdPos - 20, 20);
+    if (loc.readUInt32LE(0) !== SIG_EOCD64_LOCATOR)
+        return null;
+    const recordEnd = eocdPos - 20;
+    // The locator's offset is unshifted too; the record sits just before it.
+    const at = recordEnd - 56;
+    if (at < 0)
+        throw new ZipFormatError("zip64 record out of range");
+    const rec = await readAt(path, at, 56);
+    if (rec.readUInt32LE(0) !== SIG_EOCD64)
+        throw new ZipFormatError("bad zip64 end record");
+    return {
+        entries: safeNumber(rec.readBigUInt64LE(32)),
+        cdSize: safeNumber(rec.readBigUInt64LE(40)),
+        cdOffset: safeNumber(rec.readBigUInt64LE(48)),
+        recordEnd: at,
+    };
+}
+function safeNumber(n) {
+    if (n > BigInt(Number.MAX_SAFE_INTEGER))
+        throw new ZipFormatError("zip64 field out of range");
+    return Number(n);
+}
+function dosTime(date, time) {
+    if (date === 0)
+        return 0;
+    return new Date((date >> 9) + 1980, ((date >> 5) & 15) - 1, date & 31, time >> 11, (time >> 5) & 63, (time & 31) * 2).getTime();
+}
+/** Every member of the zip at `path`, in directory order, names undecoded by
+ *  any policy — `archive.ts` decides which names are safe to show. */
+export async function listZip(path, size, maxEntries) {
+    const eocd = await findEocd(path, size);
+    const { cdSize, shift } = eocd;
+    const cdStart = eocd.cdOffset + shift;
+    if (cdSize > MAX_CENTRAL_DIR)
+        throw new ZipFormatError("central directory too large");
+    if (cdStart + cdSize > size)
+        throw new ZipFormatError("central directory out of range");
+    const cd = await readAt(path, cdStart, cdSize);
+    const members = [];
+    let partial = false;
+    let p = 0;
+    while (p + 46 <= cd.length && members.length < eocd.entries) {
+        if (members.length >= maxEntries) {
+            partial = true;
+            break;
+        }
+        if (cd.readUInt32LE(p) !== SIG_CENTRAL)
+            throw new ZipFormatError("bad central directory record");
+        const madeBy = cd.readUInt16LE(p + 4);
+        const flags = cd.readUInt16LE(p + 8);
+        const method = cd.readUInt16LE(p + 10);
+        const mtimeMs = dosTime(cd.readUInt16LE(p + 14), cd.readUInt16LE(p + 12));
+        let csize = cd.readUInt32LE(p + 20);
+        let usize = cd.readUInt32LE(p + 24);
+        const nameLen = cd.readUInt16LE(p + 28);
+        const extraLen = cd.readUInt16LE(p + 30);
+        const commentLen = cd.readUInt16LE(p + 32);
+        const extAttr = cd.readUInt32LE(p + 38);
+        let localOffset = cd.readUInt32LE(p + 42);
+        const nameAt = p + 46;
+        const extraAt = nameAt + nameLen;
+        const next = extraAt + extraLen + commentLen;
+        if (next > cd.length)
+            throw new ZipFormatError("central directory record overruns");
+        const name = cd.toString("utf8", nameAt, extraAt);
+        // zip64: the fields that overflowed 32 bits appear, in this order, in
+        // extra block 0x0001.
+        if (usize === 0xffffffff || csize === 0xffffffff || localOffset === 0xffffffff) {
+            let e = extraAt;
+            const eEnd = extraAt + extraLen;
+            while (e + 4 <= eEnd) {
+                const id = cd.readUInt16LE(e);
+                const len = cd.readUInt16LE(e + 2);
+                if (id === 0x0001) {
+                    let f = e + 4;
+                    const fEnd = Math.min(e + 4 + len, eEnd);
+                    const take = () => {
+                        if (f + 8 > fEnd)
+                            throw new ZipFormatError("short zip64 extra field");
+                        const v = safeNumber(cd.readBigUInt64LE(f));
+                        f += 8;
+                        return v;
+                    };
+                    if (usize === 0xffffffff)
+                        usize = take();
+                    if (csize === 0xffffffff)
+                        csize = take();
+                    if (localOffset === 0xffffffff)
+                        localOffset = take();
+                    break;
+                }
+                e += 4 + len;
+            }
+        }
+        const unixMode = (madeBy >> 8) === 3 ? extAttr >>> 16 : 0;
+        const isDir = name.endsWith("/") || (unixMode & 0o170000) === 0o040000;
+        const isLink = (unixMode & 0o170000) === 0o120000;
+        const member = zipMember(path, size, {
+            localOffset: localOffset + shift, csize, usize, method, encrypted: (flags & 1) !== 0, mtimeMs,
+        });
+        members.push({
+            name,
+            kind: isDir ? "dir" : isLink ? "symlink" : "file",
+            size: isDir ? null : usize,
+            mtimeMs,
+            open: member.open,
+            readLink: isLink ? member.readLink : undefined,
+        });
+        p = next;
+    }
+    return { members, partial };
+}
+/** Where a member's bytes start: past its local header, whose name and extra
+ *  lengths may differ from the central directory's copy. */
+async function dataStart(path, fileSize, e) {
+    if (e.localOffset + 30 > fileSize)
+        throw new MemberError("member header out of range");
+    const h = await readAt(path, e.localOffset, 30);
+    if (h.length < 30 || h.readUInt32LE(0) !== SIG_LOCAL)
+        throw new MemberError("bad local header");
+    const start = e.localOffset + 30 + h.readUInt16LE(26) + h.readUInt16LE(28);
+    if (start + e.csize > fileSize)
+        throw new MemberError("member data out of range");
+    return start;
+}
+function zipMember(path, fileSize, e) {
+    const open = () => {
+        if (e.encrypted)
+            throw new MemberError("This member is encrypted");
+        if (e.method !== 0 && e.method !== 8) {
+            throw new MemberError(`Compression method ${e.method} is not supported (only stored and deflate)`);
+        }
+        // The local header is read on first use, not at listing time: a listing
+        // of 50,000 members should cost one read, not 50,001.
+        let start = null;
+        const where = () => (start ??= dataStart(path, fileSize, e));
+        if (e.method === 0) {
+            return deferredSource(e.usize, e.mtimeMs, async () => fileSource(path, e.csize, e.mtimeMs, await where()));
+        }
+        return deferredSource(e.usize, e.mtimeMs, async () => {
+            const s = await where();
+            return streamSource(() => openDecoded(path, "deflate-raw", s, s + Math.max(0, e.csize - 1)), e.csize === 0 ? 0 : null, e.mtimeMs, 0, MAX_STREAM_REACH);
+        });
+    };
+    const readLink = async () => {
+        const buf = await open().read(0, 4096);
+        return buf.toString("utf8");
+    };
+    return { open, readLink };
+}
+//# sourceMappingURL=zip.js.map