@bare-ts/lib 0.1.0 → 0.3.0

package/dist/codec/primitive.js

@@ -0,0 +1,345 @@
+// src/codec/primitive.ts
+import { assert } from "../util/assert.js";
+import { BareError } from "../core/index.js";
+import {
+  INT_SAFE_MAX_BYTE_COUNT,
+  NON_CANONICAL_REPRESENTATION,
+  TOO_LARGE_NUMBER,
+  UINT_MAX_BYTE_COUNT,
+  UINT_SAFE_MAX_BYTE_COUNT
+} from "../util/constants.js";
+import {
+  isI16,
+  isI32,
+  isI64,
+  isI8,
+  isSafeU64,
+  isU16,
+  isU32,
+  isU64,
+  isU8
+} from "../util/validator.js";
+function readBool(bc) {
+  const val = readU8(bc);
+  if (val > 1) {
+    bc.offset--;
+    throw new BareError(bc.offset, "a bool must be equal to 0 or 1");
+  }
+  return val !== 0;
+}
+function writeBool(bc, x) {
+  writeU8(bc, x ? 1 : 0);
+}
+function readF32(bc) {
+  bc.check(4);
+  const result = bc.view.getFloat32(bc.offset, true);
+  bc.offset += 4;
+  return result;
+}
+function writeF32(bc, x) {
+  bc.reserve(4);
+  bc.view.setFloat32(bc.offset, x, true);
+  assert(Number.isNaN(x) || Math.abs(bc.view.getFloat32(bc.offset, true) - x) <= Number.EPSILON, TOO_LARGE_NUMBER);
+  bc.offset += 4;
+}
+function readF64(bc) {
+  bc.check(8);
+  const result = bc.view.getFloat64(bc.offset, true);
+  bc.offset += 8;
+  return result;
+}
+function writeF64(bc, x) {
+  bc.reserve(8);
+  bc.view.setFloat64(bc.offset, x, true);
+  bc.offset += 8;
+}
+function readI8(bc) {
+  bc.check(1);
+  return bc.view.getInt8(bc.offset++);
+}
+function writeI8(bc, x) {
+  assert(isI8(x), TOO_LARGE_NUMBER);
+  bc.reserve(1);
+  bc.view.setInt8(bc.offset++, x);
+}
+function readI16(bc) {
+  bc.check(2);
+  const result = bc.view.getInt16(bc.offset, true);
+  bc.offset += 2;
+  return result;
+}
+function writeI16(bc, x) {
+  assert(isI16(x), TOO_LARGE_NUMBER);
+  bc.reserve(2);
+  bc.view.setInt16(bc.offset, x, true);
+  bc.offset += 2;
+}
+function readI32(bc) {
+  bc.check(4);
+  const result = bc.view.getInt32(bc.offset, true);
+  bc.offset += 4;
+  return result;
+}
+function writeI32(bc, x) {
+  assert(isI32(x), TOO_LARGE_NUMBER);
+  bc.reserve(4);
+  bc.view.setInt32(bc.offset, x, true);
+  bc.offset += 4;
+}
+function readI64(bc) {
+  bc.check(8);
+  const result = bc.view.getBigInt64(bc.offset, true);
+  bc.offset += 8;
+  return result;
+}
+function writeI64(bc, x) {
+  assert(isI64(x), TOO_LARGE_NUMBER);
+  bc.reserve(8);
+  bc.view.setBigInt64(bc.offset, x, true);
+  bc.offset += 8;
+}
+function readI64Safe(bc) {
+  const result = readU32(bc) + readI32(bc) * 4294967296;
+  if (!Number.isSafeInteger(result)) {
+    bc.offset -= 8;
+    throw new BareError(bc.offset, TOO_LARGE_NUMBER);
+  }
+  return result;
+}
+function writeI64Safe(bc, x) {
+  assert(Number.isSafeInteger(x), TOO_LARGE_NUMBER);
+  const lowest32 = x >>> 0;
+  writeU32(bc, lowest32);
+  let highest32 = x / 4294967296 | 0;
+  if (x < 0) {
+    highest32 = ~Math.abs(highest32) >>> 0;
+    if (lowest32 === 0) {
+      highest32++;
+    }
+  }
+  writeU32(bc, highest32);
+}
+function readInt(bc) {
+  const zigZag = readUint(bc);
+  return zigZag >> BigInt(1) ^ -(zigZag & BigInt(1));
+}
+function writeInt(bc, x) {
+  assert(isI64(x), TOO_LARGE_NUMBER);
+  const zigZag = x >> BigInt(63) ^ x << BigInt(1);
+  writeUint(bc, zigZag);
+}
+function readIntSafe(bc) {
+  const firstByte = readU8(bc);
+  let result = (firstByte & 127) >> 1;
+  if (firstByte >= 128) {
+    let shiftMul = 64;
+    let byteCount = 1;
+    let byte;
+    do {
+      byte = readU8(bc);
+      result += (byte & 127) * shiftMul;
+      shiftMul *= 128;
+      byteCount++;
+    } while (byte >= 128 && byteCount < INT_SAFE_MAX_BYTE_COUNT);
+    if (byte === 0) {
+      bc.offset -= byteCount - 1;
+      throw new BareError(bc.offset, "must be canonical");
+    }
+    if (byteCount === INT_SAFE_MAX_BYTE_COUNT && (byte > 31 || firstByte === 255)) {
+      bc.offset -= byteCount - 1;
+      throw new BareError(bc.offset, TOO_LARGE_NUMBER);
+    }
+  }
+  const isNeg = (firstByte & 1) === 1;
+  if (isNeg) {
+    result = -result - 1;
+  }
+  return result;
+}
+function writeIntSafe(bc, x) {
+  assert(Number.isSafeInteger(x), TOO_LARGE_NUMBER);
+  const sign = x < 0 ? 1 : 0;
+  if (x < 0) {
+    x = -(x + 1);
+  }
+  const firstByte = (x & 63) << 1 | sign;
+  x = Math.floor(x / 64);
+  if (x > 0) {
+    writeU8(bc, 128 | firstByte);
+    writeUintSafe(bc, x);
+  } else {
+    writeU8(bc, firstByte);
+  }
+}
+function readU8(bc) {
+  bc.check(1);
+  return bc.bytes[bc.offset++];
+}
+function writeU8(bc, x) {
+  assert(isU8(x), TOO_LARGE_NUMBER);
+  bc.reserve(1);
+  bc.bytes[bc.offset++] = x;
+}
+function readU16(bc) {
+  bc.check(2);
+  const result = bc.view.getUint16(bc.offset, true);
+  bc.offset += 2;
+  return result;
+}
+function writeU16(bc, x) {
+  assert(isU16(x), TOO_LARGE_NUMBER);
+  bc.reserve(2);
+  bc.view.setUint16(bc.offset, x, true);
+  bc.offset += 2;
+}
+function readU32(bc) {
+  bc.check(4);
+  const result = bc.view.getUint32(bc.offset, true);
+  bc.offset += 4;
+  return result;
+}
+function writeU32(bc, x) {
+  assert(isU32(x), TOO_LARGE_NUMBER);
+  bc.reserve(4);
+  bc.view.setUint32(bc.offset, x, true);
+  bc.offset += 4;
+}
+function readU64(bc) {
+  bc.check(8);
+  const result = bc.view.getBigUint64(bc.offset, true);
+  bc.offset += 8;
+  return result;
+}
+function writeU64(bc, x) {
+  assert(isU64(x), TOO_LARGE_NUMBER);
+  bc.reserve(8);
+  bc.view.setBigUint64(bc.offset, x, true);
+  bc.offset += 8;
+}
+function readU64Safe(bc) {
+  const result = readU32(bc) + readU32(bc) * 4294967296;
+  if (!isSafeU64(result)) {
+    bc.offset -= 8;
+    throw new BareError(bc.offset, TOO_LARGE_NUMBER);
+  }
+  return result;
+}
+function writeU64Safe(bc, x) {
+  assert(isSafeU64(x), TOO_LARGE_NUMBER);
+  writeU32(bc, x >>> 0);
+  writeU32(bc, x / 4294967296 >>> 0);
+}
+function readUint(bc) {
+  let low = readU8(bc);
+  if (low >= 128) {
+    low &= 127;
+    let shiftMul = 128;
+    let byteCount = 1;
+    let byte;
+    do {
+      byte = readU8(bc);
+      low += (byte & 127) * shiftMul;
+      shiftMul *= 128;
+      byteCount++;
+    } while (byte >= 128 && byteCount < 7);
+    let height = 0;
+    shiftMul = 1;
+    while (byte >= 128 && byteCount < UINT_MAX_BYTE_COUNT) {
+      byte = readU8(bc);
+      height += (byte & 127) * shiftMul;
+      shiftMul *= 128;
+      byteCount++;
+    }
+    if (byte === 0 || byteCount === UINT_MAX_BYTE_COUNT && byte > 1) {
+      bc.offset -= byteCount;
+      throw new BareError(bc.offset, NON_CANONICAL_REPRESENTATION);
+    }
+    return BigInt(low) + (BigInt(height) << BigInt(7 * 7));
+  }
+  return BigInt(low);
+}
+function writeUint(bc, x) {
+  assert(isU64(x), TOO_LARGE_NUMBER);
+  let tmp = Number(BigInt.asUintN(7 * 7, x));
+  let rest = Number(x >> BigInt(7 * 7));
+  let byteCount = 0;
+  while (tmp >= 128 || rest !== 0) {
+    writeU8(bc, 128 | tmp & 127);
+    tmp = Math.floor(tmp / 128);
+    byteCount++;
+    if (byteCount === 7) {
+      tmp = rest;
+      rest = 0;
+    }
+  }
+  writeU8(bc, tmp);
+}
+function readUintSafe(bc) {
+  let result = readU8(bc);
+  if (result >= 128) {
+    result &= 127;
+    let shiftMul = 128;
+    let byteCount = 1;
+    let byte;
+    do {
+      byte = readU8(bc);
+      result += (byte & 127) * shiftMul;
+      shiftMul *= 128;
+      byteCount++;
+    } while (byte >= 128 && byteCount < UINT_SAFE_MAX_BYTE_COUNT);
+    if (byte === 0) {
+      bc.offset -= byteCount - 1;
+      throw new BareError(bc.offset - byteCount + 1, NON_CANONICAL_REPRESENTATION);
+    }
+    if (byteCount === UINT_SAFE_MAX_BYTE_COUNT && byte > 15) {
+      bc.offset -= byteCount - 1;
+      throw new BareError(bc.offset, TOO_LARGE_NUMBER);
+    }
+  }
+  return result;
+}
+function writeUintSafe(bc, x) {
+  assert(isSafeU64(x), TOO_LARGE_NUMBER);
+  while (x >= 128) {
+    writeU8(bc, 128 | x & 127);
+    x = Math.floor(x / 128);
+  }
+  writeU8(bc, x);
+}
+export {
+  readBool,
+  readF32,
+  readF64,
+  readI16,
+  readI32,
+  readI64,
+  readI64Safe,
+  readI8,
+  readInt,
+  readIntSafe,
+  readU16,
+  readU32,
+  readU64,
+  readU64Safe,
+  readU8,
+  readUint,
+  readUintSafe,
+  writeBool,
+  writeF32,
+  writeF64,
+  writeI16,
+  writeI32,
+  writeI64,
+  writeI64Safe,
+  writeI8,
+  writeInt,
+  writeIntSafe,
+  writeU16,
+  writeU32,
+  writeU64,
+  writeU64Safe,
+  writeU8,
+  writeUint,
+  writeUintSafe
+};
+//# sourceMappingURL=primitive.js.map

package/dist/codec/string.d.ts

@@ -1,3 +1,5 @@
 import type { ByteCursor } from "../core/index.js";
-export declare function decodeString(bc: ByteCursor): string;
-export declare function encodeString(bc: ByteCursor, x: string): void;
+export declare function readString(bc: ByteCursor): string;
+export declare function writeString(bc: ByteCursor, x: string): void;
+export declare function readFixedString(bc: ByteCursor, byteLen: number): string;
+export declare function writeFixedString(bc: ByteCursor, x: string): void;

package/dist/codec/string.js

@@ -0,0 +1,126 @@
+// src/codec/string.ts
+import { BareError } from "../core/bare-error.js";
+import { INVALID_UTF8_STRING } from "../util/constants.js";
+import { readUintSafe, writeUintSafe } from "./primitive.js";
+import { writeU8FixedArray } from "./u8-array.js";
+function readString(bc) {
+  return readFixedString(bc, readUintSafe(bc));
+}
+function writeString(bc, x) {
+  if (x.length < bc.config.textEncoderThreshold) {
+    const byteLen = utf8ByteLength(x);
+    writeUintSafe(bc, byteLen);
+    bc.reserve(byteLen);
+    writeUtf8Js(bc, x);
+  } else {
+    const strBytes = UTF8_ENCODER.encode(x);
+    writeUintSafe(bc, strBytes.length);
+    writeU8FixedArray(bc, strBytes);
+  }
+}
+function readFixedString(bc, byteLen) {
+  if (byteLen < bc.config.textDecoderThreshold) {
+    return readUtf8Js(bc, byteLen);
+  }
+  try {
+    return UTF8_DECODER.decode(bc.read(byteLen));
+  } catch (cause) {
+    throw new BareError(bc.offset, INVALID_UTF8_STRING);
+  }
+}
+function writeFixedString(bc, x) {
+  if (x.length < bc.config.textEncoderThreshold) {
+    const byteLen = utf8ByteLength(x);
+    bc.reserve(byteLen);
+    writeUtf8Js(bc, x);
+  } else {
+    writeU8FixedArray(bc, UTF8_ENCODER.encode(x));
+  }
+}
+function readUtf8Js(bc, byteLen) {
+  bc.check(byteLen);
+  let result = "";
+  const bytes = bc.bytes;
+  let offset = bc.offset;
+  const upperOffset = offset + byteLen;
+  while (offset < upperOffset) {
+    let codePoint = bytes[offset++];
+    if (codePoint > 127) {
+      let malformed = true;
+      const byte1 = codePoint;
+      if (offset < upperOffset && codePoint < 224) {
+        const byte2 = bytes[offset++];
+        codePoint = (byte1 & 31) << 6 | byte2 & 63;
+        malformed = codePoint >> 7 === 0 || byte1 >> 5 !== 6 || byte2 >> 6 !== 2;
+      } else if (offset + 1 < upperOffset && codePoint < 240) {
+        const byte2 = bytes[offset++];
+        const byte3 = bytes[offset++];
+        codePoint = (byte1 & 15) << 12 | (byte2 & 63) << 6 | byte3 & 63;
+        malformed = codePoint >> 11 === 0 || codePoint >> 11 === 27 || byte1 >> 4 !== 14 || byte2 >> 6 !== 2 || byte3 >> 6 !== 2;
+      } else if (offset + 2 < upperOffset) {
+        const byte2 = bytes[offset++];
+        const byte3 = bytes[offset++];
+        const byte4 = bytes[offset++];
+        codePoint = (byte1 & 7) << 18 | (byte2 & 63) << 12 | (byte3 & 63) << 6 | byte4 & 63;
+        malformed = codePoint >> 16 === 0 || codePoint > 1114111 || byte1 >> 3 !== 30 || byte2 >> 6 !== 2 || byte3 >> 6 !== 2 || byte4 >> 6 !== 2;
+      }
+      if (malformed) {
+        throw new BareError(bc.offset, INVALID_UTF8_STRING);
+      }
+    }
+    result += String.fromCodePoint(codePoint);
+  }
+  bc.offset = offset;
+  return result;
+}
+function writeUtf8Js(bc, s) {
+  const bytes = bc.bytes;
+  let offset = bc.offset;
+  let i = 0;
+  while (i < s.length) {
+    const codePoint = s.codePointAt(i++);
+    if (codePoint < 128) {
+      bytes[offset++] = codePoint;
+    } else {
+      if (codePoint < 2048) {
+        bytes[offset++] = 192 | codePoint >> 6;
+      } else {
+        if (codePoint < 65536) {
+          bytes[offset++] = 224 | codePoint >> 12;
+        } else {
+          bytes[offset++] = 240 | codePoint >> 18;
+          bytes[offset++] = 128 | codePoint >> 12 & 63;
+          i++;
+        }
+        bytes[offset++] = 128 | codePoint >> 6 & 63;
+      }
+      bytes[offset++] = 128 | codePoint & 63;
+    }
+  }
+  bc.offset = offset;
+}
+function utf8ByteLength(s) {
+  let result = s.length;
+  for (let i = 0; i < s.length; i++) {
+    const codePoint = s.codePointAt(i);
+    if (codePoint > 127) {
+      result++;
+      if (codePoint > 2047) {
+        result++;
+        if (codePoint > 65535) {
+          i++;
+        }
+      }
+    }
+  }
+  return result;
+}
+var UTF8_DECODER = /* @__PURE__ */ new TextDecoder("utf-8", { fatal: true });
+var UTF8_ENCODER = /* @__PURE__ */ new TextEncoder();
+export {
+  readFixedString,
+  readString,
+  writeFixedString,
+  writeString
+};
+//# sourceMappingURL=string.js.map

package/dist/codec/u16-array.d.ts

@@ -1,8 +1,8 @@
 import type { ByteCursor } from "../core/index.js";
-export declare const decodeU16FixedArray: typeof decodeU16FixedArrayLE;
-export declare function decodeU16Array(bc: ByteCursor): Uint16Array;
-declare function decodeU16FixedArrayLE(bc: ByteCursor, len: number): Uint16Array;
-export declare const encodeU16FixedArray: typeof encodeU16FixedArrayLE;
-export declare function encodeU16Array(bc: ByteCursor, x: Uint16Array): void;
-declare function encodeU16FixedArrayLE(bc: ByteCursor, x: Uint16Array, len: number): void;
+export declare const readU16FixedArray: typeof readU16FixedArrayLE;
+export declare function readU16Array(bc: ByteCursor): Uint16Array;
+declare function readU16FixedArrayLE(bc: ByteCursor, len: number): Uint16Array;
+export declare const writeU16FixedArray: typeof writeU16FixedArrayLE;
+export declare function writeU16Array(bc: ByteCursor, x: Uint16Array): void;
+declare function writeU16FixedArrayLE(bc: ByteCursor, x: Uint16Array): void;
 export {};

package/dist/codec/u16-array.js

@@ -0,0 +1,43 @@
+// src/codec/u16-array.ts
+import { U16_BYTE_COUNT } from "../util/constants.js";
+import { IS_LITTLE_ENDIAN_PLATFORM } from "../util/util.js";
+import { readFixedData } from "./data.js";
+import { readU16, readUintSafe, writeU16, writeUintSafe } from "./primitive.js";
+import { writeU8FixedArray } from "./u8-array.js";
+var readU16FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readU16FixedArrayLE : readU16FixedArrayBE;
+function readU16Array(bc) {
+  return readU16FixedArray(bc, readUintSafe(bc));
+}
+function readU16FixedArrayLE(bc, len) {
+  const byteCount = len * U16_BYTE_COUNT;
+  return new Uint16Array(readFixedData(bc, byteCount));
+}
+function readU16FixedArrayBE(bc, len) {
+  bc.check(len * U16_BYTE_COUNT);
+  const result = new Uint16Array(len);
+  for (let i = 0; i < len; i++)
+    result[i] = readU16(bc);
+  return result;
+}
+var writeU16FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeU16FixedArrayLE : writeU16FixedArrayBE;
+function writeU16Array(bc, x) {
+  writeUintSafe(bc, x.length);
+  if (x.length !== 0) {
+    writeU16FixedArray(bc, x);
+  }
+}
+function writeU16FixedArrayLE(bc, x) {
+  writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
+}
+function writeU16FixedArrayBE(bc, x) {
+  bc.reserve(x.length * U16_BYTE_COUNT);
+  for (let i = 0; i < x.length; i++)
+    writeU16(bc, x[i]);
+}
+export {
+  readU16Array,
+  readU16FixedArray,
+  writeU16Array,
+  writeU16FixedArray
+};
+//# sourceMappingURL=u16-array.js.map

package/dist/codec/u32-array.d.ts

@@ -1,8 +1,8 @@
 import type { ByteCursor } from "../core/index.js";
-export declare const decodeU32FixedArray: typeof decodeU32FixedArrayLE;
-export declare function decodeU32Array(bc: ByteCursor): Uint32Array;
-declare function decodeU32FixedArrayLE(bc: ByteCursor, len: number): Uint32Array;
-export declare const encodeU32FixedArray: typeof encodeU32FixedArrayLE;
-export declare function encodeU32Array(bc: ByteCursor, x: Uint32Array): void;
-declare function encodeU32FixedArrayLE(bc: ByteCursor, x: Uint32Array, len: number): void;
+export declare const readU32FixedArray: typeof readU32FixedArrayLE;
+export declare function readU32Array(bc: ByteCursor): Uint32Array;
+declare function readU32FixedArrayLE(bc: ByteCursor, len: number): Uint32Array;
+export declare const writeU32FixedArray: typeof writeU32FixedArrayLE;
+export declare function writeU32Array(bc: ByteCursor, x: Uint32Array): void;
+declare function writeU32FixedArrayLE(bc: ByteCursor, x: Uint32Array): void;
 export {};

package/dist/codec/u32-array.js

@@ -0,0 +1,43 @@
+// src/codec/u32-array.ts
+import { U32_BYTE_COUNT } from "../util/constants.js";
+import { IS_LITTLE_ENDIAN_PLATFORM } from "../util/util.js";
+import { readFixedData } from "./data.js";
+import { readU32, readUintSafe, writeU32, writeUintSafe } from "./primitive.js";
+import { writeU8FixedArray } from "./u8-array.js";
+var readU32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readU32FixedArrayLE : readU32FixedArrayBE;
+function readU32Array(bc) {
+  return readU32FixedArray(bc, readUintSafe(bc));
+}
+function readU32FixedArrayLE(bc, len) {
+  const byteCount = len * U32_BYTE_COUNT;
+  return new Uint32Array(readFixedData(bc, byteCount));
+}
+function readU32FixedArrayBE(bc, len) {
+  bc.check(len * U32_BYTE_COUNT);
+  const result = new Uint32Array(len);
+  for (let i = 0; i < len; i++)
+    result[i] = readU32(bc);
+  return result;
+}
+var writeU32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeU32FixedArrayLE : writeU32FixedArrayBE;
+function writeU32Array(bc, x) {
+  writeUintSafe(bc, x.length);
+  if (x.length !== 0) {
+    writeU32FixedArray(bc, x);
+  }
+}
+function writeU32FixedArrayLE(bc, x) {
+  writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
+}
+function writeU32FixedArrayBE(bc, x) {
+  bc.reserve(x.length * U32_BYTE_COUNT);
+  for (let i = 0; i < x.length; i++)
+    writeU32(bc, x[i]);
+}
+export {
+  readU32Array,
+  readU32FixedArray,
+  writeU32Array,
+  writeU32FixedArray
+};
+//# sourceMappingURL=u32-array.js.map

package/dist/codec/u64-array.d.ts

@@ -1,8 +1,8 @@
 import type { ByteCursor } from "../core/index.js";
-export declare const decodeU64FixedArray: typeof decodeU64FixedArrayLE;
-export declare function decodeU64Array(bc: ByteCursor): BigUint64Array;
-declare function decodeU64FixedArrayLE(bc: ByteCursor, len: number): BigUint64Array;
-export declare const encodeU64FixedArray: typeof encodeU64FixedArrayLE;
-export declare function encodeU64Array(bc: ByteCursor, x: BigUint64Array): void;
-declare function encodeU64FixedArrayLE(bc: ByteCursor, x: BigUint64Array, len: number): void;
+export declare const readU64FixedArray: typeof readU64FixedArrayLE;
+export declare function readU64Array(bc: ByteCursor): BigUint64Array;
+declare function readU64FixedArrayLE(bc: ByteCursor, len: number): BigUint64Array;
+export declare const writeU64FixedArray: typeof writeU64FixedArrayLE;
+export declare function writeU64Array(bc: ByteCursor, x: BigUint64Array): void;
+declare function writeU64FixedArrayLE(bc: ByteCursor, x: BigUint64Array): void;
 export {};

package/dist/codec/u64-array.js

@@ -0,0 +1,43 @@
+// src/codec/u64-array.ts
+import { U64_BYTE_COUNT } from "../util/constants.js";
+import { IS_LITTLE_ENDIAN_PLATFORM } from "../util/util.js";
+import { readFixedData } from "./data.js";
+import { readU64, readUintSafe, writeU64, writeUintSafe } from "./primitive.js";
+import { writeU8FixedArray } from "./u8-array.js";
+var readU64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readU64FixedArrayLE : readU64FixedArrayBE;
+function readU64Array(bc) {
+  return readU64FixedArray(bc, readUintSafe(bc));
+}
+function readU64FixedArrayLE(bc, len) {
+  const byteCount = len * U64_BYTE_COUNT;
+  return new BigUint64Array(readFixedData(bc, byteCount));
+}
+function readU64FixedArrayBE(bc, len) {
+  bc.check(len * U64_BYTE_COUNT);
+  const result = new BigUint64Array(len);
+  for (let i = 0; i < len; i++)
+    result[i] = readU64(bc);
+  return result;
+}
+var writeU64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeU64FixedArrayLE : writeU64FixedArrayBE;
+function writeU64Array(bc, x) {
+  writeUintSafe(bc, x.length);
+  if (x.length !== 0) {
+    writeU64FixedArray(bc, x);
+  }
+}
+function writeU64FixedArrayLE(bc, x) {
+  writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
+}
+function writeU64FixedArrayBE(bc, x) {
+  bc.reserve(x.length * U64_BYTE_COUNT);
+  for (let i = 0; i < x.length; i++)
+    writeU64(bc, x[i]);
+}
+export {
+  readU64Array,
+  readU64FixedArray,
+  writeU64Array,
+  writeU64FixedArray
+};
+//# sourceMappingURL=u64-array.js.map

package/dist/codec/u8-array.d.ts

@@ -1,5 +1,5 @@
 import type { ByteCursor } from "../core/index.js";
-export declare function decodeU8Array(bc: ByteCursor): Uint8Array;
-export declare function encodeU8Array(bc: ByteCursor, x: Uint8Array): void;
-export declare function decodeU8FixedArray(bc: ByteCursor, len: number): Uint8Array;
-export declare function encodeU8FixedArray(bc: ByteCursor, x: Uint8Array, len: number): void;
+export declare function readU8Array(bc: ByteCursor): Uint8Array;
+export declare function writeU8Array(bc: ByteCursor, x: Uint8Array): void;
+export declare function readU8FixedArray(bc: ByteCursor, len: number): Uint8Array;
+export declare function writeU8FixedArray(bc: ByteCursor, x: Uint8Array): void;

package/dist/codec/u8-array.js

@@ -0,0 +1,27 @@
+// src/codec/u8-array.ts
+import { readUintSafe, writeUintSafe } from "./primitive.js";
+function readU8Array(bc) {
+  return readU8FixedArray(bc, readUintSafe(bc));
+}
+function writeU8Array(bc, x) {
+  writeUintSafe(bc, x.length);
+  writeU8FixedArray(bc, x);
+}
+function readU8FixedArray(bc, len) {
+  return bc.read(len).slice();
+}
+function writeU8FixedArray(bc, x) {
+  const len = x.length;
+  if (len !== 0) {
+    bc.reserve(len);
+    bc.bytes.set(x, bc.offset);
+    bc.offset += len;
+  }
+}
+export {
+  readU8Array,
+  readU8FixedArray,
+  writeU8Array,
+  writeU8FixedArray
+};
+//# sourceMappingURL=u8-array.js.map