@ac-kit/core 0.1.0

package/dist/buffer/codec/get-uint32-be.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Reads a big-endian unsigned integer from `data` at `offset`.
+ *
+ * Unlike `DataView.getUint32`, this reads straight from the array and therefore
+ * needs no view object per call. The caller is responsible for ensuring that
+ * `byteLength` bytes are available at `offset`.
+ *
+ * @param data - The bytes to read from.
+ * @param offset - The index of the first byte to read.
+ * @param byteLength - How many bytes to read, in the 0..4 range. Defaults to 4
+ *   (a full word); fewer bytes read a narrower big-endian integer formed from
+ *   just those leading bytes — not a zero-padded full word — for a binary
+ *   format's variable-width or partial trailing fields.
+ * @returns The value as an unsigned 32-bit integer.
+ */
+export declare function getUint32Be(data: Uint8Array, offset: number, byteLength?: number): number;
+//# sourceMappingURL=get-uint32-be.d.ts.map

package/dist/buffer/codec/get-uint32-be.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-uint32-be.d.ts","sourceRoot":"","sources":["../../../src/buffer/codec/get-uint32-be.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,WAAW,CAC1B,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE,MAAM,EACd,UAAU,SAAI,GACZ,MAAM,CAgBR"}

package/dist/buffer/codec/get-uint32-be.js

@@ -0,0 +1,30 @@
+/**
+ * Reads a big-endian unsigned integer from `data` at `offset`.
+ *
+ * Unlike `DataView.getUint32`, this reads straight from the array and therefore
+ * needs no view object per call. The caller is responsible for ensuring that
+ * `byteLength` bytes are available at `offset`.
+ *
+ * @param data - The bytes to read from.
+ * @param offset - The index of the first byte to read.
+ * @param byteLength - How many bytes to read, in the 0..4 range. Defaults to 4
+ *   (a full word); fewer bytes read a narrower big-endian integer formed from
+ *   just those leading bytes — not a zero-padded full word — for a binary
+ *   format's variable-width or partial trailing fields.
+ * @returns The value as an unsigned 32-bit integer.
+ */
+export function getUint32Be(data, offset, byteLength = 4) {
+    if (byteLength === 4) {
+        return (((data[offset] << 24) |
+            (data[offset + 1] << 16) |
+            (data[offset + 2] << 8) |
+            data[offset + 3]) >>>
+            0);
+    }
+    let value = 0;
+    for (let i = 0; i < byteLength; i++) {
+        value = ((value << 8) | data[offset + i]) >>> 0;
+    }
+    return value;
+}
+//# sourceMappingURL=get-uint32-be.js.map

package/dist/buffer/codec/get-uint32-be.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-uint32-be.js","sourceRoot":"","sources":["../../../src/buffer/codec/get-uint32-be.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,WAAW,CAC1B,IAAgB,EAChB,MAAc,EACd,UAAU,GAAG,CAAC;IAEd,IAAI,UAAU,KAAK,CAAC,EAAE,CAAC;QACtB,OAAO,CACN,CAAC,CAAC,IAAI,CAAC,MAAM,CAAE,IAAI,EAAE,CAAC;YACrB,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAE,IAAI,EAAE,CAAC;YACzB,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAE,IAAI,CAAC,CAAC;YACxB,IAAI,CAAC,MAAM,GAAG,CAAC,CAAE,CAAC;YACnB,CAAC,CACD,CAAC;IACH,CAAC;IAED,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,EAAE,CAAC,EAAE,EAAE,CAAC;QACrC,KAAK,GAAG,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC,CAAE,CAAC,KAAK,CAAC,CAAC;IAClD,CAAC;IACD,OAAO,KAAK,CAAC;AACd,CAAC"}

package/dist/buffer/codec/get-uint32-le.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Reads a little-endian unsigned integer from `data` at `offset`.
+ *
+ * Unlike `DataView.getUint32`, this reads straight from the array and therefore
+ * needs no view object per call. The caller is responsible for ensuring that
+ * `byteLength` bytes are available at `offset`.
+ *
+ * @param data - The bytes to read from.
+ * @param offset - The index of the first byte to read.
+ * @param byteLength - How many bytes to read, in the 0..4 range. Defaults to 4
+ *   (a full word); fewer bytes read a narrower little-endian integer formed
+ *   from just those leading bytes, which for little-endian is equivalent to
+ *   zero-padding the missing high bytes — for a binary format's variable-width
+ *   or partial trailing fields.
+ * @returns The value as an unsigned 32-bit integer.
+ */
+export declare function getUint32Le(data: Uint8Array, offset: number, byteLength?: number): number;
+//# sourceMappingURL=get-uint32-le.d.ts.map

package/dist/buffer/codec/get-uint32-le.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-uint32-le.d.ts","sourceRoot":"","sources":["../../../src/buffer/codec/get-uint32-le.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,WAAW,CAC1B,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE,MAAM,EACd,UAAU,SAAI,GACZ,MAAM,CAgBR"}

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

@@ -0,0 +1,31 @@
+/**
+ * Reads a little-endian unsigned integer from `data` at `offset`.
+ *
+ * Unlike `DataView.getUint32`, this reads straight from the array and therefore
+ * needs no view object per call. The caller is responsible for ensuring that
+ * `byteLength` bytes are available at `offset`.
+ *
+ * @param data - The bytes to read from.
+ * @param offset - The index of the first byte to read.
+ * @param byteLength - How many bytes to read, in the 0..4 range. Defaults to 4
+ *   (a full word); fewer bytes read a narrower little-endian integer formed
+ *   from just those leading bytes, which for little-endian is equivalent to
+ *   zero-padding the missing high bytes — for a binary format's variable-width
+ *   or partial trailing fields.
+ * @returns The value as an unsigned 32-bit integer.
+ */
+export function getUint32Le(data, offset, byteLength = 4) {
+    if (byteLength === 4) {
+        return ((data[offset] |
+            (data[offset + 1] << 8) |
+            (data[offset + 2] << 16) |
+            (data[offset + 3] << 24)) >>>
+            0);
+    }
+    let value = 0;
+    for (let i = byteLength - 1; i >= 0; i--) {
+        value = ((value << 8) | data[offset + i]) >>> 0;
+    }
+    return value;
+}
+//# sourceMappingURL=get-uint32-le.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get-uint32-le.js","sourceRoot":"","sources":["../../../src/buffer/codec/get-uint32-le.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,WAAW,CAC1B,IAAgB,EAChB,MAAc,EACd,UAAU,GAAG,CAAC;IAEd,IAAI,UAAU,KAAK,CAAC,EAAE,CAAC;QACtB,OAAO,CACN,CAAC,IAAI,CAAC,MAAM,CAAE;YACb,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAE,IAAI,CAAC,CAAC;YACxB,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAE,IAAI,EAAE,CAAC;YACzB,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAE,IAAI,EAAE,CAAC,CAAC;YAC3B,CAAC,CACD,CAAC;IACH,CAAC;IAED,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,KAAK,IAAI,CAAC,GAAG,UAAU,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QAC1C,KAAK,GAAG,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC,CAAE,CAAC,KAAK,CAAC,CAAC;IAClD,CAAC;IACD,OAAO,KAAK,CAAC;AACd,CAAC"}

package/dist/buffer/codec/set-big-uint64-array-be.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Writes `words` into `target` at `offset` as big-endian bytes, in place.
+ *
+ * @param target - The bytes to write into. The caller is responsible for
+ *   ensuring that `byteLength` bytes are available at `offset`.
+ * @param offset - The index of the first byte to write.
+ * @param words - The words to serialize.
+ * @param byteLength - How many leading bytes to write. Defaults to all of
+ *   `words`. Truncation is byte-granular, not word-granular.
+ */
+export declare function setBigUint64ArrayBe(target: Uint8Array, offset: number, words: BigUint64Array, byteLength?: number): void;
+//# sourceMappingURL=set-big-uint64-array-be.d.ts.map

package/dist/buffer/codec/set-big-uint64-array-be.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-big-uint64-array-be.d.ts","sourceRoot":"","sources":["../../../src/buffer/codec/set-big-uint64-array-be.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAClC,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,cAAc,EACrB,UAAU,GAAE,MAAyB,GACnC,IAAI,CAcN"}

package/dist/buffer/codec/set-big-uint64-array-be.js

@@ -0,0 +1,24 @@
+import { setBigUint64Be } from "./set-big-uint64-be.js";
+/**
+ * Writes `words` into `target` at `offset` as big-endian bytes, in place.
+ *
+ * @param target - The bytes to write into. The caller is responsible for
+ *   ensuring that `byteLength` bytes are available at `offset`.
+ * @param offset - The index of the first byte to write.
+ * @param words - The words to serialize.
+ * @param byteLength - How many leading bytes to write. Defaults to all of
+ *   `words`. Truncation is byte-granular, not word-granular.
+ */
+export function setBigUint64ArrayBe(target, offset, words, byteLength = words.length * 8) {
+    const fullWords = byteLength >> 3;
+    for (let word = 0; word < fullWords; word++) {
+        setBigUint64Be(target, offset + word * 8, words[word]);
+    }
+    const remainder = byteLength - fullWords * 8;
+    if (remainder > 0) {
+        const tail = new Uint8Array(8);
+        setBigUint64Be(tail, 0, words[fullWords]);
+        target.set(tail.subarray(0, remainder), offset + fullWords * 8);
+    }
+}
+//# sourceMappingURL=set-big-uint64-array-be.js.map

package/dist/buffer/codec/set-big-uint64-array-be.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-big-uint64-array-be.js","sourceRoot":"","sources":["../../../src/buffer/codec/set-big-uint64-array-be.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAExD;;;;;;;;;GASG;AACH,MAAM,UAAU,mBAAmB,CAClC,MAAkB,EAClB,MAAc,EACd,KAAqB,EACrB,UAAU,GAAW,KAAK,CAAC,MAAM,GAAG,CAAC;IAErC,MAAM,SAAS,GAAG,UAAU,IAAI,CAAC,CAAC;IAElC,KAAK,IAAI,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,SAAS,EAAE,IAAI,EAAE,EAAE,CAAC;QAC7C,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,CAAC,EAAE,KAAK,CAAC,IAAI,CAAE,CAAC,CAAC;IACzD,CAAC;IAED,MAAM,SAAS,GAAG,UAAU,GAAG,SAAS,GAAG,CAAC,CAAC;IAE7C,IAAI,SAAS,GAAG,CAAC,EAAE,CAAC;QACnB,MAAM,IAAI,GAAG,IAAI,UAAU,CAAC,CAAC,CAAC,CAAC;QAC/B,cAAc,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,CAAC,SAAS,CAAE,CAAC,CAAC;QAC3C,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,CAAC,CAAC,CAAC;IACjE,CAAC;AACF,CAAC"}

package/dist/buffer/codec/set-big-uint64-array-le.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Writes `words` into `target` at `offset` as little-endian bytes, in place.
+ *
+ * @param target - The bytes to write into. The caller is responsible for
+ *   ensuring that `byteLength` bytes are available at `offset`.
+ * @param offset - The index of the first byte to write.
+ * @param words - The words to serialize.
+ * @param byteLength - How many leading bytes to write. Defaults to all of
+ *   `words`. Truncation is byte-granular, not word-granular — e.g. BLAKE2b
+ *   accepts any output length from 1 to 64 bytes, not just multiples of 8.
+ */
+export declare function setBigUint64ArrayLe(target: Uint8Array, offset: number, words: BigUint64Array, byteLength?: number): void;
+//# sourceMappingURL=set-big-uint64-array-le.d.ts.map

package/dist/buffer/codec/set-big-uint64-array-le.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-big-uint64-array-le.d.ts","sourceRoot":"","sources":["../../../src/buffer/codec/set-big-uint64-array-le.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAClC,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,cAAc,EACrB,UAAU,GAAE,MAAyB,GACnC,IAAI,CAcN"}

package/dist/buffer/codec/set-big-uint64-array-le.js

@@ -0,0 +1,25 @@
+import { setBigUint64Le } from "./set-big-uint64-le.js";
+/**
+ * Writes `words` into `target` at `offset` as little-endian bytes, in place.
+ *
+ * @param target - The bytes to write into. The caller is responsible for
+ *   ensuring that `byteLength` bytes are available at `offset`.
+ * @param offset - The index of the first byte to write.
+ * @param words - The words to serialize.
+ * @param byteLength - How many leading bytes to write. Defaults to all of
+ *   `words`. Truncation is byte-granular, not word-granular — e.g. BLAKE2b
+ *   accepts any output length from 1 to 64 bytes, not just multiples of 8.
+ */
+export function setBigUint64ArrayLe(target, offset, words, byteLength = words.length * 8) {
+    const fullWords = byteLength >> 3;
+    for (let word = 0; word < fullWords; word++) {
+        setBigUint64Le(target, offset + word * 8, words[word]);
+    }
+    const remainder = byteLength - fullWords * 8;
+    if (remainder > 0) {
+        const tail = new Uint8Array(8);
+        setBigUint64Le(tail, 0, words[fullWords]);
+        target.set(tail.subarray(0, remainder), offset + fullWords * 8);
+    }
+}
+//# sourceMappingURL=set-big-uint64-array-le.js.map

package/dist/buffer/codec/set-big-uint64-array-le.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-big-uint64-array-le.js","sourceRoot":"","sources":["../../../src/buffer/codec/set-big-uint64-array-le.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAExD;;;;;;;;;;GAUG;AACH,MAAM,UAAU,mBAAmB,CAClC,MAAkB,EAClB,MAAc,EACd,KAAqB,EACrB,UAAU,GAAW,KAAK,CAAC,MAAM,GAAG,CAAC;IAErC,MAAM,SAAS,GAAG,UAAU,IAAI,CAAC,CAAC;IAElC,KAAK,IAAI,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,SAAS,EAAE,IAAI,EAAE,EAAE,CAAC;QAC7C,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,CAAC,EAAE,KAAK,CAAC,IAAI,CAAE,CAAC,CAAC;IACzD,CAAC;IAED,MAAM,SAAS,GAAG,UAAU,GAAG,SAAS,GAAG,CAAC,CAAC;IAE7C,IAAI,SAAS,GAAG,CAAC,EAAE,CAAC;QACnB,MAAM,IAAI,GAAG,IAAI,UAAU,CAAC,CAAC,CAAC,CAAC;QAC/B,cAAc,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,CAAC,SAAS,CAAE,CAAC,CAAC;QAC3C,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,CAAC,CAAC,CAAC;IACjE,CAAC;AACF,CAAC"}

package/dist/buffer/codec/set-big-uint64-be.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Writes `value` into `target` at `offset` as a big-endian unsigned 64-bit
+ * integer.
+ *
+ * The caller is responsible for ensuring that eight 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 64 bits are used.
+ */
+export declare function setBigUint64Be(target: Uint8Array, offset: number, value: bigint): void;
+//# sourceMappingURL=set-big-uint64-be.d.ts.map

package/dist/buffer/codec/set-big-uint64-be.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-big-uint64-be.d.ts","sourceRoot":"","sources":["../../../src/buffer/codec/set-big-uint64-be.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAC7B,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GACX,IAAI,CAGN"}

package/dist/buffer/codec/set-big-uint64-be.js

@@ -0,0 +1,18 @@
+import { MASK_32N } from "../../constants/mask.js";
+import { setUint32Be } from "./set-uint32-be.js";
+/**
+ * Writes `value` into `target` at `offset` as a big-endian unsigned 64-bit
+ * integer.
+ *
+ * The caller is responsible for ensuring that eight 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 64 bits are used.
+ */
+export function setBigUint64Be(target, offset, value) {
+    setUint32Be(target, offset, Number((value >> 32n) & MASK_32N));
+    setUint32Be(target, offset + 4, Number(value & MASK_32N));
+}
+//# sourceMappingURL=set-big-uint64-be.js.map

package/dist/buffer/codec/set-big-uint64-be.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-big-uint64-be.js","sourceRoot":"","sources":["../../../src/buffer/codec/set-big-uint64-be.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AACnD,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEjD;;;;;;;;;;GAUG;AACH,MAAM,UAAU,cAAc,CAC7B,MAAkB,EAClB,MAAc,EACd,KAAa;IAEb,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,KAAK,IAAI,GAAG,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC;IAC/D,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,CAAC,EAAE,MAAM,CAAC,KAAK,GAAG,QAAQ,CAAC,CAAC,CAAC;AAC3D,CAAC"}

package/dist/buffer/codec/set-big-uint64-le.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Writes `value` into `target` at `offset` as a little-endian unsigned 64-bit
+ * integer.
+ *
+ * The caller is responsible for ensuring that eight 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 64 bits are used.
+ */
+export declare function setBigUint64Le(target: Uint8Array, offset: number, value: bigint): void;
+//# sourceMappingURL=set-big-uint64-le.d.ts.map

package/dist/buffer/codec/set-big-uint64-le.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-big-uint64-le.d.ts","sourceRoot":"","sources":["../../../src/buffer/codec/set-big-uint64-le.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAC7B,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GACX,IAAI,CAGN"}

package/dist/buffer/codec/set-big-uint64-le.js

@@ -0,0 +1,18 @@
+import { MASK_32N } from "../../constants/mask.js";
+import { setUint32Le } from "./set-uint32-le.js";
+/**
+ * Writes `value` into `target` at `offset` as a little-endian unsigned 64-bit
+ * integer.
+ *
+ * The caller is responsible for ensuring that eight 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 64 bits are used.
+ */
+export function setBigUint64Le(target, offset, value) {
+    setUint32Le(target, offset, Number(value & MASK_32N));
+    setUint32Le(target, offset + 4, Number((value >> 32n) & MASK_32N));
+}
+//# sourceMappingURL=set-big-uint64-le.js.map

package/dist/buffer/codec/set-big-uint64-le.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-big-uint64-le.js","sourceRoot":"","sources":["../../../src/buffer/codec/set-big-uint64-le.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AACnD,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEjD;;;;;;;;;;GAUG;AACH,MAAM,UAAU,cAAc,CAC7B,MAAkB,EAClB,MAAc,EACd,KAAa;IAEb,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,KAAK,GAAG,QAAQ,CAAC,CAAC,CAAC;IACtD,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,CAAC,EAAE,MAAM,CAAC,CAAC,KAAK,IAAI,GAAG,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC;AACpE,CAAC"}

package/dist/buffer/codec/set-float32-be.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Writes `value` into `target` at `offset` as a big-endian IEEE 754
+ * single-precision (binary32) float.
+ *
+ * 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.
+ */
+export declare function setFloat32Be(target: Uint8Array, offset: number, value: number): void;
+//# sourceMappingURL=set-float32-be.d.ts.map

package/dist/buffer/codec/set-float32-be.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-float32-be.d.ts","sourceRoot":"","sources":["../../../src/buffer/codec/set-float32-be.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAC3B,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GACX,IAAI,CAMN"}

package/dist/buffer/codec/set-float32-be.js

@@ -0,0 +1,15 @@
+/**
+ * Writes `value` into `target` at `offset` as a big-endian IEEE 754
+ * single-precision (binary32) float.
+ *
+ * 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.
+ */
+export function setFloat32Be(target, offset, value) {
+    new DataView(target.buffer, target.byteOffset + offset, 4).setFloat32(0, value, false);
+}
+//# sourceMappingURL=set-float32-be.js.map

package/dist/buffer/codec/set-float32-be.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-float32-be.js","sourceRoot":"","sources":["../../../src/buffer/codec/set-float32-be.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,UAAU,YAAY,CAC3B,MAAkB,EAClB,MAAc,EACd,KAAa;IAEb,IAAI,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,UAAU,GAAG,MAAM,EAAE,CAAC,CAAC,CAAC,UAAU,CACpE,CAAC,EACD,KAAK,EACL,KAAK,CACL,CAAC;AACH,CAAC"}

package/dist/buffer/codec/set-float32-le.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Writes `value` into `target` at `offset` as a little-endian IEEE 754
+ * single-precision (binary32) float.
+ *
+ * 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.
+ */
+export declare function setFloat32Le(target: Uint8Array, offset: number, value: number): void;
+//# sourceMappingURL=set-float32-le.d.ts.map

package/dist/buffer/codec/set-float32-le.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-float32-le.d.ts","sourceRoot":"","sources":["../../../src/buffer/codec/set-float32-le.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAC3B,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GACX,IAAI,CAMN"}

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

@@ -0,0 +1,15 @@
+/**
+ * Writes `value` into `target` at `offset` as a little-endian IEEE 754
+ * single-precision (binary32) float.
+ *
+ * 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.
+ */
+export function setFloat32Le(target, offset, value) {
+    new DataView(target.buffer, target.byteOffset + offset, 4).setFloat32(0, value, true);
+}
+//# sourceMappingURL=set-float32-le.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"set-float32-le.js","sourceRoot":"","sources":["../../../src/buffer/codec/set-float32-le.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,UAAU,YAAY,CAC3B,MAAkB,EAClB,MAAc,EACd,KAAa;IAEb,IAAI,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,UAAU,GAAG,MAAM,EAAE,CAAC,CAAC,CAAC,UAAU,CACpE,CAAC,EACD,KAAK,EACL,IAAI,CACJ,CAAC;AACH,CAAC"}

package/dist/buffer/codec/set-float64-be.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Writes `value` into `target` at `offset` as a big-endian IEEE 754
+ * double-precision (binary64) float.
+ *
+ * The caller is responsible for ensuring that eight 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.
+ */
+export declare function setFloat64Be(target: Uint8Array, offset: number, value: number): void;
+//# sourceMappingURL=set-float64-be.d.ts.map

package/dist/buffer/codec/set-float64-be.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-float64-be.d.ts","sourceRoot":"","sources":["../../../src/buffer/codec/set-float64-be.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAC3B,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GACX,IAAI,CAMN"}

package/dist/buffer/codec/set-float64-be.js

@@ -0,0 +1,15 @@
+/**
+ * Writes `value` into `target` at `offset` as a big-endian IEEE 754
+ * double-precision (binary64) float.
+ *
+ * The caller is responsible for ensuring that eight 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.
+ */
+export function setFloat64Be(target, offset, value) {
+    new DataView(target.buffer, target.byteOffset + offset, 8).setFloat64(0, value, false);
+}
+//# sourceMappingURL=set-float64-be.js.map

package/dist/buffer/codec/set-float64-be.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-float64-be.js","sourceRoot":"","sources":["../../../src/buffer/codec/set-float64-be.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,UAAU,YAAY,CAC3B,MAAkB,EAClB,MAAc,EACd,KAAa;IAEb,IAAI,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,UAAU,GAAG,MAAM,EAAE,CAAC,CAAC,CAAC,UAAU,CACpE,CAAC,EACD,KAAK,EACL,KAAK,CACL,CAAC;AACH,CAAC"}

package/dist/buffer/codec/set-float64-le.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Writes `value` into `target` at `offset` as a little-endian IEEE 754
+ * double-precision (binary64) float.
+ *
+ * The caller is responsible for ensuring that eight 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.
+ */
+export declare function setFloat64Le(target: Uint8Array, offset: number, value: number): void;
+//# sourceMappingURL=set-float64-le.d.ts.map

package/dist/buffer/codec/set-float64-le.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-float64-le.d.ts","sourceRoot":"","sources":["../../../src/buffer/codec/set-float64-le.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAC3B,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GACX,IAAI,CAMN"}

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

@@ -0,0 +1,15 @@
+/**
+ * Writes `value` into `target` at `offset` as a little-endian IEEE 754
+ * double-precision (binary64) float.
+ *
+ * The caller is responsible for ensuring that eight 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.
+ */
+export function setFloat64Le(target, offset, value) {
+    new DataView(target.buffer, target.byteOffset + offset, 8).setFloat64(0, value, true);
+}
+//# sourceMappingURL=set-float64-le.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"set-float64-le.js","sourceRoot":"","sources":["../../../src/buffer/codec/set-float64-le.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,UAAU,YAAY,CAC3B,MAAkB,EAClB,MAAc,EACd,KAAa;IAEb,IAAI,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,UAAU,GAAG,MAAM,EAAE,CAAC,CAAC,CAAC,UAAU,CACpE,CAAC,EACD,KAAK,EACL,IAAI,CACJ,CAAC;AACH,CAAC"}

package/dist/buffer/codec/set-uint32-array-be.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Writes `words` into `target` at `offset` as big-endian bytes, in place.
+ *
+ * @param target - The bytes to write into. The caller is responsible for
+ *   ensuring that `byteLength` bytes are available at `offset`.
+ * @param offset - The index of the first byte to write.
+ * @param words - The words to serialize.
+ * @param byteLength - How many leading bytes to write. Defaults to all of
+ *   `words`. Truncation is byte-granular, not word-granular — e.g. BLAKE2s
+ *   accepts any output length from 1 to 32 bytes, not just multiples of 4 — so
+ *   a truncated final word writes only its leading bytes, never spilling past
+ *   `offset + byteLength` into whatever follows in `target`.
+ */
+export declare function setUint32ArrayBe(target: Uint8Array, offset: number, words: Uint32Array, byteLength?: number): void;
+//# sourceMappingURL=set-uint32-array-be.d.ts.map

package/dist/buffer/codec/set-uint32-array-be.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-uint32-array-be.d.ts","sourceRoot":"","sources":["../../../src/buffer/codec/set-uint32-array-be.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAC/B,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,WAAW,EAClB,UAAU,GAAE,MAAyB,GACnC,IAAI,CAcN"}

package/dist/buffer/codec/set-uint32-array-be.js

@@ -0,0 +1,27 @@
+import { setUint32Be } from "./set-uint32-be.js";
+/**
+ * Writes `words` into `target` at `offset` as big-endian bytes, in place.
+ *
+ * @param target - The bytes to write into. The caller is responsible for
+ *   ensuring that `byteLength` bytes are available at `offset`.
+ * @param offset - The index of the first byte to write.
+ * @param words - The words to serialize.
+ * @param byteLength - How many leading bytes to write. Defaults to all of
+ *   `words`. Truncation is byte-granular, not word-granular — e.g. BLAKE2s
+ *   accepts any output length from 1 to 32 bytes, not just multiples of 4 — so
+ *   a truncated final word writes only its leading bytes, never spilling past
+ *   `offset + byteLength` into whatever follows in `target`.
+ */
+export function setUint32ArrayBe(target, offset, words, byteLength = words.length * 4) {
+    const fullWords = byteLength >> 2;
+    for (let word = 0; word < fullWords; word++) {
+        setUint32Be(target, offset + word * 4, words[word]);
+    }
+    const remainder = byteLength - fullWords * 4;
+    if (remainder > 0) {
+        const tail = new Uint8Array(4);
+        setUint32Be(tail, 0, words[fullWords]);
+        target.set(tail.subarray(0, remainder), offset + fullWords * 4);
+    }
+}
+//# sourceMappingURL=set-uint32-array-be.js.map

package/dist/buffer/codec/set-uint32-array-be.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-uint32-array-be.js","sourceRoot":"","sources":["../../../src/buffer/codec/set-uint32-array-be.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEjD;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,gBAAgB,CAC/B,MAAkB,EAClB,MAAc,EACd,KAAkB,EAClB,UAAU,GAAW,KAAK,CAAC,MAAM,GAAG,CAAC;IAErC,MAAM,SAAS,GAAG,UAAU,IAAI,CAAC,CAAC;IAElC,KAAK,IAAI,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,SAAS,EAAE,IAAI,EAAE,EAAE,CAAC;QAC7C,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,CAAC,EAAE,KAAK,CAAC,IAAI,CAAE,CAAC,CAAC;IACtD,CAAC;IAED,MAAM,SAAS,GAAG,UAAU,GAAG,SAAS,GAAG,CAAC,CAAC;IAE7C,IAAI,SAAS,GAAG,CAAC,EAAE,CAAC;QACnB,MAAM,IAAI,GAAG,IAAI,UAAU,CAAC,CAAC,CAAC,CAAC;QAC/B,WAAW,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,CAAC,SAAS,CAAE,CAAC,CAAC;QACxC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,CAAC,CAAC,CAAC;IACjE,CAAC;AACF,CAAC"}

package/dist/buffer/codec/set-uint32-array-le.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Writes `words` into `target` at `offset` as little-endian bytes, in place.
+ *
+ * @param target - The bytes to write into. The caller is responsible for
+ *   ensuring that `byteLength` bytes are available at `offset`.
+ * @param offset - The index of the first byte to write.
+ * @param words - The words to serialize.
+ * @param byteLength - How many leading bytes to write. Defaults to all of
+ *   `words`. Truncation is byte-granular, not word-granular — e.g. BLAKE2s
+ *   accepts any output length from 1 to 32 bytes, not just multiples of 4 — so
+ *   a truncated final word writes only its leading bytes, never spilling past
+ *   `offset + byteLength` into whatever follows in `target`.
+ */
+export declare function setUint32ArrayLe(target: Uint8Array, offset: number, words: Uint32Array, byteLength?: number): void;
+//# sourceMappingURL=set-uint32-array-le.d.ts.map

package/dist/buffer/codec/set-uint32-array-le.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-uint32-array-le.d.ts","sourceRoot":"","sources":["../../../src/buffer/codec/set-uint32-array-le.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAC/B,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,WAAW,EAClB,UAAU,GAAE,MAAyB,GACnC,IAAI,CAcN"}

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

@@ -0,0 +1,27 @@
+import { setUint32Le } from "./set-uint32-le.js";
+/**
+ * Writes `words` into `target` at `offset` as little-endian bytes, in place.
+ *
+ * @param target - The bytes to write into. The caller is responsible for
+ *   ensuring that `byteLength` bytes are available at `offset`.
+ * @param offset - The index of the first byte to write.
+ * @param words - The words to serialize.
+ * @param byteLength - How many leading bytes to write. Defaults to all of
+ *   `words`. Truncation is byte-granular, not word-granular — e.g. BLAKE2s
+ *   accepts any output length from 1 to 32 bytes, not just multiples of 4 — so
+ *   a truncated final word writes only its leading bytes, never spilling past
+ *   `offset + byteLength` into whatever follows in `target`.
+ */
+export function setUint32ArrayLe(target, offset, words, byteLength = words.length * 4) {
+    const fullWords = byteLength >> 2;
+    for (let word = 0; word < fullWords; word++) {
+        setUint32Le(target, offset + word * 4, words[word]);
+    }
+    const remainder = byteLength - fullWords * 4;
+    if (remainder > 0) {
+        const tail = new Uint8Array(4);
+        setUint32Le(tail, 0, words[fullWords]);
+        target.set(tail.subarray(0, remainder), offset + fullWords * 4);
+    }
+}
+//# sourceMappingURL=set-uint32-array-le.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"set-uint32-array-le.js","sourceRoot":"","sources":["../../../src/buffer/codec/set-uint32-array-le.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEjD;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,gBAAgB,CAC/B,MAAkB,EAClB,MAAc,EACd,KAAkB,EAClB,UAAU,GAAW,KAAK,CAAC,MAAM,GAAG,CAAC;IAErC,MAAM,SAAS,GAAG,UAAU,IAAI,CAAC,CAAC;IAElC,KAAK,IAAI,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,SAAS,EAAE,IAAI,EAAE,EAAE,CAAC;QAC7C,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,CAAC,EAAE,KAAK,CAAC,IAAI,CAAE,CAAC,CAAC;IACtD,CAAC;IAED,MAAM,SAAS,GAAG,UAAU,GAAG,SAAS,GAAG,CAAC,CAAC;IAE7C,IAAI,SAAS,GAAG,CAAC,EAAE,CAAC;QACnB,MAAM,IAAI,GAAG,IAAI,UAAU,CAAC,CAAC,CAAC,CAAC;QAC/B,WAAW,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,CAAC,SAAS,CAAE,CAAC,CAAC;QACxC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,CAAC,CAAC,CAAC;IACjE,CAAC;AACF,CAAC"}

package/dist/buffer/codec/set-uint32-be.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Writes `value` into `target` at `offset` as a big-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 declare function setUint32Be(target: Uint8Array, offset: number, value: number): void;
+//# sourceMappingURL=set-uint32-be.d.ts.map

package/dist/buffer/codec/set-uint32-be.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-uint32-be.d.ts","sourceRoot":"","sources":["../../../src/buffer/codec/set-uint32-be.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAC1B,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GACX,IAAI,CAKN"}

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

@@ -0,0 +1,18 @@
+/**
+ * Writes `value` into `target` at `offset` as a big-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 setUint32Be(target, offset, value) {
+    target[offset] = (value >>> 24) & 0xff;
+    target[offset + 1] = (value >>> 16) & 0xff;
+    target[offset + 2] = (value >>> 8) & 0xff;
+    target[offset + 3] = value & 0xff;
+}
+//# sourceMappingURL=set-uint32-be.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"set-uint32-be.js","sourceRoot":"","sources":["../../../src/buffer/codec/set-uint32-be.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,UAAU,WAAW,CAC1B,MAAkB,EAClB,MAAc,EACd,KAAa;IAEb,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;IACvC,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,CAAC,CAAC,GAAG,IAAI,CAAC;IAC1C,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,KAAK,GAAG,IAAI,CAAC;AACnC,CAAC"}

package/dist/buffer/codec/set-uint32-le.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 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 declare function setUint32Le(target: Uint8Array, offset: number, value: number): void;
+//# sourceMappingURL=set-uint32-le.d.ts.map

package/dist/buffer/codec/set-uint32-le.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-uint32-le.d.ts","sourceRoot":"","sources":["../../../src/buffer/codec/set-uint32-le.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAC1B,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GACX,IAAI,CAKN"}