brane 0.1.1 → 0.3.0

package/dist/files/archive.js

@@ -0,0 +1,182 @@
+// Archives as directories. A path that runs through an archive —
+// `dist/app.zip/src/main.ts` — names a member, and the archive itself lists
+// as a folder. Nothing is ever extracted: members are listed from the index
+// the format keeps (zip) or from one pass over the stream (tar), and read
+// through a `ByteSource` that decodes only as far as a request reaches.
+//
+// Member names are data from the archive's author, so this is where they are
+// made safe to show. A name that is absolute has its leading slashes dropped;
+// one containing `..` or a NUL is hidden and counted (`skipped`), since there
+// is no honest place in the tree to draw it. Since nothing is written to
+// disk, none of this is what stops zip-slip — there is no slip to stop — it
+// only keeps the tree the operator sees from lying about where a member sits.
+import { stat } from "node:fs/promises";
+import { fileSource, streamSource } from "./bytes.js";
+import { HAS_ZSTD, openDecoded } from "./codecs.js";
+import { listZip } from "./zip.js";
+import { scanTar } from "./tar.js";
+/** Zip under other names: Java and Android packages, Python wheels, e-books,
+ *  Office and OpenDocument files, browser and editor extensions. Each is a zip
+ *  whose contents are worth reading, and each showed as binary before. */
+const ZIP_EXTS = [
+    ".zip", ".jar", ".war", ".ear", ".aar", ".apk", ".aab", ".ipa", ".whl",
+    ".epub", ".docx", ".xlsx", ".pptx", ".odt", ".ods", ".odp", ".odg",
+    ".nupkg", ".vsix", ".xpi", ".kmz", ".sketch", ".xmind",
+];
+const COMPRESSED_EXTS = [
+    { ext: ".tar.gz", codec: "gzip", tar: true },
+    { ext: ".tgz", codec: "gzip", tar: true },
+    { ext: ".taz", codec: "gzip", tar: true },
+    { ext: ".tar.br", codec: "brotli", tar: true },
+    { ext: ".tbr", codec: "brotli", tar: true },
+    ...(HAS_ZSTD ? [
+        { ext: ".tar.zst", codec: "zstd", tar: true },
+        { ext: ".tzst", codec: "zstd", tar: true },
+        { ext: ".zst", codec: "zstd", tar: false },
+    ] : []),
+    { ext: ".gz", codec: "gzip", tar: false },
+    { ext: ".br", codec: "brotli", tar: false },
+];
+/** What kind of archive a file name says it is, or null. The name only
+ *  nominates: a file that doesn't parse as what it claims falls back to being
+ *  an ordinary (usually binary) file. */
+export function archiveFormatFor(name) {
+    const lower = name.toLowerCase();
+    const base = lower.slice(lower.lastIndexOf("/") + 1);
+    if (ZIP_EXTS.some((e) => base.endsWith(e) && base.length > e.length)) {
+        return { kind: "zip", label: "zip" };
+    }
+    if (base.endsWith(".tar") && base.length > 4)
+        return { kind: "tar", label: "tar", codec: null };
+    for (const c of COMPRESSED_EXTS) {
+        if (!base.endsWith(c.ext) || base.length <= c.ext.length)
+            continue;
+        const label = c.ext.slice(1);
+        if (c.tar)
+            return { kind: "tar", label, codec: c.codec };
+        const original = name.slice(name.lastIndexOf("/") + 1);
+        return { kind: "single", label, codec: c.codec, inner: original.slice(0, original.length - c.ext.length) };
+    }
+    return null;
+}
+/** A name as the tree will show it, or null if it can't honestly be placed.
+ *  A name that is only the root (`./`, which `tar -C dir .` writes first) is
+ *  "" — nothing to place, but nothing wrong either. */
+export function normalizeMemberName(name) {
+    if (name.includes("\0"))
+        return null;
+    const parts = [];
+    for (const part of name.replace(/\\/g, "/").split("/")) {
+        if (part === "" || part === ".")
+            continue;
+        if (part === "..")
+            return null;
+        parts.push(part);
+    }
+    return parts.join("/");
+}
+export const ARCHIVE_LIMITS = {
+    maxEntries: 200_000,
+    /** Decoded bytes a compressed tar's listing may run through. */
+    maxScanBytes: 1024 * 1024 * 1024,
+};
+export function buildIndex(format, members, partial) {
+    const nodes = new Map();
+    const children = new Map();
+    const root = { name: "", kind: "dir", size: null, mtimeMs: 0 };
+    nodes.set("", root);
+    children.set("", new Map());
+    let skipped = 0;
+    const ensureDir = (path, mtimeMs) => {
+        const existing = nodes.get(path);
+        if (existing)
+            return existing.kind === "dir" ? existing : null;
+        const slash = path.lastIndexOf("/");
+        const parentPath = slash < 0 ? "" : path.slice(0, slash);
+        const parent = ensureDir(parentPath, mtimeMs);
+        if (!parent)
+            return null;
+        const node = { name: path.slice(slash + 1), kind: "dir", size: null, mtimeMs };
+        nodes.set(path, node);
+        children.set(path, new Map());
+        children.get(parentPath).set(node.name, node);
+        return node;
+    };
+    for (const m of members) {
+        const path = normalizeMemberName(m.name);
+        if (path === null || (path === "" && m.kind !== "dir")) {
+            skipped++;
+            continue;
+        }
+        if (m.kind === "dir") {
+            const dir = ensureDir(path, m.mtimeMs);
+            if (!dir) {
+                skipped++;
+                continue;
+            }
+            if (m.mtimeMs)
+                dir.mtimeMs = m.mtimeMs;
+            continue;
+        }
+        const slash = path.lastIndexOf("/");
+        const parentPath = slash < 0 ? "" : path.slice(0, slash);
+        const existing = nodes.get(path);
+        // A file where the tree already has a directory (`a` beside `a/b`) has
+        // nowhere to go. A second file of the same name replaces the first, as
+        // extracting it would.
+        if (existing?.kind === "dir") {
+            skipped++;
+            continue;
+        }
+        const parent = ensureDir(parentPath, m.mtimeMs);
+        if (!parent) {
+            skipped++;
+            continue;
+        }
+        const node = { name: path.slice(slash + 1), kind: m.kind, size: m.size, mtimeMs: m.mtimeMs, member: m };
+        nodes.set(path, node);
+        children.get(parentPath).set(node.name, node);
+    }
+    return { format, nodes, children, skipped, partial };
+}
+/** Lists the archive at `path`. Throws when it isn't what its name claims. */
+export async function readArchiveIndex(path, size, format) {
+    if (format.kind === "zip") {
+        const { members, partial } = await listZip(path, size, ARCHIVE_LIMITS.maxEntries);
+        return buildIndex(format, members, partial);
+    }
+    if (format.kind === "tar") {
+        const codec = format.codec;
+        const { members, partial } = await scanTar(openDecoded(path, codec), (offset, bodySize, mtime) => codec
+            ? streamSource(() => openDecoded(path, codec), bodySize, mtime, offset)
+            : fileSource(path, bodySize, mtime, offset), ARCHIVE_LIMITS);
+        return buildIndex(format, members, partial);
+    }
+    throw new Error("not an archive");
+}
+// A listing of a compressed tar costs a pass over the whole thing, and the
+// Files view asks for one per directory it opens, so indexes are kept while
+// the file is unchanged. Keyed on (path, size, mtime): an edit or a rebuild
+// is a new key, never a stale listing.
+const CACHE_SIZE = 16;
+const cache = new Map();
+export async function archiveIndex(path, format) {
+    const st = await stat(path);
+    const key = `${path}\0${st.size}\0${st.mtimeMs}`;
+    let hit = cache.get(key);
+    if (hit) {
+        cache.delete(key);
+        cache.set(key, hit);
+        return hit;
+    }
+    hit = readArchiveIndex(path, st.size, format);
+    cache.set(key, hit);
+    // A failure is not cached: the next request tries again (the file may have
+    // been mid-write).
+    hit.catch(() => { if (cache.get(key) === hit)
+        cache.delete(key); });
+    while (cache.size > CACHE_SIZE)
+        cache.delete(cache.keys().next().value);
+    return hit;
+}
+//# sourceMappingURL=archive.js.map

package/dist/files/browse.js

@@ -0,0 +1,327 @@
+// GET /api/files, as a function of (fold, path, options) → answer, so the
+// whole route can be tested without HTTP. The server does only the lookup of
+// the narrative's fold and the writing of what comes back.
+//
+// Every file — on disk, inside an archive, behind a `.gz` — is served through
+// one `respondWithSource`, which is why a format added in `archive.ts` gains
+// text, highlighting, images, the hex view and download all at once.
+import { readdir, stat } from "node:fs/promises";
+import { extname, relative, resolve } from "node:path";
+import { detectLanguage, highlight } from "../highlight.js";
+import { BINARY_SNIFF_BYTES, HEX_PAGE_BYTES, looksBinary } from "../shared/hex-dump.js";
+import { ReachError, fileSource, streamSource } from "./bytes.js";
+import { openDecoded } from "./codecs.js";
+import { archiveFormatFor, archiveIndex, normalizeMemberName } from "./archive.js";
+import { MemberError } from "./zip.js";
+/** Text is sent inline up to this size; past it, a notice and a download. */
+export const MAX_INLINE = 2 * 1024 * 1024;
+const err = (status, error) => ({ status, json: { error } });
+/** Parse `offset=`: a non-negative safe integer, or undefined when absent. */
+export function parseOffsetParam(v) {
+    if (v === null)
+        return null;
+    if (!/^\d+$/.test(v))
+        return undefined;
+    const n = Number(v);
+    return Number.isSafeInteger(n) ? n : undefined;
+}
+/** The request's path confined to the fold, or why it can't be. */
+function confine(foldRoot, relParam) {
+    if (relParam.startsWith("/") || relParam.startsWith("\\"))
+        return { status: 400, error: "Absolute paths not allowed" };
+    const cleanRel = relParam.split("#")[0].split("?")[0];
+    const target = resolve(foldRoot, cleanRel);
+    if (target !== foldRoot && !target.startsWith(foldRoot + "/"))
+        return { status: 400, error: "Path escapes fold" };
+    // Echo a NORMALIZED relative path: resolve() already collapsed any
+    // `.`/`..`/`//` segments, so the breadcrumb never renders `fold/./blah`.
+    return { target, normRel: relative(foldRoot, target) };
+}
+export async function browseFold(foldRoot, relParam, opts) {
+    const where = confine(foldRoot, relParam);
+    if ("error" in where)
+        return err(where.status, where.error);
+    const { target, normRel } = where;
+    let st;
+    try {
+        st = await stat(target);
+    }
+    catch (e) {
+        const code = e.code;
+        if (code !== "ENOENT" && code !== "ENOTDIR")
+            throw e;
+        return browseInsideArchive(foldRoot, normRel, opts);
+    }
+    if (st.isDirectory()) {
+        return { status: 200, json: { type: "directory", path: normRel, entries: await listDirectory(target) } };
+    }
+    const format = archiveFormatFor(normRel);
+    if (format?.kind === "single" && !opts.raw) {
+        // A `.gz` opens as what it compresses. `raw` still means the file itself.
+        const source = streamSource(() => openDecoded(target, format.codec), null, st.mtimeMs);
+        return respondWithSource(source, normRel, format.inner, opts);
+    }
+    if (format && format.kind !== "single" && !opts.raw && (opts.offset ?? null) === null) {
+        try {
+            const index = await archiveIndex(target, format);
+            return archiveDirectory(index, "", normRel, archiveInfo(normRel, format, index));
+        }
+        catch {
+            // Not what its name says: show it as the file it is.
+        }
+    }
+    return respondWithSource(fileSource(target, st.size, st.mtimeMs), normRel, normRel, opts);
+}
+async function listDirectory(dir) {
+    const names = await readdir(dir);
+    const entries = await Promise.all(names
+        .filter((n) => !n.startsWith(".")) // hide dotfiles by default
+        .map(async (name) => {
+        try {
+            const child = await stat(resolve(dir, name));
+            const isDir = child.isDirectory();
+            const fmt = isDir ? null : archiveFormatFor(name);
+            return {
+                name,
+                is_dir: isDir,
+                size: isDir ? null : child.size,
+                mtime: child.mtimeMs,
+                ...(fmt && fmt.kind !== "single" ? { archive: true } : {}),
+            };
+        }
+        catch {
+            return null;
+        }
+    }));
+    return sortEntries(entries.filter((e) => e !== null));
+}
+function sortEntries(entries) {
+    return entries.sort((a, b) => {
+        if (a.is_dir !== b.is_dir)
+            return a.is_dir ? -1 : 1;
+        return a.name.localeCompare(b.name);
+    });
+}
+function archiveInfo(root, format, index) {
+    return {
+        root,
+        format: format.label,
+        ...(index.skipped ? { skipped: index.skipped } : {}),
+        ...(index.partial ? { partial: true } : {}),
+    };
+}
+function archiveDirectory(index, inner, normRel, info) {
+    const kids = index.children.get(inner);
+    if (!kids)
+        return err(404, "Not found");
+    const entries = [];
+    for (const node of kids.values()) {
+        // Dotfiles are hidden as they are in the fold — which also keeps macOS's
+        // `._name` AppleDouble twins out of every tarball made on a Mac.
+        if (node.name.startsWith("."))
+            continue;
+        const isDir = node.kind === "dir";
+        entries.push({
+            name: node.name,
+            is_dir: isDir,
+            size: isDir ? null : node.size,
+            mtime: node.mtimeMs,
+            ...(node.member?.link ? { link: node.member.link } : {}),
+        });
+    }
+    return { status: 200, json: { type: "directory", path: normRel, entries: sortEntries(entries), archive: info } };
+}
+/** `normRel` doesn't exist on disk. If a prefix of it is an archive, the rest
+ *  names a member. Archives do not nest: a member that is itself a zip opens
+ *  as its bytes. */
+async function browseInsideArchive(foldRoot, normRel, opts) {
+    const found = await locateMember(foldRoot, normRel);
+    if (!found)
+        return err(404, "Not found");
+    const { index, node, inner, info } = found;
+    return browseMember(index, node, inner, normRel, info, opts);
+}
+/** The archive member `normRel` names, when a prefix of it is an archive. */
+async function locateMember(foldRoot, normRel) {
+    const segs = normRel.split("/");
+    for (let i = segs.length - 1; i >= 1; i--) {
+        const prefix = segs.slice(0, i).join("/");
+        const format = archiveFormatFor(prefix);
+        let st;
+        try {
+            st = await stat(resolve(foldRoot, prefix));
+        }
+        catch {
+            continue;
+        }
+        if (!st.isFile() || !format || format.kind === "single")
+            return null;
+        let index;
+        try {
+            index = await archiveIndex(resolve(foldRoot, prefix), format);
+        }
+        catch {
+            return null;
+        }
+        const inner = segs.slice(i).join("/");
+        const node = index.nodes.get(inner);
+        return node ? { index, node, inner, info: archiveInfo(prefix, format, index) } : null;
+    }
+    return null;
+}
+/** A tar hard link names an earlier member of the same archive; that one
+ *  lookup is as far as it goes. */
+function hardlinkTarget(index, node) {
+    const to = node.member?.link;
+    const resolved = to === undefined ? undefined : index.nodes.get(normalizeMemberName(to) ?? "\0");
+    return resolved?.kind === "file" ? resolved : undefined;
+}
+/** The bytes the hex view shows for `relParam` — a file, an archive member,
+ *  a `.gz` body — for a search to read. A search reads what the view reads,
+ *  or its hits would name offsets the view has never heard of. */
+export async function openFoldSource(foldRoot, relParam) {
+    const where = confine(foldRoot, relParam);
+    if ("error" in where)
+        return where;
+    const { target, normRel } = where;
+    let st;
+    try {
+        st = await stat(target);
+    }
+    catch (e) {
+        const code = e.code;
+        if (code !== "ENOENT" && code !== "ENOTDIR")
+            throw e;
+        const found = await locateMember(foldRoot, normRel);
+        if (!found)
+            return { status: 404, error: "Not found" };
+        const node = found.node.kind === "hardlink" ? hardlinkTarget(found.index, found.node) : found.node;
+        if (node?.kind !== "file" || !node.member?.open)
+            return { status: 400, error: "Not a file with contents" };
+        try {
+            return node.member.open();
+        }
+        catch (e) {
+            if (e instanceof MemberError)
+                return { status: 400, error: e.message };
+            throw e;
+        }
+    }
+    if (!st.isFile())
+        return { status: 400, error: "Not a file" };
+    const format = archiveFormatFor(normRel);
+    if (format?.kind === "single")
+        return streamSource(() => openDecoded(target, format.codec), null, st.mtimeMs);
+    return fileSource(target, st.size, st.mtimeMs);
+}
+async function browseMember(index, node, inner, normRel, info, opts) {
+    if (node.kind === "dir")
+        return archiveDirectory(index, inner, normRel, info);
+    const plain = (extra) => ({
+        status: 200,
+        json: { type: "file", path: normRel, size: node.size, mtime: node.mtimeMs, content: "", archive: info, ...extra },
+    });
+    let target = node;
+    if (node.kind === "symlink") {
+        // Shown, never followed: a link's target is the archive author's claim
+        // about a filesystem that doesn't exist here.
+        let link = node.member?.link;
+        if (link === undefined && node.member?.readLink) {
+            link = await node.member.readLink().catch(() => undefined);
+        }
+        return plain({ size: 0, link: link ?? "" });
+    }
+    if (node.kind === "hardlink") {
+        const resolved = hardlinkTarget(index, node);
+        if (!resolved)
+            return plain({ size: 0, link: node.member?.link ?? "" });
+        target = resolved;
+    }
+    if (target.kind !== "file" || !target.member?.open) {
+        return plain({ notice: "A special file (device, FIFO or similar), which has no contents to show" });
+    }
+    let source;
+    try {
+        source = target.member.open();
+    }
+    catch (e) {
+        if (e instanceof MemberError)
+            return plain({ notice: e.message });
+        throw e;
+    }
+    const res = await respondWithSource(source, normRel, inner, opts);
+    if ("json" in res && res.status === 200 && res.json && res.json.type === "file") {
+        res.json.archive = info;
+    }
+    return res;
+}
+/** The one place a file's bytes become a response. `name` decides the MIME
+ *  type and the highlighter; it differs from `normRel` for a `.gz` body. */
+export async function respondWithSource(source, normRel, name, opts) {
+    const mime = opts.mimeTypes[extname(name).toLowerCase()];
+    const base = { type: "file", path: normRel, size: source.size, mtime: source.mtimeMs };
+    if (opts.raw) {
+        return { status: 200, raw: { stream: source.stream(), contentType: mime ?? "application/octet-stream" } };
+    }
+    const offset = opts.offset ?? null;
+    if (offset !== null)
+        return hexPage(source, base, offset);
+    // Images, PDFs and fonts render from a raw URL; the JSON only says so.
+    const rendersFromRaw = mime?.startsWith("image/") || mime === "application/pdf" || mime === "font/woff" || mime === "font/woff2";
+    if (rendersFromRaw) {
+        return {
+            status: 200,
+            json: { ...base, binary: true, truncated: source.size !== null && source.size > MAX_INLINE, content: "" },
+        };
+    }
+    const head = await source.read(0, BINARY_SNIFF_BYTES);
+    if (looksBinary(head))
+        return hexPage(source, base, 0);
+    if (source.size !== null && source.size > MAX_INLINE) {
+        return { status: 200, json: { ...base, truncated: true, content: "" } };
+    }
+    // One byte past the limit says whether a body of unknown size is too big.
+    const body = source.size !== null && source.size <= BINARY_SNIFF_BYTES ? head : await source.read(0, MAX_INLINE + 1);
+    if (body.length > MAX_INLINE) {
+        return { status: 200, json: { ...base, truncated: true, content: "" } };
+    }
+    const data = body.toString("utf8");
+    // detectLanguage returns null for markdown and unknown types, so markdown
+    // (rendered client-side by MarkdownContent) and plain text both skip the
+    // highlighter without a special case here.
+    const lang = detectLanguage(name);
+    const hi = lang
+        ? await highlight(data, lang).catch((e) => {
+            console.warn(`[files] highlight failed for ${normRel} (${lang}):`, e);
+            return null;
+        })
+        : null;
+    return { status: 200, json: { ...base, size: source.size ?? body.length, content: data, highlight: hi } };
+}
+async function hexPage(source, base, offset) {
+    let bytes;
+    let notice;
+    try {
+        // One byte past the page says whether another follows.
+        bytes = await source.read(offset, HEX_PAGE_BYTES + 1);
+    }
+    catch (e) {
+        if (!(e instanceof ReachError))
+            throw e;
+        bytes = Buffer.alloc(0);
+        notice = e.message;
+    }
+    const eof = bytes.length <= HEX_PAGE_BYTES;
+    const page = eof ? bytes : bytes.subarray(0, HEX_PAGE_BYTES);
+    return {
+        status: 200,
+        json: {
+            ...base,
+            binary: true,
+            content: "",
+            hex: { offset, data: page.toString("base64"), eof },
+            ...(notice ? { notice } : {}),
+        },
+    };
+}
+//# sourceMappingURL=browse.js.map

package/dist/files/bytes.js

@@ -0,0 +1,162 @@
+// A ByteSource is anything the Files view can open: a file in the fold, a
+// member of an archive, the decompressed body of a `.gz`. Every renderer —
+// text, highlighting, images, the hex view, a raw download — reads through
+// this one interface, so a format added here is browsable everywhere at once.
+import { open } from "node:fs/promises";
+import { createReadStream } from "node:fs";
+import { Readable } from "node:stream";
+/** Bytes a search reads from disk at a time. */
+const SCAN_CHUNK_BYTES = 1024 * 1024;
+/** A byte range of a file on disk, read by position. */
+export function fileSource(path, size, mtimeMs, start = 0) {
+    return {
+        size,
+        mtimeMs,
+        async read(offset, length) {
+            const n = Math.max(0, Math.min(length, size - offset));
+            if (n === 0)
+                return Buffer.alloc(0);
+            return readAt(path, start + offset, n);
+        },
+        stream() {
+            if (size === 0)
+                return Readable.from([]);
+            return createReadStream(path, { start, end: start + size - 1 });
+        },
+        chunks(from) {
+            if (from >= size)
+                return Readable.from([]);
+            return createReadStream(path, { start: start + from, end: start + size - 1, highWaterMark: SCAN_CHUNK_BYTES });
+        },
+    };
+}
+/** `length` bytes at `position` of a file, fewer only at its end. */
+export async function readAt(path, position, length) {
+    const fh = await open(path, "r");
+    try {
+        const buf = Buffer.alloc(length);
+        let got = 0;
+        while (got < length) {
+            const { bytesRead } = await fh.read(buf, got, length - got, position + got);
+            if (bytesRead === 0)
+                break;
+            got += bytesRead;
+        }
+        return got === length ? buf : buf.subarray(0, got);
+    }
+    finally {
+        await fh.close();
+    }
+}
+/** How far into a decompressed stream a read may reach. Reaching byte N of a
+ *  compressed body means inflating every byte before it, so this bounds the
+ *  CPU one request can spend: a page 10 GB into a zip bomb is refused rather
+ *  than computed. */
+export const MAX_STREAM_REACH = 1024 * 1024 * 1024;
+export class ReachError extends Error {
+    constructor(limit) {
+        super(`That is more than ${Math.round(limit / 1024 / 1024)} MB into a compressed stream, further than brane will decompress`);
+    }
+}
+/** A body that can only be read front to back, at `start` within what `open`
+ *  yields: each read decompresses from the beginning and tears the pipeline
+ *  down once it has what it asked for. Nothing past the requested range is
+ *  ever produced, and that is the whole defence against a decompression
+ *  bomb — output is bounded by the request, never by what the archive claims. */
+export function streamSource(openStream, size, mtimeMs, start = 0, reach = MAX_STREAM_REACH) {
+    const bound = (offset, length) => {
+        if (size !== null)
+            length = Math.max(0, Math.min(length, size - offset));
+        const end = start + offset + length;
+        if (end > reach) {
+            if (start + offset >= reach)
+                throw new ReachError(reach);
+            length = reach - start - offset;
+        }
+        return length;
+    };
+    return {
+        size,
+        mtimeMs,
+        async read(offset, length) {
+            const n = bound(offset, length);
+            if (n === 0)
+                return Buffer.alloc(0);
+            const parts = [];
+            for await (const chunk of sliceStream(openStream, start + offset, n))
+                parts.push(chunk);
+            return Buffer.concat(parts);
+        },
+        stream() {
+            // A download stops at the reach limit too: a bomb member streams a
+            // gigabyte and ends, rather than inflating until the client gives up.
+            const n = size ?? reach - start;
+            return Readable.from(sliceStream(openStream, start, Math.min(n, reach - start)));
+        },
+        async *chunks(from) {
+            const want = size === null ? Infinity : Math.max(0, size - from);
+            const room = reach - start - from;
+            if (want === 0)
+                return;
+            if (room <= 0)
+                throw new ReachError(reach);
+            // One byte past the reach limit says whether the body goes on past it.
+            const take = Math.min(want, room + 1);
+            let got = 0;
+            for await (const chunk of sliceStream(openStream, start + from, take)) {
+                const keep = Math.min(chunk.length, room - got);
+                if (keep > 0)
+                    yield keep === chunk.length ? chunk : chunk.subarray(0, keep);
+                got += chunk.length;
+                if (got > room)
+                    throw new ReachError(reach);
+            }
+        },
+    };
+}
+/** Bytes [start, start + length) of a freshly opened stream, as chunks. The
+ *  stream is destroyed when the range is done or the consumer stops early. */
+export async function* sliceStream(openStream, start, length) {
+    const stream = await openStream();
+    let pos = 0;
+    let left = length;
+    try {
+        for await (const chunk of stream) {
+            const end = pos + chunk.length;
+            if (end > start && left > 0) {
+                const from = Math.max(0, start - pos);
+                const take = Math.min(chunk.length - from, left);
+                yield chunk.subarray(from, from + take);
+                left -= take;
+            }
+            pos = end;
+            if (left <= 0)
+                break;
+        }
+    }
+    finally {
+        stream.destroy();
+    }
+}
+/** A source whose real reader needs an async step first (a zip member's local
+ *  header). `size` is the archive's claim, shown but never relied on. */
+export function deferredSource(size, mtimeMs, make) {
+    let inner = null;
+    const get = () => (inner ??= make());
+    return {
+        size,
+        mtimeMs,
+        async read(offset, length) {
+            return (await get()).read(offset, length);
+        },
+        stream() {
+            return Readable.from((async function* () {
+                yield* (await get()).stream();
+            })());
+        },
+        async *chunks(from) {
+            yield* (await get()).chunks(from);
+        },
+    };
+}
+//# sourceMappingURL=bytes.js.map