@ac-kit/core 0.1.0

package/dist/buffer/codec/set-uint32-le.js

@@ -0,0 +1,18 @@
+/**
+ * Writes `value` into `target` at `offset` as a little-endian unsigned 32-bit
+ * integer.
+ *
+ * The caller is responsible for ensuring that four bytes are available at
+ * `offset`.
+ *
+ * @param target - The bytes to write into.
+ * @param offset - The index of the first byte to write.
+ * @param value - The value to write; only its low 32 bits are used.
+ */
+export function setUint32Le(target, offset, value) {
+    target[offset] = value & 0xff;
+    target[offset + 1] = (value >>> 8) & 0xff;
+    target[offset + 2] = (value >>> 16) & 0xff;
+    target[offset + 3] = (value >>> 24) & 0xff;
+}
+//# sourceMappingURL=set-uint32-le.js.map

package/dist/buffer/codec/set-uint32-le.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-uint32-le.js","sourceRoot":"","sources":["../../../src/buffer/codec/set-uint32-le.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,UAAU,WAAW,CAC1B,MAAkB,EAClB,MAAc,EACd,KAAa;IAEb,MAAM,CAAC,MAAM,CAAC,GAAG,KAAK,GAAG,IAAI,CAAC;IAC9B,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,CAAC,KAAK,KAAK,CAAC,CAAC,GAAG,IAAI,CAAC;IAC1C,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,CAAC,KAAK,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;IAC3C,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,CAAC,KAAK,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;AAC5C,CAAC"}

package/dist/buffer/compare-bytes.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Compares two `Uint8Array`s lexicographically by byte value.
+ *
+ * @param a The first array to compare.
+ * @param b The second array to compare.
+ * @returns A negative number if `a` sorts before `b`, positive if after, zero
+ *   if equal. When one array is a prefix of the other, the shorter one sorts
+ *   first.
+ */
+export declare function compareBytes(a: Uint8Array, b: Uint8Array): number;
+//# sourceMappingURL=compare-bytes.d.ts.map

package/dist/buffer/compare-bytes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compare-bytes.d.ts","sourceRoot":"","sources":["../../src/buffer/compare-bytes.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,GAAG,MAAM,CAUjE"}

package/dist/buffer/compare-bytes.js

@@ -0,0 +1,19 @@
+/**
+ * Compares two `Uint8Array`s lexicographically by byte value.
+ *
+ * @param a The first array to compare.
+ * @param b The second array to compare.
+ * @returns A negative number if `a` sorts before `b`, positive if after, zero
+ *   if equal. When one array is a prefix of the other, the shorter one sorts
+ *   first.
+ */
+export function compareBytes(a, b) {
+    const len = Math.min(a.length, b.length);
+    for (let index = 0; index < len; index++) {
+        if (a[index] !== b[index]) {
+            return a[index] - b[index];
+        }
+    }
+    return a.length - b.length;
+}
+//# sourceMappingURL=compare-bytes.js.map

package/dist/buffer/compare-bytes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compare-bytes.js","sourceRoot":"","sources":["../../src/buffer/compare-bytes.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,UAAU,YAAY,CAAC,CAAa,EAAE,CAAa;IACxD,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC;IAEzC,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,GAAG,EAAE,KAAK,EAAE,EAAE,CAAC;QAC1C,IAAI,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC;YAC3B,OAAO,CAAC,CAAC,KAAK,CAAE,GAAG,CAAC,CAAC,KAAK,CAAE,CAAC;QAC9B,CAAC;IACF,CAAC;IAED,OAAO,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC;AAC5B,CAAC"}

package/dist/buffer/concat-bytes.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Concatenates any number of `Uint8Array`s into one, copying each source once —
+ * linear in the total byte length. Accepts an array directly to avoid forcing a
+ * spread at large call counts; the variadic overload is for the common small,
+ * fixed-arity call site.
+ *
+ * The result is always backed by a plain `ArrayBuffer`, never a shared one, so
+ * it satisfies `BufferSource` and can be handed straight to a Web API.
+ */
+export declare function concatBytes(arrays: readonly Uint8Array[]): Uint8Array<ArrayBuffer>;
+export declare function concatBytes(...arrays: Uint8Array[]): Uint8Array<ArrayBuffer>;
+//# sourceMappingURL=concat-bytes.d.ts.map

package/dist/buffer/concat-bytes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"concat-bytes.d.ts","sourceRoot":"","sources":["../../src/buffer/concat-bytes.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAC1B,MAAM,EAAE,SAAS,UAAU,EAAE,GAC3B,UAAU,CAAC,WAAW,CAAC,CAAC;AAC3B,wBAAgB,WAAW,CAAC,GAAG,MAAM,EAAE,UAAU,EAAE,GAAG,UAAU,CAAC,WAAW,CAAC,CAAC"}

package/dist/buffer/concat-bytes.js

@@ -0,0 +1,17 @@
+import { fromVariadicArgs } from "../function/variadic-args.js";
+export function concatBytes(...args) {
+    const arrays = fromVariadicArgs(args);
+    let totalLength = 0;
+    for (let index = 0; index < arrays.length; index++) {
+        totalLength += arrays[index].length;
+    }
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (let index = 0; index < arrays.length; index++) {
+        const array = arrays[index];
+        result.set(array, offset);
+        offset += array.length;
+    }
+    return result;
+}
+//# sourceMappingURL=concat-bytes.js.map

package/dist/buffer/concat-bytes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"concat-bytes.js","sourceRoot":"","sources":["../../src/buffer/concat-bytes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAehE,MAAM,UAAU,WAAW,CAC1B,GAAG,IAA4C;IAE/C,MAAM,MAAM,GAAG,gBAAgB,CAAC,IAAI,CAAC,CAAC;IAEtC,IAAI,WAAW,GAAG,CAAC,CAAC;IAEpB,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;QACpD,WAAW,IAAI,MAAM,CAAC,KAAK,CAAE,CAAC,MAAM,CAAC;IACtC,CAAC;IAED,MAAM,MAAM,GAAG,IAAI,UAAU,CAAC,WAAW,CAAC,CAAC;IAC3C,IAAI,MAAM,GAAG,CAAC,CAAC;IAEf,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;QACpD,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAE,CAAC;QAC7B,MAAM,CAAC,GAAG,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;QAC1B,MAAM,IAAI,KAAK,CAAC,MAAM,CAAC;IACxB,CAAC;IAED,OAAO,MAAM,CAAC;AACf,CAAC"}

package/dist/buffer/index-of-sequence.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Index of the first occurrence of `needle` in `haystack`, or `-1`.
+ *
+ * `Uint8Array.prototype.indexOf` only finds single bytes, so multi-byte
+ * sequences (delimiters, magic numbers) need this.
+ *
+ * @param haystack - Bytes to search.
+ * @param needle - Sequence to find. An empty needle matches at `from`.
+ * @param from - Index to start searching at.
+ * @returns The index of the first match, or `-1`.
+ */
+export declare function indexOfSequence(haystack: Uint8Array, needle: Uint8Array, from?: number): number;
+//# sourceMappingURL=index-of-sequence.d.ts.map

package/dist/buffer/index-of-sequence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-of-sequence.d.ts","sourceRoot":"","sources":["../../src/buffer/index-of-sequence.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAC9B,QAAQ,EAAE,UAAU,EACpB,MAAM,EAAE,UAAU,EAClB,IAAI,SAAI,GACN,MAAM,CAuBR"}

package/dist/buffer/index-of-sequence.js

@@ -0,0 +1,31 @@
+/**
+ * Index of the first occurrence of `needle` in `haystack`, or `-1`.
+ *
+ * `Uint8Array.prototype.indexOf` only finds single bytes, so multi-byte
+ * sequences (delimiters, magic numbers) need this.
+ *
+ * @param haystack - Bytes to search.
+ * @param needle - Sequence to find. An empty needle matches at `from`.
+ * @param from - Index to start searching at.
+ * @returns The index of the first match, or `-1`.
+ */
+export function indexOfSequence(haystack, needle, from = 0) {
+    if (needle.length === 0) {
+        return from;
+    }
+    const first = needle[0];
+    const last = haystack.length - needle.length;
+    outer: for (let start = from; start <= last; start++) {
+        if (haystack[start] !== first) {
+            continue;
+        }
+        for (let offset = 1; offset < needle.length; offset++) {
+            if (haystack[start + offset] !== needle[offset]) {
+                continue outer;
+            }
+        }
+        return start;
+    }
+    return -1;
+}
+//# sourceMappingURL=index-of-sequence.js.map

package/dist/buffer/index-of-sequence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-of-sequence.js","sourceRoot":"","sources":["../../src/buffer/index-of-sequence.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,UAAU,eAAe,CAC9B,QAAoB,EACpB,MAAkB,EAClB,IAAI,GAAG,CAAC;IAER,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzB,OAAO,IAAI,CAAC;IACb,CAAC;IAED,MAAM,KAAK,GAAG,MAAM,CAAC,CAAC,CAAE,CAAC;IACzB,MAAM,IAAI,GAAG,QAAQ,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;IAE7C,KAAK,EAAE,KAAK,IAAI,KAAK,GAAG,IAAI,EAAE,KAAK,IAAI,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC;QACtD,IAAI,QAAQ,CAAC,KAAK,CAAC,KAAK,KAAK,EAAE,CAAC;YAC/B,SAAS;QACV,CAAC;QAED,KAAK,IAAI,MAAM,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;YACvD,IAAI,QAAQ,CAAC,KAAK,GAAG,MAAM,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC;gBACjD,SAAS,KAAK,CAAC;YAChB,CAAC;QACF,CAAC;QAED,OAAO,KAAK,CAAC;IACd,CAAC;IAED,OAAO,CAAC,CAAC,CAAC;AACX,CAAC"}

package/dist/buffer/stream/bit-builder.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Accumulates individual bits into bytes, MSB-first within each byte — the
+ * bit-level counterpart of {@link ByteBuilder}, for any bit-packed format (ASN.1
+ * PER/X.691, other bitfield-oriented wire protocols).
+ *
+ * Every `writeBit`/`writeBits` call is O(1) (or O(n) in the bit count for
+ * `writeBits`, never re-walking bits already written); the cost of assembling
+ * the final byte array is paid once, in `result()`.
+ */
+export declare class BitBuilder {
+    private readonly bytes;
+    private currentByte;
+    private bitsInCurrent;
+    /** Total bits written so far. */
+    get bitLength(): number;
+    /** Writes a single bit. */
+    writeBit(bit: 0 | 1): void;
+    /**
+     * Writes the low `n` bits of `value`, MSB first.
+     *
+     * @param value - The bits to write. A plain `number` covers `n` up to 32 —
+     *   the range JS's `<<`/`>>>` bitwise operators support; a `bigint` covers
+     *   any wider `n` (e.g. a PER constrained integer whose range needs more than
+     *   32 bits).
+     * @param n - How many low bits of `value` to write.
+     * @throws {RangeError} When `value` is a plain `number` and `n` is greater
+     *   than 32.
+     */
+    writeBits(value: number, n: number): void;
+    writeBits(value: bigint, n: number): void;
+    /**
+     * For aligned PER-style formats: pads with zero bits to the next byte
+     * boundary.
+     */
+    align(): void;
+    /** Writes a complete byte (8 bits). */
+    writeByte(value: number): void;
+    /** Writes every byte of `data`, in order. */
+    writeBytes(data: Uint8Array): void;
+    /**
+     * Produces the accumulated bytes, padding the last one with zero bits if
+     * needed.
+     */
+    result(): Uint8Array;
+}
+//# sourceMappingURL=bit-builder.d.ts.map

package/dist/buffer/stream/bit-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bit-builder.d.ts","sourceRoot":"","sources":["../../../src/buffer/stream/bit-builder.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,qBAAa,UAAU;IACtB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgB;IACtC,OAAO,CAAC,WAAW,CAAK;IACxB,OAAO,CAAC,aAAa,CAAK;IAE1B,iCAAiC;IACjC,IAAI,SAAS,IAAI,MAAM,CAEtB;IAED,2BAA2B;IAC3B,QAAQ,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,IAAI,CASzB;IAED;;;;;;;;;;OAUG;IACH,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1C,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAoB1C;;;OAGG;IACH,KAAK,IAAI,IAAI,CAMZ;IAED,uCAAuC;IACvC,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAE7B;IAED,6CAA6C;IAC7C,UAAU,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAIjC;IAED;;;OAGG;IACH,MAAM,IAAI,UAAU,CAQnB;CACD"}

package/dist/buffer/stream/bit-builder.js

@@ -0,0 +1,75 @@
+/**
+ * Accumulates individual bits into bytes, MSB-first within each byte — the
+ * bit-level counterpart of {@link ByteBuilder}, for any bit-packed format (ASN.1
+ * PER/X.691, other bitfield-oriented wire protocols).
+ *
+ * Every `writeBit`/`writeBits` call is O(1) (or O(n) in the bit count for
+ * `writeBits`, never re-walking bits already written); the cost of assembling
+ * the final byte array is paid once, in `result()`.
+ */
+export class BitBuilder {
+    bytes = [];
+    currentByte = 0;
+    bitsInCurrent = 0;
+    /** Total bits written so far. */
+    get bitLength() {
+        return this.bytes.length * 8 + this.bitsInCurrent;
+    }
+    /** Writes a single bit. */
+    writeBit(bit) {
+        this.currentByte = (this.currentByte << 1) | bit;
+        this.bitsInCurrent++;
+        if (this.bitsInCurrent === 8) {
+            this.bytes.push(this.currentByte);
+            this.currentByte = 0;
+            this.bitsInCurrent = 0;
+        }
+    }
+    writeBits(value, n) {
+        if (typeof value === "bigint") {
+            for (let shift = BigInt(n - 1); shift >= 0n; shift -= 1n) {
+                this.writeBit(Number((value >> shift) & 1n));
+            }
+            return;
+        }
+        if (n > 32) {
+            throw new RangeError("BitBuilder.writeBits: n must be <= 32 for a number value; pass a bigint for a wider value");
+        }
+        for (let i = n - 1; i >= 0; i--) {
+            this.writeBit(((value >>> i) & 1));
+        }
+    }
+    /**
+     * For aligned PER-style formats: pads with zero bits to the next byte
+     * boundary.
+     */
+    align() {
+        if (this.bitsInCurrent > 0) {
+            this.bytes.push(this.currentByte << (8 - this.bitsInCurrent));
+            this.currentByte = 0;
+            this.bitsInCurrent = 0;
+        }
+    }
+    /** Writes a complete byte (8 bits). */
+    writeByte(value) {
+        this.writeBits(value, 8);
+    }
+    /** Writes every byte of `data`, in order. */
+    writeBytes(data) {
+        for (let i = 0; i < data.length; i++) {
+            this.writeByte(data[i]);
+        }
+    }
+    /**
+     * Produces the accumulated bytes, padding the last one with zero bits if
+     * needed.
+     */
+    result() {
+        const bytes = this.bytes.slice();
+        if (this.bitsInCurrent > 0) {
+            bytes.push(this.currentByte << (8 - this.bitsInCurrent));
+        }
+        return Uint8Array.from(bytes);
+    }
+}
+//# sourceMappingURL=bit-builder.js.map

package/dist/buffer/stream/bit-builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bit-builder.js","sourceRoot":"","sources":["../../../src/buffer/stream/bit-builder.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,OAAO,UAAU;IACL,KAAK,GAAa,EAAE,CAAC;IAC9B,WAAW,GAAG,CAAC,CAAC;IAChB,aAAa,GAAG,CAAC,CAAC;IAE1B,iCAAiC;IACjC,IAAI,SAAS;QACZ,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC;IACnD,CAAC;IAED,2BAA2B;IAC3B,QAAQ,CAAC,GAAU;QAClB,IAAI,CAAC,WAAW,GAAG,CAAC,IAAI,CAAC,WAAW,IAAI,CAAC,CAAC,GAAG,GAAG,CAAC;QACjD,IAAI,CAAC,aAAa,EAAE,CAAC;QAErB,IAAI,IAAI,CAAC,aAAa,KAAK,CAAC,EAAE,CAAC;YAC9B,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;YAClC,IAAI,CAAC,WAAW,GAAG,CAAC,CAAC;YACrB,IAAI,CAAC,aAAa,GAAG,CAAC,CAAC;QACxB,CAAC;IACF,CAAC;IAeD,SAAS,CAAC,KAAsB,EAAE,CAAS;QAC1C,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;YAC/B,KAAK,IAAI,KAAK,GAAG,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,IAAI,EAAE,EAAE,KAAK,IAAI,EAAE,EAAE,CAAC;gBAC1D,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,KAAK,IAAI,KAAK,CAAC,GAAG,EAAE,CAAU,CAAC,CAAC;YACvD,CAAC;YACD,OAAO;QACR,CAAC;QAED,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC;YACZ,MAAM,IAAI,UAAU,CACnB,2FAA2F,CAC3F,CAAC;QACH,CAAC;QAED,KAAK,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YACjC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,GAAG,CAAC,CAAU,CAAC,CAAC;QAC7C,CAAC;IACF,CAAC;IAED;;;OAGG;IACH,KAAK;QACJ,IAAI,IAAI,CAAC,aAAa,GAAG,CAAC,EAAE,CAAC;YAC5B,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC;YAC9D,IAAI,CAAC,WAAW,GAAG,CAAC,CAAC;YACrB,IAAI,CAAC,aAAa,GAAG,CAAC,CAAC;QACxB,CAAC;IACF,CAAC;IAED,uCAAuC;IACvC,SAAS,CAAC,KAAa;QACtB,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;IAC1B,CAAC;IAED,6CAA6C;IAC7C,UAAU,CAAC,IAAgB;QAC1B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACtC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAE,CAAC,CAAC;QAC1B,CAAC;IACF,CAAC;IAED;;;OAGG;IACH,MAAM;QACL,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;QAEjC,IAAI,IAAI,CAAC,aAAa,GAAG,CAAC,EAAE,CAAC;YAC5B,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC;QAC1D,CAAC;QAED,OAAO,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC/B,CAAC;CACD"}

package/dist/buffer/stream/bit-reader.d.ts

@@ -0,0 +1,49 @@
+/**
+ * A cursor over an existing `Uint8Array`, reading individual bits MSB-first
+ * within each byte — the bit-level counterpart of {@link ByteReader}, for any
+ * bit-packed format (ASN.1 PER/X.691, other bitfield-oriented wire protocols).
+ *
+ * Every read advances the cursor by the number of bits read; nothing is copied.
+ */
+export declare class BitReader {
+    private readonly bytes;
+    private bytePos;
+    private bitPos;
+    /**
+     * @param bytes The bytes to read from. Not copied — mutating `bytes` after
+     *   construction is visible to this reader.
+     */
+    constructor(bytes: Uint8Array);
+    /** How many bits remain unread. */
+    get bitsRemaining(): number;
+    /** Whether every bit has been read. */
+    get atEnd(): boolean;
+    private nextBit;
+    /** Reads and returns the next bit, advancing the cursor by one. */
+    readBit(): 0 | 1;
+    /**
+     * Reads the next `n` bits as an unsigned integer, MSB first.
+     *
+     * @throws {RangeError} When `n` is greater than 32 — use {@link readBigBits}
+     *   for a wider field.
+     */
+    readBits(n: number): number;
+    /**
+     * Reads the next `n` bits as an unsigned integer, MSB first — the `bigint`
+     * counterpart of {@link readBits}, for `n` beyond 32 (e.g. a PER constrained
+     * integer whose range needs more than 32 bits).
+     */
+    readBigBits(n: number): bigint;
+    /** For aligned PER-style formats: advances to the next byte boundary. */
+    align(): void;
+    /**
+     * Reads `n` complete bytes as a view (not a copy) into the underlying buffer.
+     *
+     * @throws {RangeError} When the cursor isn't currently byte-aligned, or fewer
+     *   than `n` bytes remain.
+     */
+    readBytes(n: number): Uint8Array;
+    /** Reads a complete byte (8 bits). */
+    readByte(): number;
+}
+//# sourceMappingURL=bit-reader.d.ts.map

package/dist/buffer/stream/bit-reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bit-reader.d.ts","sourceRoot":"","sources":["../../../src/buffer/stream/bit-reader.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,qBAAa,SAAS;IAQT,OAAO,CAAC,QAAQ,CAAC,KAAK;IAPlC,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,MAAM,CAAK;IAEnB;;;OAGG;IACH,YAA6B,KAAK,EAAE,UAAU,EAAI;IAElD,mCAAmC;IACnC,IAAI,aAAa,IAAI,MAAM,CAE1B;IAED,uCAAuC;IACvC,IAAI,KAAK,IAAI,OAAO,CAEnB;IAED,OAAO,CAAC,OAAO;IAgBf,mEAAmE;IACnE,OAAO,IAAI,CAAC,GAAG,CAAC,CAEf;IAED;;;;;OAKG;IACH,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAY1B;IAED;;;;OAIG;IACH,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAM7B;IAED,yEAAyE;IACzE,KAAK,IAAI,IAAI,CAKZ;IAED;;;;;OAKG;IACH,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,UAAU,CAY/B;IAED,sCAAsC;IACtC,QAAQ,IAAI,MAAM,CAEjB;CACD"}

package/dist/buffer/stream/bit-reader.js

@@ -0,0 +1,100 @@
+/**
+ * A cursor over an existing `Uint8Array`, reading individual bits MSB-first
+ * within each byte — the bit-level counterpart of {@link ByteReader}, for any
+ * bit-packed format (ASN.1 PER/X.691, other bitfield-oriented wire protocols).
+ *
+ * Every read advances the cursor by the number of bits read; nothing is copied.
+ */
+export class BitReader {
+    bytes;
+    bytePos = 0;
+    bitPos = 0; // Within the current byte: 0 is the MSB, 7 the LSB.
+    /**
+     * @param bytes The bytes to read from. Not copied — mutating `bytes` after
+     *   construction is visible to this reader.
+     */
+    constructor(bytes) {
+        this.bytes = bytes;
+    }
+    /** How many bits remain unread. */
+    get bitsRemaining() {
+        return (this.bytes.length - this.bytePos) * 8 - this.bitPos;
+    }
+    /** Whether every bit has been read. */
+    get atEnd() {
+        return this.bytePos >= this.bytes.length && this.bitPos === 0;
+    }
+    nextBit() {
+        if (this.bytePos >= this.bytes.length) {
+            throw new RangeError("BitReader: unexpected end of input");
+        }
+        const bit = (this.bytes[this.bytePos] >>> (7 - this.bitPos)) & 1;
+        this.bitPos++;
+        if (this.bitPos === 8) {
+            this.bytePos++;
+            this.bitPos = 0;
+        }
+        return bit;
+    }
+    /** Reads and returns the next bit, advancing the cursor by one. */
+    readBit() {
+        return this.nextBit();
+    }
+    /**
+     * Reads the next `n` bits as an unsigned integer, MSB first.
+     *
+     * @throws {RangeError} When `n` is greater than 32 — use {@link readBigBits}
+     *   for a wider field.
+     */
+    readBits(n) {
+        if (n > 32) {
+            throw new RangeError("BitReader.readBits: n must be <= 32; use readBigBits for a wider value");
+        }
+        let result = 0;
+        for (let i = 0; i < n; i++) {
+            result = (result << 1) | this.nextBit();
+        }
+        return result;
+    }
+    /**
+     * Reads the next `n` bits as an unsigned integer, MSB first — the `bigint`
+     * counterpart of {@link readBits}, for `n` beyond 32 (e.g. a PER constrained
+     * integer whose range needs more than 32 bits).
+     */
+    readBigBits(n) {
+        let result = 0n;
+        for (let i = 0; i < n; i++) {
+            result = (result << 1n) | BigInt(this.nextBit());
+        }
+        return result;
+    }
+    /** For aligned PER-style formats: advances to the next byte boundary. */
+    align() {
+        if (this.bitPos > 0) {
+            this.bytePos++;
+            this.bitPos = 0;
+        }
+    }
+    /**
+     * Reads `n` complete bytes as a view (not a copy) into the underlying buffer.
+     *
+     * @throws {RangeError} When the cursor isn't currently byte-aligned, or fewer
+     *   than `n` bytes remain.
+     */
+    readBytes(n) {
+        if (this.bitPos !== 0) {
+            throw new RangeError("BitReader.readBytes: not byte-aligned");
+        }
+        if (this.bytePos + n > this.bytes.length) {
+            throw new RangeError("BitReader.readBytes: insufficient data");
+        }
+        const view = this.bytes.subarray(this.bytePos, this.bytePos + n);
+        this.bytePos += n;
+        return view;
+    }
+    /** Reads a complete byte (8 bits). */
+    readByte() {
+        return this.readBits(8);
+    }
+}
+//# sourceMappingURL=bit-reader.js.map

package/dist/buffer/stream/bit-reader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bit-reader.js","sourceRoot":"","sources":["../../../src/buffer/stream/bit-reader.ts"],"names":[],"mappings":"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"}

package/dist/buffer/stream/block-accumulator.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Buffers arbitrary-length writes into fixed-size blocks, invoking
+ * `processBlock` once per full block, and carrying any sub-block remainder
+ * across calls.
+ *
+ * The general shape behind any incremental, block-oriented consumer of a byte
+ * stream (block ciphers, block-based hash functions, framed protocols, …):
+ * accumulate the previous remainder plus the new chunk, process every full
+ * block that yields, and keep whatever is left over for next time.
+ *
+ * By default (`holdBackFinalBlock: false`) a block is flushed as soon as it
+ * completes — correct whenever finalization can unambiguously recognise the
+ * true final block from the data itself (e.g. Merkle–Damgård/Keccak padding,
+ * which always appends a marker byte, so nothing already flushed can be
+ * mistaken for it). Pass `holdBackFinalBlock: true` for algorithms whose
+ * finalization instead flips a flag at compress-time with no marker in the data
+ * (BLAKE2): then the last full block a chunk completes is always kept back,
+ * since flushing it immediately would leave no way to later mark it final
+ * without compressing it twice.
+ *
+ * @example
+ * 	```ts
+ * 	const acc = new BlockAccumulator(4, (block, offset) =>
+ * 		console.log(block.subarray(offset, offset + 4)),
+ * 	);
+ * 	acc.absorb(new Uint8Array([1, 2, 3])); // buffered, no full block yet
+ * 	acc.absorb(new Uint8Array([4, 5])); // logs [1,2,3,4]; tail is now [5]
+ * 	```;
+ */
+export declare class BlockAccumulator {
+    private readonly blockSizeBytes;
+    private readonly processBlock;
+    private readonly holdBackFinalBlock;
+    private tail_;
+    /**
+     * @param blockSizeBytes The fixed block size `processBlock` is called with.
+     * @param processBlock Invoked once per full block, in order, never with a
+     *   partial block.
+     * @param holdBackFinalBlock When `true`, the last full block a chunk
+     *   completes is kept in `tail` rather than flushed immediately — see the
+     *   class doc above.
+     */
+    constructor(blockSizeBytes: number, processBlock: (block: Uint8Array, offset: number) => void, holdBackFinalBlock?: boolean);
+    /** The bytes buffered since the last full block, not yet processed. */
+    get tail(): Uint8Array<ArrayBuffer>;
+    /** Discard everything held, without processing it. */
+    clear(): void;
+    /** Buffers `chunk`, processing every full block it completes. */
+    absorb(chunk: Uint8Array): void;
+}
+//# sourceMappingURL=block-accumulator.d.ts.map

package/dist/buffer/stream/block-accumulator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block-accumulator.d.ts","sourceRoot":"","sources":["../../../src/buffer/stream/block-accumulator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,qBAAa,gBAAgB;IAY3B,OAAO,CAAC,QAAQ,CAAC,cAAc;IAC/B,OAAO,CAAC,QAAQ,CAAC,YAAY;IAC7B,OAAO,CAAC,QAAQ,CAAC,kBAAkB;IAbpC,OAAO,CAAC,KAAK,CAAqB;IAElC;;;;;;;OAOG;IACH,YACkB,cAAc,EAAE,MAAM,EACtB,YAAY,EAAE,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,EACzD,kBAAkB,UAAQ,EACxC;IAEJ,uEAAuE;IACvE,IAAI,IAAI,IAAI,UAAU,CAAC,WAAW,CAAC,CAElC;IAED,sDAAsD;IACtD,KAAK,IAAI,IAAI,CAEZ;IAED,iEAAiE;IACjE,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI,CAyB9B;CACD"}

package/dist/buffer/stream/block-accumulator.js

@@ -0,0 +1,79 @@
+/**
+ * Buffers arbitrary-length writes into fixed-size blocks, invoking
+ * `processBlock` once per full block, and carrying any sub-block remainder
+ * across calls.
+ *
+ * The general shape behind any incremental, block-oriented consumer of a byte
+ * stream (block ciphers, block-based hash functions, framed protocols, …):
+ * accumulate the previous remainder plus the new chunk, process every full
+ * block that yields, and keep whatever is left over for next time.
+ *
+ * By default (`holdBackFinalBlock: false`) a block is flushed as soon as it
+ * completes — correct whenever finalization can unambiguously recognise the
+ * true final block from the data itself (e.g. Merkle–Damgård/Keccak padding,
+ * which always appends a marker byte, so nothing already flushed can be
+ * mistaken for it). Pass `holdBackFinalBlock: true` for algorithms whose
+ * finalization instead flips a flag at compress-time with no marker in the data
+ * (BLAKE2): then the last full block a chunk completes is always kept back,
+ * since flushing it immediately would leave no way to later mark it final
+ * without compressing it twice.
+ *
+ * @example
+ * 	```ts
+ * 	const acc = new BlockAccumulator(4, (block, offset) =>
+ * 		console.log(block.subarray(offset, offset + 4)),
+ * 	);
+ * 	acc.absorb(new Uint8Array([1, 2, 3])); // buffered, no full block yet
+ * 	acc.absorb(new Uint8Array([4, 5])); // logs [1,2,3,4]; tail is now [5]
+ * 	```;
+ */
+export class BlockAccumulator {
+    blockSizeBytes;
+    processBlock;
+    holdBackFinalBlock;
+    tail_ = new Uint8Array(0);
+    /**
+     * @param blockSizeBytes The fixed block size `processBlock` is called with.
+     * @param processBlock Invoked once per full block, in order, never with a
+     *   partial block.
+     * @param holdBackFinalBlock When `true`, the last full block a chunk
+     *   completes is kept in `tail` rather than flushed immediately — see the
+     *   class doc above.
+     */
+    constructor(blockSizeBytes, processBlock, holdBackFinalBlock = false) {
+        this.blockSizeBytes = blockSizeBytes;
+        this.processBlock = processBlock;
+        this.holdBackFinalBlock = holdBackFinalBlock;
+    }
+    /** The bytes buffered since the last full block, not yet processed. */
+    get tail() {
+        return this.tail_;
+    }
+    /** Discard everything held, without processing it. */
+    clear() {
+        this.tail_ = new Uint8Array(0);
+    }
+    /** Buffers `chunk`, processing every full block it completes. */
+    absorb(chunk) {
+        let combined;
+        if (this.tail_.length > 0) {
+            combined = new Uint8Array(this.tail_.length + chunk.length);
+            combined.set(this.tail_);
+            combined.set(chunk, this.tail_.length);
+        }
+        else {
+            combined = chunk;
+        }
+        let offset = 0;
+        while (this.holdBackFinalBlock
+            ? combined.length - offset > this.blockSizeBytes
+            : combined.length - offset >= this.blockSizeBytes) {
+            this.processBlock(combined, offset);
+            offset += this.blockSizeBytes;
+        }
+        // slice() copies, so mutating the caller's chunk after absorb() returns
+        // can never corrupt the carried tail.
+        this.tail_ = combined.slice(offset);
+    }
+}
+//# sourceMappingURL=block-accumulator.js.map

package/dist/buffer/stream/block-accumulator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"block-accumulator.js","sourceRoot":"","sources":["../../../src/buffer/stream/block-accumulator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,OAAO,gBAAgB;IAYV,cAAc;IACd,YAAY;IACZ,kBAAkB;IAb5B,KAAK,GAAG,IAAI,UAAU,CAAC,CAAC,CAAC,CAAC;IAElC;;;;;;;OAOG;IACH,YACkB,cAAsB,EACtB,YAAyD,EACzD,kBAAkB,GAAG,KAAK;8BAF1B,cAAc;4BACd,YAAY;kCACZ,kBAAkB;IACjC,CAAC;IAEJ,uEAAuE;IACvE,IAAI,IAAI;QACP,OAAO,IAAI,CAAC,KAAK,CAAC;IACnB,CAAC;IAED,sDAAsD;IACtD,KAAK;QACJ,IAAI,CAAC,KAAK,GAAG,IAAI,UAAU,CAAC,CAAC,CAAC,CAAC;IAChC,CAAC;IAED,iEAAiE;IACjE,MAAM,CAAC,KAAiB;QACvB,IAAI,QAAoB,CAAC;QAEzB,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC3B,QAAQ,GAAG,IAAI,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC;YAC5D,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACzB,QAAQ,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QACxC,CAAC;aAAM,CAAC;YACP,QAAQ,GAAG,KAAK,CAAC;QAClB,CAAC;QAED,IAAI,MAAM,GAAG,CAAC,CAAC;QAEf,OACC,IAAI,CAAC,kBAAkB;YACtB,CAAC,CAAC,QAAQ,CAAC,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC,cAAc;YAChD,CAAC,CAAC,QAAQ,CAAC,MAAM,GAAG,MAAM,IAAI,IAAI,CAAC,cAAc,EACjD,CAAC;YACF,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;YACpC,MAAM,IAAI,IAAI,CAAC,cAAc,CAAC;QAC/B,CAAC;QAED,wEAAwE;QACxE,sCAAsC;QACtC,IAAI,CAAC,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IACrC,CAAC;CACD"}