nervur 0.21.4 → 0.22.0

package/dist/core/git/object.js

@@ -0,0 +1,103 @@
+// SPDX-License-Identifier: Apache-2.0
+// Git's objects, byte for byte as git writes them: a blob, a tree and a
+// commit, each named by the SHA-1 of `<type> <size>\0` and its body.
+//
+//   tree     one entry after another, `<mode> <name>\0` and the 20 bytes of
+//            its id, sorted by name as git sorts, a tree's name read with
+//            a `/` after it
+//   commit   `tree`, each `parent`, `author` and `committer` lines, a blank
+//            line, and the message
+import { concat, hex, unhex, utf8 } from '../crypto/bytes.js';
+import { own, subtle } from '../crypto/subtle.js';
+import { deflate, inflate } from './zlib.js';
+export const TYPES = ['blob', 'tree', 'commit', 'tag'];
+// The tree with no entry, which every empty commit names.
+export const EMPTY_TREE = '4b825dc642cb6eb9a060e54bf8d69288fbee4904';
+const decoder = new TextDecoder('utf-8', { fatal: true });
+export const text = (bytes) => decoder.decode(bytes);
+export const sha1 = async (bytes) => hex(new Uint8Array(await subtle().digest('SHA-1', own(bytes))));
+export const isId = (value) => typeof value === 'string' && /^[0-9a-f]{40}$/.test(value);
+// An object as git keeps it loose, before it is deflated.
+export const loose = (o) => concat(utf8(`${o.type} ${String(o.body.length)}\0`), o.body);
+export const idOf = (o) => sha1(loose(o));
+export const readLoose = (bytes) => {
+    const nul = bytes.indexOf(0);
+    const head = nul < 0 ? '' : text(bytes.subarray(0, nul));
+    const [type, size] = head.split(' ');
+    const body = bytes.subarray(nul + 1);
+    if (!TYPES.includes(type) || String(body.length) !== size)
+        throw new Error('no loose object');
+    return { type: type, body: body.slice() };
+};
+// The file git writes under `.git/objects/`, and the object it holds.
+export const deflated = (o) => deflate(loose(o));
+export const inflated = async (bytes) => readLoose(await inflate(bytes));
+export const blob = (source) => ({ type: 'blob', body: utf8(source) });
+export const FILE = '100644';
+export const DIRECTORY = '40000';
+const sortName = (e) => (e.mode === DIRECTORY ? `${e.name}/` : e.name);
+const byName = (a, b) => {
+    const [x, y] = [utf8(sortName(a)), utf8(sortName(b))];
+    for (let k = 0; k < Math.min(x.length, y.length); k += 1)
+        if (x[k] !== y[k])
+            return x[k] - y[k];
+    return x.length - y.length;
+};
+export const tree = (entries) => ({
+    type: 'tree',
+    body: concat(...[...entries].sort(byName).flatMap((e) => [utf8(`${e.mode} ${e.name}\0`), unhex(e.id)])),
+});
+export const readTree = (o) => {
+    if (o.type !== 'tree')
+        throw new Error('no tree');
+    const entries = [];
+    for (let at = 0; at < o.body.length;) {
+        const space = o.body.indexOf(0x20, at);
+        const nul = o.body.indexOf(0, space);
+        if (space < 0 || nul < 0 || nul + 21 > o.body.length)
+            throw new Error('a tree cut short');
+        entries.push({ mode: text(o.body.subarray(at, space)), name: text(o.body.subarray(space + 1, nul)), id: hex(o.body.subarray(nul + 1, nul + 21)) });
+        at = nul + 21;
+    }
+    return entries;
+};
+const signed = (s) => `${s.name} <${s.email}> ${String(s.seconds)} ${s.zone}`;
+const readSigned = (line) => {
+    const m = /^(.*) <([^>]*)> (\d+) ([+-]\d{4})$/.exec(line);
+    if (!m)
+        throw new Error('a signature git does not write');
+    return { name: m[1], email: m[2], seconds: Number(m[3]), zone: m[4] };
+};
+export const commit = (c) => ({
+    type: 'commit',
+    body: utf8([`tree ${c.tree}`, ...c.parents.map((p) => `parent ${p}`), `author ${signed(c.author)}`, `committer ${signed(c.committer)}`, '', c.message].join('\n')),
+});
+// A commit's own headers, read; a header it does not name, a signature
+// among them, is kept in the bytes and read past.
+export const readCommit = (o) => {
+    if (o.type !== 'commit')
+        throw new Error('no commit');
+    const all = text(o.body);
+    const blank = all.indexOf('\n\n');
+    const head = blank < 0 ? all : all.slice(0, blank);
+    const message = blank < 0 ? '' : all.slice(blank + 2);
+    let root;
+    const parents = [];
+    let author;
+    let committer;
+    for (const line of head.split('\n')) {
+        const space = line.indexOf(' ');
+        const [key, value] = [line.slice(0, space), line.slice(space + 1)];
+        if (key === 'tree')
+            root = value;
+        else if (key === 'parent')
+            parents.push(value);
+        else if (key === 'author')
+            author = readSigned(value);
+        else if (key === 'committer')
+            committer = readSigned(value);
+    }
+    if (!isId(root) || !author || !committer || !parents.every(isId))
+        throw new Error('a commit git does not write');
+    return { tree: root, parents, author, committer, message };
+};

package/dist/core/git/pack.d.ts

@@ -0,0 +1,9 @@
+import { type GitObject } from './object.ts';
+export declare const applyDelta: (base: Uint8Array, delta: Uint8Array) => Uint8Array;
+export declare const readPack: (pack: Uint8Array, outside?: (id: string) => Promise<GitObject | null>) => Promise<Map<string, GitObject>>;
+export declare const pkt: (line: string) => Uint8Array;
+export declare const FLUSH: Uint8Array<ArrayBufferLike>;
+export declare const readPkts: (bytes: Uint8Array, at?: number, stop?: (_line: string) => boolean) => {
+    lines: string[];
+    end: number;
+};

package/dist/core/git/pack.js

@@ -0,0 +1,171 @@
+// SPDX-License-Identifier: Apache-2.0
+// A packfile, version 2, read into its objects: each entry a header of its
+// type and size, then a zlib stream, and a SHA-1 of it all at the end. A
+// delta names its base by the distance back to it in the pack, OFS_DELTA,
+// or by its id, REF_DELTA, which may name an object the reader holds
+// already.
+import { hex, utf8 } from '../crypto/bytes.js';
+import { idOf, sha1 } from './object.js';
+import { inflateAt } from './zlib.js';
+const KINDS = { 1: 'commit', 2: 'tree', 3: 'blob', 4: 'tag' };
+const OFS_DELTA = 6;
+const REF_DELTA = 7;
+// A delta's instructions laid over its base.
+export const applyDelta = (base, delta) => {
+    let at = 0;
+    const size = () => {
+        let n = 0;
+        let shift = 0;
+        for (let b = 0x80; b & 0x80; shift += 7) {
+            b = delta[at++];
+            n += (b & 0x7f) * 2 ** shift;
+        }
+        return n;
+    };
+    if (size() !== base.length)
+        throw new Error('a delta for another base');
+    const out = new Uint8Array(size());
+    let written = 0;
+    while (at < delta.length) {
+        const op = delta[at++];
+        if (op & 0x80) {
+            let offset = 0;
+            let length = 0;
+            for (let k = 0; k < 4; k += 1)
+                if (op & (1 << k))
+                    offset |= delta[at++] << (8 * k);
+            for (let k = 0; k < 3; k += 1)
+                if (op & (0x10 << k))
+                    length |= delta[at++] << (8 * k);
+            if (length === 0)
+                length = 0x10000;
+            offset >>>= 0;
+            if (offset + length > base.length || written + length > out.length)
+                throw new Error('a delta copy past its bounds');
+            out.set(base.subarray(offset, offset + length), written);
+            written += length;
+        }
+        else if (op !== 0) {
+            if (at + op > delta.length || written + op > out.length)
+                throw new Error('a delta insert past its bounds');
+            out.set(delta.subarray(at, at + op), written);
+            written += op;
+            at += op;
+        }
+        else
+            throw new Error('a delta op of nothing');
+    }
+    if (written !== out.length)
+        throw new Error('a delta short of its size');
+    return out;
+};
+// Every object a pack holds, by id. `outside` finds a REF_DELTA's base the
+// pack does not carry.
+export const readPack = async (pack, outside = () => Promise.resolve(null)) => {
+    if (pack.length < 32 || new TextDecoder().decode(pack.subarray(0, 4)) !== 'PACK')
+        throw new Error('no pack');
+    const word = (at) => ((pack[at] << 24) | (pack[at + 1] << 16) | (pack[at + 2] << 8) | pack[at + 3]) >>> 0;
+    if (word(4) !== 2)
+        throw new Error('a pack of another version');
+    const count = word(8);
+    const body = pack.subarray(0, pack.length - 20);
+    if ((await sha1(body)) !== hex(pack.subarray(pack.length - 20)))
+        throw new Error('a pack whose sum does not check');
+    const entries = new Map();
+    let at = 12;
+    for (let n = 0; n < count; n += 1) {
+        const start = at;
+        let b = pack[at++];
+        const type = (b >> 4) & 7;
+        let size = b & 15;
+        for (let shift = 4; b & 0x80; shift += 7) {
+            b = pack[at++];
+            size += (b & 0x7f) * 2 ** shift;
+        }
+        let base;
+        if (type === OFS_DELTA) {
+            b = pack[at++];
+            let back = b & 0x7f;
+            while (b & 0x80) {
+                b = pack[at++];
+                back = (back + 1) * 128 + (b & 0x7f);
+            }
+            base = start - back;
+        }
+        else if (type === REF_DELTA) {
+            base = hex(pack.subarray(at, at + 20));
+            at += 20;
+        }
+        else if (!KINDS[type])
+            throw new Error(`a pack entry of type ${String(type)}`);
+        const { out, end } = inflateAt(body, at);
+        if (out.length !== size)
+            throw new Error('a pack entry of another size');
+        at = end;
+        entries.set(start, { type, data: out, ...(base === undefined ? {} : { base }) });
+    }
+    if (at !== body.length)
+        throw new Error('a pack with bytes past its objects');
+    // Pass after pass, every entry whose base stands now is laid over it,
+    // until every entry stands or a pass stands none.
+    const byOffset = new Map();
+    const byId = new Map();
+    const outsiders = new Map();
+    const baseOf = async (base) => {
+        if (typeof base === 'number')
+            return byOffset.get(base);
+        const inside = byId.get(base);
+        if (inside)
+            return inside;
+        if (!outsiders.has(base))
+            outsiders.set(base, await outside(base));
+        return outsiders.get(base) ?? undefined;
+    };
+    while (byOffset.size < entries.size) {
+        const before = byOffset.size;
+        for (const [offset, e] of entries) {
+            if (byOffset.has(offset))
+                continue;
+            let o;
+            if (e.base === undefined)
+                o = { type: KINDS[e.type], body: e.data };
+            else {
+                const base = await baseOf(e.base);
+                if (!base)
+                    continue;
+                o = { type: base.type, body: applyDelta(base.body, e.data) };
+            }
+            byOffset.set(offset, o);
+            byId.set(await idOf(o), o);
+        }
+        if (byOffset.size === before)
+            throw new Error('a delta whose base is nowhere');
+    }
+    return byId;
+};
+// pkt-lines, as git's protocols frame them: four hex digits of length,
+// itself counted, and `0000` for a flush.
+export const pkt = (line) => {
+    const bytes = utf8(line);
+    return new Uint8Array([...utf8((bytes.length + 4).toString(16).padStart(4, '0')), ...bytes]);
+};
+export const FLUSH = utf8('0000');
+// The lines of a pkt-line stream up to its first flush, and where it ends.
+export const readPkts = (bytes, at = 0, stop = (_line) => false) => {
+    const lines = [];
+    while (at + 4 <= bytes.length) {
+        const length = parseInt(new TextDecoder().decode(bytes.subarray(at, at + 4)), 16);
+        if (Number.isNaN(length))
+            throw new Error('no pkt-line');
+        if (length === 0)
+            return { lines, end: at + 4 };
+        if (length < 4 || at + length > bytes.length)
+            throw new Error('a pkt-line cut short');
+        const line = new TextDecoder().decode(bytes.subarray(at + 4, at + length));
+        lines.push(line);
+        at += length;
+        if (stop(line))
+            return { lines, end: at };
+    }
+    return { lines, end: at };
+};

package/dist/core/git/store.d.ts

@@ -0,0 +1,23 @@
+import { type Commit, type GitObject } from './object.ts';
+export interface ObjectStore {
+    get(id: string): Promise<GitObject | null>;
+    put(objects: readonly GitObject[]): Promise<string[]>;
+}
+export declare const need: (store: ObjectStore, id: string, type: GitObject['type']) => Promise<GitObject>;
+export declare const files: (store: ObjectStore, id: string) => Promise<Map<string, string>>;
+export declare const writeTree: (store: ObjectStore, paths: ReadonlyMap<string, string>) => Promise<string>;
+export declare const writeCommit: (store: ObjectStore, c: Commit) => Promise<string>;
+export declare const reachable: (store: ObjectStore, from: string) => Promise<string[]>;
+export declare class HeldObjects implements ObjectStore {
+    #private;
+    objects(): GitObject[];
+    get(id: string): Promise<GitObject | null>;
+    put(objects: readonly GitObject[]): Promise<string[]>;
+}
+export declare class StagedObjects implements ObjectStore {
+    #private;
+    constructor(under: ObjectStore);
+    get(id: string): Promise<GitObject | null>;
+    put(objects: readonly GitObject[]): Promise<string[]>;
+    flush(): Promise<void>;
+}

package/dist/core/git/store.js

@@ -0,0 +1,120 @@
+// SPDX-License-Identifier: Apache-2.0
+// Where objects are kept, and what a repository reads out of them: the
+// files a commit holds, a tree written from files, and every object a
+// commit reaches.
+import { commit, DIRECTORY, FILE, idOf, readCommit, readTree, tree } from './object.js';
+// An object the store must hold, of the type named.
+export const need = async (store, id, type) => {
+    const o = await store.get(id);
+    if (!o)
+        throw new Error(`${id} is no object this harbor holds`);
+    if (o.type !== type)
+        throw new Error(`${id} is a ${o.type}, not a ${type}`);
+    return o;
+};
+// Every file of a commit's tree, by its path, with its blob's id.
+export const files = async (store, id) => {
+    const out = new Map();
+    const walk = async (treeId, at) => {
+        for (const e of readTree(await need(store, treeId, 'tree'))) {
+            if (e.mode === DIRECTORY)
+                await walk(e.id, `${at}${e.name}/`);
+            else
+                out.set(`${at}${e.name}`, e.id);
+        }
+    };
+    await walk(readCommit(await need(store, id, 'commit')).tree, '');
+    return out;
+};
+// Files by path, each a blob's id, written as trees; the root's id.
+export const writeTree = async (store, paths) => {
+    const level = async (under) => {
+        const entries = [];
+        const dirs = new Map();
+        for (const [path, id] of under) {
+            const slash = path.indexOf('/');
+            if (slash < 0)
+                entries.push({ mode: FILE, name: path, id });
+            else {
+                const name = path.slice(0, slash);
+                if (!dirs.has(name))
+                    dirs.set(name, new Map());
+                dirs.get(name).set(path.slice(slash + 1), id);
+            }
+        }
+        for (const [name, inner] of dirs)
+            entries.push({ mode: DIRECTORY, name, id: await level(inner) });
+        const [id] = await store.put([tree(entries)]);
+        return id;
+    };
+    return level(paths);
+};
+export const writeCommit = async (store, c) => {
+    const [id] = await store.put([commit(c)]);
+    return id;
+};
+// Every object a commit reaches, itself first: its ancestors, their trees
+// and every blob.
+export const reachable = async (store, from) => {
+    const seen = new Set();
+    const walkTree = async (id) => {
+        if (seen.has(id))
+            return;
+        seen.add(id);
+        for (const e of readTree(await need(store, id, 'tree'))) {
+            if (e.mode === DIRECTORY)
+                await walkTree(e.id);
+            else
+                seen.add(e.id);
+        }
+    };
+    const commits = [from];
+    while (commits.length > 0) {
+        const id = commits.pop();
+        if (seen.has(id))
+            continue;
+        seen.add(id);
+        const c = readCommit(await need(store, id, 'commit'));
+        await walkTree(c.tree);
+        commits.push(...c.parents);
+    }
+    return [...seen];
+};
+// Objects held in this process alone.
+export class HeldObjects {
+    #objects = new Map();
+    // Every object held, in the order first put.
+    objects() {
+        return [...this.#objects.values()];
+    }
+    get(id) {
+        return Promise.resolve(this.#objects.get(id) ?? null);
+    }
+    async put(objects) {
+        const ids = [];
+        for (const o of objects) {
+            const id = await idOf(o);
+            this.#objects.set(id, o);
+            ids.push(id);
+        }
+        return ids;
+    }
+}
+// Objects written over a store and kept aside until `flush` puts them in
+// it: what a store reads through, and what it writes nowhere yet.
+export class StagedObjects {
+    #under;
+    #staged = new HeldObjects();
+    constructor(under) {
+        this.#under = under;
+    }
+    async get(id) {
+        return (await this.#staged.get(id)) ?? this.#under.get(id);
+    }
+    put(objects) {
+        return this.#staged.put(objects);
+    }
+    async flush() {
+        await this.#under.put(this.#staged.objects());
+    }
+}

package/dist/core/git/zlib.d.ts

@@ -0,0 +1,6 @@
+export declare const deflate: (bytes: Uint8Array) => Promise<Uint8Array>;
+export declare const inflate: (bytes: Uint8Array) => Promise<Uint8Array>;
+export declare const inflateAt: (bytes: Uint8Array, at: number) => {
+    out: Uint8Array;
+    end: number;
+};

package/dist/core/git/zlib.js

@@ -0,0 +1,210 @@
+// SPDX-License-Identifier: Apache-2.0
+// zlib, as git keeps an object. A loose object is deflated and inflated by
+// the engine's own CompressionStream and DecompressionStream. A pack holds
+// its objects one after another with no length before each stream, and a
+// stream API never says how much of its input one stream took, so a pack
+// is read by `inflateAt`, an inflater of RFC 1950 and 1951 that says where
+// the stream it read ends.
+import { own } from '../crypto/subtle.js';
+const through = async (bytes, stream) => {
+    const writer = stream.writable.getWriter();
+    void writer.write(own(bytes)).catch(() => undefined);
+    void writer.close().catch(() => undefined);
+    return new Uint8Array(await new Response(stream.readable).arrayBuffer());
+};
+export const deflate = (bytes) => through(bytes, new CompressionStream('deflate'));
+export const inflate = async (bytes) => {
+    try {
+        return await through(bytes, new DecompressionStream('deflate'));
+    }
+    catch {
+        throw new Error('bytes that do not inflate');
+    }
+};
+const LENGTH_BASE = [3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258];
+const LENGTH_EXTRA = [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0];
+const DISTANCE_BASE = [1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577];
+const DISTANCE_EXTRA = [0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13];
+const ORDER = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
+const BITS = 15;
+const huffman = (lengths) => {
+    const count = new Uint16Array(BITS + 1);
+    for (let s = 0; s < lengths.length; s += 1)
+        count[lengths[s]] += 1;
+    const offsets = new Uint16Array(BITS + 1);
+    for (let len = 1; len < BITS; len += 1)
+        offsets[len + 1] = offsets[len] + count[len];
+    const symbol = new Uint16Array(lengths.length);
+    for (let s = 0; s < lengths.length; s += 1)
+        if (lengths[s] !== 0)
+            symbol[offsets[lengths[s]]++] = s;
+    count[0] = 0;
+    return { count, symbol };
+};
+const FIXED_LENGTHS = huffman(Array.from({ length: 288 }, (_, s) => (s < 144 ? 8 : s < 256 ? 9 : s < 280 ? 7 : 8)));
+const FIXED_DISTANCES = huffman(Array.from({ length: 30 }, () => 5));
+class Reader {
+    #bytes;
+    at;
+    #buffer = 0;
+    #held = 0;
+    constructor(bytes, at) {
+        this.#bytes = bytes;
+        this.at = at;
+    }
+    bits(n) {
+        while (this.#held < n) {
+            if (this.at >= this.#bytes.length)
+                throw new Error('a stream cut short');
+            this.#buffer |= this.#bytes[this.at++] << this.#held;
+            this.#held += 8;
+        }
+        const out = this.#buffer & ((1 << n) - 1);
+        this.#buffer >>>= n;
+        this.#held -= n;
+        return out;
+    }
+    // The rest of this byte let go, as a stored block and the end ask.
+    align() {
+        this.#buffer = 0;
+        this.#held = 0;
+    }
+    byte() {
+        if (this.at >= this.#bytes.length)
+            throw new Error('a stream cut short');
+        return this.#bytes[this.at++];
+    }
+    decode(h) {
+        let code = 0;
+        let first = 0;
+        let index = 0;
+        for (let len = 1; len <= BITS; len += 1) {
+            code |= this.bits(1);
+            const count = h.count[len];
+            if (code - count < first)
+                return h.symbol[index + (code - first)];
+            index += count;
+            first += count;
+            first <<= 1;
+            code <<= 1;
+        }
+        throw new Error('a code no table holds');
+    }
+}
+class Output {
+    bytes = new Uint8Array(1024);
+    length = 0;
+    #room(n) {
+        if (this.length + n <= this.bytes.length)
+            return;
+        let size = this.bytes.length * 2;
+        while (size < this.length + n)
+            size *= 2;
+        const grown = new Uint8Array(size);
+        grown.set(this.bytes.subarray(0, this.length));
+        this.bytes = grown;
+    }
+    push(byte) {
+        this.#room(1);
+        this.bytes[this.length++] = byte;
+    }
+    copy(distance, length) {
+        if (distance > this.length)
+            throw new Error('a distance before the start');
+        this.#room(length);
+        for (let k = 0; k < length; k += 1)
+            this.bytes[this.length] = this.bytes[this.length++ - distance];
+    }
+}
+const dynamic = (r) => {
+    const nlen = r.bits(5) + 257;
+    const ndist = r.bits(5) + 1;
+    const ncode = r.bits(4) + 4;
+    const codeLengths = new Uint8Array(19);
+    for (let k = 0; k < ncode; k += 1)
+        codeLengths[ORDER[k]] = r.bits(3);
+    const codes = huffman(codeLengths);
+    const lengths = new Uint8Array(nlen + ndist);
+    for (let k = 0; k < nlen + ndist;) {
+        const sym = r.decode(codes);
+        if (sym < 16) {
+            lengths[k++] = sym;
+            continue;
+        }
+        let repeat;
+        let value = 0;
+        if (sym === 16) {
+            if (k === 0)
+                throw new Error('a repeat with nothing before it');
+            value = lengths[k - 1];
+            repeat = 3 + r.bits(2);
+        }
+        else if (sym === 17)
+            repeat = 3 + r.bits(3);
+        else
+            repeat = 11 + r.bits(7);
+        if (k + repeat > nlen + ndist)
+            throw new Error('too many lengths');
+        while (repeat-- > 0)
+            lengths[k++] = value;
+    }
+    return [huffman(lengths.subarray(0, nlen)), huffman(lengths.subarray(nlen))];
+};
+const adler32 = (bytes) => {
+    let a = 1;
+    let b = 0;
+    for (let k = 0; k < bytes.length; k += 1) {
+        a = (a + bytes[k]) % 65521;
+        b = (b + a) % 65521;
+    }
+    return ((b << 16) | a) >>> 0;
+};
+// One zlib stream that starts at `at`: its bytes, and where it ends.
+export const inflateAt = (bytes, at) => {
+    const r = new Reader(bytes, at);
+    const cmf = r.byte();
+    const flg = r.byte();
+    if ((cmf & 15) !== 8 || ((cmf << 8) | flg) % 31 !== 0 || (flg & 32) !== 0)
+        throw new Error('no zlib stream');
+    const out = new Output();
+    for (let last = 0; last === 0;) {
+        last = r.bits(1);
+        const type = r.bits(2);
+        if (type === 0) {
+            r.align();
+            const len = r.byte() | (r.byte() << 8);
+            const nlen = r.byte() | (r.byte() << 8);
+            if ((len ^ 0xffff) !== nlen)
+                throw new Error('a stored block whose length does not check');
+            for (let k = 0; k < len; k += 1)
+                out.push(r.byte());
+            continue;
+        }
+        if (type === 3)
+            throw new Error('a block of no type');
+        const [lengths, distances] = type === 1 ? [FIXED_LENGTHS, FIXED_DISTANCES] : dynamic(r);
+        for (;;) {
+            const sym = r.decode(lengths);
+            if (sym < 256)
+                out.push(sym);
+            else if (sym === 256)
+                break;
+            else {
+                const l = sym - 257;
+                if (l >= 29)
+                    throw new Error('a length of no code');
+                const length = LENGTH_BASE[l] + r.bits(LENGTH_EXTRA[l]);
+                const d = r.decode(distances);
+                if (d >= 30)
+                    throw new Error('a distance of no code');
+                out.copy(DISTANCE_BASE[d] + r.bits(DISTANCE_EXTRA[d]), length);
+            }
+        }
+    }
+    r.align();
+    const sum = ((r.byte() << 24) | (r.byte() << 16) | (r.byte() << 8) | r.byte()) >>> 0;
+    const result = out.bytes.slice(0, out.length);
+    if (sum !== adler32(result))
+        throw new Error('a stream whose sum does not check');
+    return { out: result, end: r.at };
+};