@bare-ts/lib 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1112 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, copyDefault, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toESM = (module2, isNodeMode) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", !isNodeMode && module2 && module2.__esModule ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+var __toCommonJS = /* @__PURE__ */ ((cache) => {
+  return (module2, temp) => {
+    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
+  };
+})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  BareError: () => BareError,
+  ByteCursor: () => ByteCursor,
+  Config: () => Config,
+  decodeBool: () => decodeBool,
+  decodeData: () => decodeData,
+  decodeF32: () => decodeF32,
+  decodeF32Array: () => decodeF32Array,
+  decodeF32FixedArray: () => decodeF32FixedArray,
+  decodeF64: () => decodeF64,
+  decodeF64Array: () => decodeF64Array,
+  decodeF64FixedArray: () => decodeF64FixedArray,
+  decodeFixedData: () => decodeFixedData,
+  decodeI16: () => decodeI16,
+  decodeI16Array: () => decodeI16Array,
+  decodeI16FixedArray: () => decodeI16FixedArray,
+  decodeI32: () => decodeI32,
+  decodeI32Array: () => decodeI32Array,
+  decodeI32FixedArray: () => decodeI32FixedArray,
+  decodeI64: () => decodeI64,
+  decodeI64Array: () => decodeI64Array,
+  decodeI64FixedArray: () => decodeI64FixedArray,
+  decodeI64Safe: () => decodeI64Safe,
+  decodeI8: () => decodeI8,
+  decodeI8Array: () => decodeI8Array,
+  decodeI8FixedArray: () => decodeI8FixedArray,
+  decodeInt: () => decodeInt,
+  decodeIntSafe: () => decodeIntSafe,
+  decodeString: () => decodeString,
+  decodeU16: () => decodeU16,
+  decodeU16Array: () => decodeU16Array,
+  decodeU16FixedArray: () => decodeU16FixedArray,
+  decodeU32: () => decodeU32,
+  decodeU32Array: () => decodeU32Array,
+  decodeU32FixedArray: () => decodeU32FixedArray,
+  decodeU64: () => decodeU64,
+  decodeU64Array: () => decodeU64Array,
+  decodeU64FixedArray: () => decodeU64FixedArray,
+  decodeU64Safe: () => decodeU64Safe,
+  decodeU8: () => decodeU8,
+  decodeU8Array: () => decodeU8Array,
+  decodeU8ClampedArray: () => decodeU8ClampedArray,
+  decodeU8ClampedFixedArray: () => decodeU8ClampedFixedArray,
+  decodeU8FixedArray: () => decodeU8FixedArray,
+  decodeUint: () => decodeUint,
+  decodeUintSafe: () => decodeUintSafe,
+  decodeVoid: () => decodeVoid,
+  encodeBool: () => encodeBool,
+  encodeData: () => encodeData,
+  encodeF32: () => encodeF32,
+  encodeF32Array: () => encodeF32Array,
+  encodeF32FixedArray: () => encodeF32FixedArray,
+  encodeF64: () => encodeF64,
+  encodeF64Array: () => encodeF64Array,
+  encodeF64FixedArray: () => encodeF64FixedArray,
+  encodeFixedData: () => encodeFixedData,
+  encodeI16: () => encodeI16,
+  encodeI16Array: () => encodeI16Array,
+  encodeI16FixedArray: () => encodeI16FixedArray,
+  encodeI32: () => encodeI32,
+  encodeI32Array: () => encodeI32Array,
+  encodeI32FixedArray: () => encodeI32FixedArray,
+  encodeI64: () => encodeI64,
+  encodeI64Array: () => encodeI64Array,
+  encodeI64FixedArray: () => encodeI64FixedArray,
+  encodeI64Safe: () => encodeI64Safe,
+  encodeI8: () => encodeI8,
+  encodeI8Array: () => encodeI8Array,
+  encodeI8FixedArray: () => encodeI8FixedArray,
+  encodeInt: () => encodeInt,
+  encodeIntSafe: () => encodeIntSafe,
+  encodeString: () => encodeString,
+  encodeU16: () => encodeU16,
+  encodeU16Array: () => encodeU16Array,
+  encodeU16FixedArray: () => encodeU16FixedArray,
+  encodeU32: () => encodeU32,
+  encodeU32Array: () => encodeU32Array,
+  encodeU32FixedArray: () => encodeU32FixedArray,
+  encodeU64: () => encodeU64,
+  encodeU64Array: () => encodeU64Array,
+  encodeU64FixedArray: () => encodeU64FixedArray,
+  encodeU64Safe: () => encodeU64Safe,
+  encodeU8: () => encodeU8,
+  encodeU8Array: () => encodeU8Array,
+  encodeU8ClampedArray: () => encodeU8ClampedArray,
+  encodeU8ClampedFixedArray: () => encodeU8ClampedFixedArray,
+  encodeU8FixedArray: () => encodeU8FixedArray,
+  encodeUint: () => encodeUint,
+  encodeUintSafe: () => encodeUintSafe,
+  encodeVoid: () => encodeVoid
+});
+
+// src/codec/u8-array.ts
+var import_assert4 = __toESM(require("assert"), 1);
+
+// src/codec/primitive.ts
+var import_assert3 = __toESM(require("assert"), 1);
+
+// src/core/bare-error.ts
+var BareError = class extends Error {
+  constructor(offset, issue, opts) {
+    super(`(byte:${offset}) ${issue}`);
+    this.name = "BareError";
+    this.issue = issue;
+    this.offset = offset;
+    this.cause = opts == null ? void 0 : opts.cause;
+  }
+};
+
+// src/core/config.ts
+var import_assert = __toESM(require("assert"), 1);
+
+// src/util/validator.ts
+function isI8(val) {
+  return val === val << 24 >> 24;
+}
+function isI16(val) {
+  return val === val << 16 >> 16;
+}
+function isI32(val) {
+  return val === (val | 0);
+}
+function isI64(val) {
+  return val === BigInt.asIntN(64, val);
+}
+function isSafeU64(val) {
+  return Number.isSafeInteger(val) && val >= 0;
+}
+function isU8(val) {
+  return val === (val & 255);
+}
+function isU16(val) {
+  return val === (val & 65535);
+}
+function isU32(val) {
+  return val === val >>> 0;
+}
+function isU64(val) {
+  return val === BigInt.asUintN(64, val);
+}
+
+// src/core/config.ts
+var TOO_LARGE_NUMBER = "too large number";
+var initialBufferLength = 1024;
+var maxBufferLength = 1024 * 1024 * 32;
+var textDecoderThreshold = 256;
+var textEncoderThreshold = 256;
+function Config(part) {
+  const config = Object.assign({
+    initialBufferLength,
+    maxBufferLength,
+    textDecoderThreshold,
+    textEncoderThreshold
+  }, part);
+  (0, import_assert.default)(isU32(config.initialBufferLength), TOO_LARGE_NUMBER);
+  (0, import_assert.default)(isU32(config.maxBufferLength), TOO_LARGE_NUMBER);
+  (0, import_assert.default)(isU32(config.textDecoderThreshold), TOO_LARGE_NUMBER);
+  (0, import_assert.default)(isU32(config.textEncoderThreshold), TOO_LARGE_NUMBER);
+  (0, import_assert.default)(config.initialBufferLength <= config.maxBufferLength, "initialBufferLength must be lower than or equal to maxBufferLength");
+  return config;
+}
+
+// src/core/byte-cursor.ts
+var import_assert2 = __toESM(require("assert"), 1);
+var TOO_LARGE_BUFFER = "too large buffer";
+var ByteCursor = class {
+  constructor(bytes, config) {
+    this.config = config;
+    this.offset = 0;
+    this.view = bytes instanceof Uint8Array ? new DataView(bytes.buffer, bytes.byteOffset, bytes.length) : new DataView(bytes);
+    if (this.view.byteLength > config.maxBufferLength) {
+      throw new BareError(0, TOO_LARGE_BUFFER);
+    }
+  }
+  check(min) {
+    if (this.offset + min > this.view.byteLength) {
+      throw new BareError(this.offset, "missing bytes");
+    }
+  }
+  reserve(min) {
+    const { config, offset, view } = this;
+    if (offset + min > view.byteLength) {
+      const bytes = new Uint8Array(view.buffer);
+      const minExtraLength = min + offset - view.byteLength;
+      (0, import_assert2.default)(bytes.length === view.byteOffset + view.byteLength, "un-growable buffer");
+      (0, import_assert2.default)(bytes.length + minExtraLength <= config.maxBufferLength, TOO_LARGE_BUFFER);
+      const newLen = Math.min(bytes.length + Math.max(minExtraLength, bytes.length), config.maxBufferLength);
+      const newBytes = new Uint8Array(newLen);
+      newBytes.set(bytes);
+      this.view = new DataView(newBytes.buffer, view.byteOffset);
+    }
+  }
+  read(len) {
+    this.check(len);
+    const bufferOffset = this.view.byteOffset + this.offset;
+    this.offset += len;
+    return new Uint8Array(this.view.buffer, bufferOffset, len);
+  }
+  write(bytes) {
+    const len = bytes.length;
+    if (len !== 0) {
+      this.reserve(len);
+      const writableArea = new Uint8Array(this.view.buffer, this.offset, len);
+      writableArea.set(bytes);
+      this.offset += len;
+    }
+  }
+};
+
+// src/codec/primitive.ts
+var NAN_NOT_ALLOWED = "NaN is not allowed";
+var NON_CANONICAL_REPRESENTATION = "must be canonical";
+var TOO_LARGE_NUMBER2 = "too large number";
+function decodeBool(bc) {
+  const val = decodeU8(bc);
+  if (val > 1) {
+    bc.offset--;
+    throw new BareError(bc.offset, "a bool must be equal to 0 or 1");
+  }
+  return val !== 0;
+}
+function encodeBool(bc, x) {
+  encodeU8(bc, x ? 1 : 0);
+}
+function decodeF32(bc) {
+  bc.check(4);
+  const result = bc.view.getFloat32(bc.offset, true);
+  if (Number.isNaN(result)) {
+    throw new BareError(bc.offset, NAN_NOT_ALLOWED);
+  }
+  bc.offset += 4;
+  return result;
+}
+function encodeF32(bc, x) {
+  (0, import_assert3.default)(!Number.isNaN(x), NAN_NOT_ALLOWED);
+  bc.reserve(4);
+  bc.view.setFloat32(bc.offset, x, true);
+  (0, import_assert3.default)(Math.abs(bc.view.getFloat32(bc.offset, true) - x) <= Number.EPSILON, TOO_LARGE_NUMBER2);
+  bc.offset += 4;
+}
+function decodeF64(bc) {
+  bc.check(8);
+  const result = bc.view.getFloat64(bc.offset, true);
+  if (Number.isNaN(result)) {
+    throw new BareError(bc.offset, NAN_NOT_ALLOWED);
+  }
+  bc.offset += 8;
+  return result;
+}
+function encodeF64(bc, x) {
+  (0, import_assert3.default)(!Number.isNaN(x), NAN_NOT_ALLOWED);
+  bc.reserve(8);
+  bc.view.setFloat64(bc.offset, x, true);
+  bc.offset += 8;
+}
+function decodeI8(bc) {
+  bc.check(1);
+  return bc.view.getInt8(bc.offset++);
+}
+function encodeI8(bc, x) {
+  (0, import_assert3.default)(isI8(x), TOO_LARGE_NUMBER2);
+  bc.reserve(1);
+  bc.view.setInt8(bc.offset++, x);
+}
+function decodeI16(bc) {
+  bc.check(2);
+  const result = bc.view.getInt16(bc.offset, true);
+  bc.offset += 2;
+  return result;
+}
+function encodeI16(bc, x) {
+  (0, import_assert3.default)(isI16(x), TOO_LARGE_NUMBER2);
+  bc.reserve(2);
+  bc.view.setInt16(bc.offset, x, true);
+  bc.offset += 2;
+}
+function decodeI32(bc) {
+  bc.check(4);
+  const result = bc.view.getInt32(bc.offset, true);
+  bc.offset += 4;
+  return result;
+}
+function encodeI32(bc, x) {
+  (0, import_assert3.default)(isI32(x), TOO_LARGE_NUMBER2);
+  bc.reserve(4);
+  bc.view.setInt32(bc.offset, x, true);
+  bc.offset += 4;
+}
+function decodeI64(bc) {
+  bc.check(8);
+  const result = bc.view.getBigInt64(bc.offset, true);
+  bc.offset += 8;
+  return result;
+}
+function encodeI64(bc, x) {
+  (0, import_assert3.default)(isI64(x), TOO_LARGE_NUMBER2);
+  bc.reserve(8);
+  bc.view.setBigInt64(bc.offset, x, true);
+  bc.offset += 8;
+}
+function decodeI64Safe(bc) {
+  const result = decodeU32(bc) + decodeI32(bc) * 4294967296;
+  if (!Number.isSafeInteger(result)) {
+    bc.offset -= 8;
+    throw new BareError(bc.offset, TOO_LARGE_NUMBER2);
+  }
+  return result;
+}
+function encodeI64Safe(bc, x) {
+  (0, import_assert3.default)(Number.isSafeInteger(x), TOO_LARGE_NUMBER2);
+  const lowest32 = x >>> 0;
+  encodeU32(bc, lowest32);
+  let highest32 = x / 4294967296 | 0;
+  if (x < 0) {
+    highest32 = ~Math.abs(highest32) >>> 0;
+    if (lowest32 === 0) {
+      highest32++;
+    }
+  }
+  encodeU32(bc, highest32);
+}
+function decodeInt(bc) {
+  const zigZag = decodeUint(bc);
+  return zigZag >> BigInt(1) ^ -(zigZag & BigInt(1));
+}
+function encodeInt(bc, x) {
+  (0, import_assert3.default)(isI64(x), TOO_LARGE_NUMBER2);
+  const zigZag = x >> BigInt(63) ^ x << BigInt(1);
+  encodeUint(bc, zigZag);
+}
+var INT_SAFE_MAX_BYTE_COUNT = 8;
+function decodeIntSafe(bc) {
+  const firstByte = decodeU8(bc);
+  let result = (firstByte & 127) >> 1;
+  if (firstByte >= 128) {
+    let shiftMul = 64;
+    let byteCount = 1;
+    let byte;
+    do {
+      byte = decodeU8(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_NUMBER2);
+    }
+  }
+  const isNeg = (firstByte & 1) === 1;
+  if (isNeg) {
+    result = -result - 1;
+  }
+  return result;
+}
+function encodeIntSafe(bc, x) {
+  (0, import_assert3.default)(Number.isSafeInteger(x), TOO_LARGE_NUMBER2);
+  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) {
+    encodeU8(bc, 128 | firstByte);
+    encodeUintSafe(bc, x);
+  } else {
+    encodeU8(bc, firstByte);
+  }
+}
+function decodeU8(bc) {
+  bc.check(1);
+  return bc.view.getUint8(bc.offset++);
+}
+function encodeU8(bc, x) {
+  (0, import_assert3.default)(isU8(x), TOO_LARGE_NUMBER2);
+  bc.reserve(1);
+  bc.view.setUint8(bc.offset++, x);
+}
+function decodeU16(bc) {
+  bc.check(2);
+  const result = bc.view.getUint16(bc.offset, true);
+  bc.offset += 2;
+  return result;
+}
+function encodeU16(bc, x) {
+  (0, import_assert3.default)(isU16(x), TOO_LARGE_NUMBER2);
+  bc.reserve(2);
+  bc.view.setUint16(bc.offset, x, true);
+  bc.offset += 2;
+}
+function decodeU32(bc) {
+  bc.check(4);
+  const result = bc.view.getUint32(bc.offset, true);
+  bc.offset += 4;
+  return result;
+}
+function encodeU32(bc, x) {
+  (0, import_assert3.default)(isU32(x), TOO_LARGE_NUMBER2);
+  bc.reserve(4);
+  bc.view.setUint32(bc.offset, x, true);
+  bc.offset += 4;
+}
+function decodeU64(bc) {
+  bc.check(8);
+  const result = bc.view.getBigUint64(bc.offset, true);
+  bc.offset += 8;
+  return result;
+}
+function encodeU64(bc, x) {
+  (0, import_assert3.default)(isU64(x), TOO_LARGE_NUMBER2);
+  bc.reserve(8);
+  bc.view.setBigUint64(bc.offset, x, true);
+  bc.offset += 8;
+}
+function decodeU64Safe(bc) {
+  const result = decodeU32(bc) + decodeU32(bc) * 4294967296;
+  if (!isSafeU64(result)) {
+    bc.offset -= 8;
+    throw new BareError(bc.offset, TOO_LARGE_NUMBER2);
+  }
+  return result;
+}
+function encodeU64Safe(bc, x) {
+  (0, import_assert3.default)(isSafeU64(x), TOO_LARGE_NUMBER2);
+  encodeU32(bc, x >>> 0);
+  encodeU32(bc, x / 4294967296 >>> 0);
+}
+var UINT_MAX_BYTE_COUNT = 10;
+function decodeUint(bc) {
+  let byteCount = 0;
+  let byte;
+  let low = 0;
+  let shiftMul = 1;
+  do {
+    byte = decodeU8(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 = decodeU8(bc);
+    height += (byte & 127) * shiftMul;
+    shiftMul *= 128;
+    byteCount++;
+  }
+  if (byteCount !== 1 && 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));
+}
+function encodeUint(bc, x) {
+  (0, import_assert3.default)(isU64(x), TOO_LARGE_NUMBER2);
+  let tmp = Number(BigInt.asUintN(7 * 7, x));
+  let rest = Number(x >> BigInt(7 * 7));
+  let byteCount = 0;
+  while (tmp >= 128 || rest !== 0) {
+    encodeU8(bc, 128 | tmp & 127);
+    tmp = Math.floor(tmp / 128);
+    byteCount++;
+    if (byteCount === 7) {
+      tmp = rest;
+      rest = 0;
+    }
+  }
+  encodeU8(bc, tmp);
+}
+var UINT_SAFE_MAX_BYTE_COUNT = 8;
+function decodeUintSafe(bc) {
+  let result = 0;
+  let shiftMul = 1;
+  let byteCount = 0;
+  let byte;
+  do {
+    byte = decodeU8(bc);
+    result += (byte & 127) * shiftMul;
+    shiftMul *= 128;
+    byteCount++;
+  } while (byte >= 128 && byteCount < UINT_SAFE_MAX_BYTE_COUNT);
+  if (byteCount !== 1 && 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_NUMBER2);
+  }
+  return result;
+}
+function encodeUintSafe(bc, x) {
+  (0, import_assert3.default)(isSafeU64(x), TOO_LARGE_NUMBER2);
+  while (x >= 128) {
+    encodeU8(bc, 128 | x & 127);
+    x = Math.floor(x / 128);
+  }
+  encodeU8(bc, x);
+}
+function decodeVoid(_dc) {
+  return void 0;
+}
+function encodeVoid(_dc, _x) {
+}
+
+// src/codec/u8-array.ts
+function decodeU8Array(bc) {
+  const len = decodeUintSafe(bc);
+  return bc.read(len).slice();
+}
+function encodeU8Array(bc, x) {
+  encodeUintSafe(bc, x.length);
+  bc.write(x);
+}
+function decodeU8FixedArray(bc, len) {
+  return bc.read(len).slice();
+}
+function encodeU8FixedArray(bc, x, len) {
+  (0, import_assert4.default)(x.length === len);
+  bc.write(x);
+}
+
+// src/codec/data.ts
+function decodeData(bc) {
+  return decodeU8Array(bc).buffer;
+}
+function encodeData(bc, x) {
+  encodeU8Array(bc, new Uint8Array(x));
+}
+function decodeFixedData(bc, len) {
+  return decodeU8FixedArray(bc, len).buffer;
+}
+function encodeFixedData(bc, x, len) {
+  encodeU8FixedArray(bc, new Uint8Array(x), len);
+}
+
+// src/codec/float-array.ts
+var import_assert5 = __toESM(require("assert"), 1);
+
+// src/util/util.ts
+var IS_LITTLE_ENDIAN_PLATFORM = new DataView(Uint16Array.of(1).buffer).getUint8(0) === 1;
+
+// src/codec/float-array.ts
+var NAN_NOT_ALLOWED2 = "NaN is not allowed";
+var decodeF32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? decodeF32FixedArrayLE : decodeF32FixedArrayBE;
+function decodeF32FixedArrayLE(bc, len) {
+  const byteLen = len * 4;
+  const result = new Float32Array(decodeFixedData(bc, byteLen));
+  if (result.some(Number.isNaN)) {
+    throw new BareError(bc.offset, NAN_NOT_ALLOWED2);
+  }
+  return result;
+}
+function decodeF32FixedArrayBE(bc, len) {
+  bc.check(len * 4);
+  const result = new Float32Array(len);
+  for (let i = 0; i < len; i++)
+    result[i] = decodeF32(bc);
+  return result;
+}
+var encodeF32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? encodeF32FixedArrayLE : encodeF32FixedArrayBE;
+function encodeF32FixedArrayLE(bc, x, len) {
+  (0, import_assert5.default)(x.length === len);
+  (0, import_assert5.default)(!x.every(Number.isNaN), NAN_NOT_ALLOWED2);
+  bc.write(new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
+}
+function encodeF32FixedArrayBE(bc, val, len) {
+  (0, import_assert5.default)(val.length === len);
+  bc.reserve(val.length * 4);
+  for (let i = 0; i < val.length; i++)
+    encodeF32(bc, val[i]);
+}
+function decodeF32Array(bc) {
+  return decodeF32FixedArray(bc, decodeUintSafe(bc));
+}
+function encodeF32Array(bc, x) {
+  encodeUintSafe(bc, x.length);
+  if (x.length !== 0) {
+    encodeF32FixedArray(bc, x, x.length);
+  }
+}
+var decodeF64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? decodeF64FixedArrayLE : decodeF64FixedArrayBE;
+function decodeF64FixedArrayLE(bc, len) {
+  const byteLen = len * 8;
+  const result = new Float64Array(decodeFixedData(bc, byteLen));
+  if (result.some(Number.isNaN)) {
+    throw new BareError(bc.offset, NAN_NOT_ALLOWED2);
+  }
+  return result;
+}
+function decodeF64FixedArrayBE(bc, len) {
+  bc.check(len * 8);
+  const result = new Float64Array(len);
+  for (let i = 0; i < len; i++)
+    result[i] = decodeF64(bc);
+  return result;
+}
+var encodeF64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? encodeF64FixedArrayLE : encodeF64FixedArrayBE;
+function encodeF64FixedArrayLE(bc, x, len) {
+  (0, import_assert5.default)(x.length === len);
+  (0, import_assert5.default)(!x.every(Number.isNaN), NAN_NOT_ALLOWED2);
+  bc.write(new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
+}
+function encodeF64FixedArrayBE(bc, x, len) {
+  (0, import_assert5.default)(x.length === len);
+  bc.reserve(x.length * 8);
+  for (let i = 0; i < x.length; i++)
+    encodeF64(bc, x[i]);
+}
+function decodeF64Array(bc) {
+  return decodeF64FixedArray(bc, decodeUintSafe(bc));
+}
+function encodeF64Array(bc, x) {
+  encodeUintSafe(bc, x.length);
+  if (x.length !== 0) {
+    encodeF64FixedArray(bc, x, x.length);
+  }
+}
+
+// src/codec/i16-array.ts
+var import_assert6 = __toESM(require("assert"), 1);
+var I16_BYTE_COUNT = 2;
+var decodeI16FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? decodeI16FixedArrayLE : decodeI16FixedArrayBE;
+function decodeI16Array(bc) {
+  return decodeI16FixedArray(bc, decodeUintSafe(bc));
+}
+function decodeI16FixedArrayLE(bc, len) {
+  const byteCount = len * I16_BYTE_COUNT;
+  return new Int16Array(decodeFixedData(bc, byteCount));
+}
+function decodeI16FixedArrayBE(bc, len) {
+  bc.check(len * I16_BYTE_COUNT);
+  const result = new Int16Array(len);
+  for (let i = 0; i < len; i++)
+    result[i] = decodeI16(bc);
+  return result;
+}
+var encodeI16FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? encodeI16FixedArrayLE : encodeI16FixedArrayBE;
+function encodeI16Array(bc, x) {
+  encodeUintSafe(bc, x.length);
+  if (x.length !== 0) {
+    encodeI16FixedArray(bc, x, x.length);
+  }
+}
+function encodeI16FixedArrayLE(bc, x, len) {
+  (0, import_assert6.default)(x.length === len);
+  bc.write(new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
+}
+function encodeI16FixedArrayBE(bc, x, len) {
+  (0, import_assert6.default)(x.length === len);
+  bc.reserve(x.length * I16_BYTE_COUNT);
+  for (let i = 0; i < x.length; i++)
+    encodeI16(bc, x[i]);
+}
+
+// src/codec/i32-array.ts
+var import_assert7 = __toESM(require("assert"), 1);
+var I32_BYTE_COUNT = 4;
+var decodeI32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? decodeI32FixedArrayLE : decodeI32FixedArrayBE;
+function decodeI32Array(bc) {
+  return decodeI32FixedArray(bc, decodeUintSafe(bc));
+}
+function decodeI32FixedArrayLE(bc, len) {
+  const byteCount = len * I32_BYTE_COUNT;
+  return new Int32Array(decodeFixedData(bc, byteCount));
+}
+function decodeI32FixedArrayBE(bc, len) {
+  bc.check(len * I32_BYTE_COUNT);
+  const result = new Int32Array(len);
+  for (let i = 0; i < len; i++)
+    result[i] = decodeI32(bc);
+  return result;
+}
+var encodeI32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? encodeI32FixedArrayLE : encodeI32FixedArrayBE;
+function encodeI32Array(bc, x) {
+  encodeUintSafe(bc, x.length);
+  if (x.length !== 0) {
+    encodeI32FixedArray(bc, x, x.length);
+  }
+}
+function encodeI32FixedArrayLE(bc, x, len) {
+  (0, import_assert7.default)(x.length === len);
+  bc.write(new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
+}
+function encodeI32FixedArrayBE(bc, x, len) {
+  (0, import_assert7.default)(x.length === len);
+  bc.reserve(x.length * I32_BYTE_COUNT);
+  for (let i = 0; i < x.length; i++)
+    encodeI32(bc, x[i]);
+}
+
+// src/codec/i64-array.ts
+var import_assert8 = __toESM(require("assert"), 1);
+var I64_BYTE_COUNT = 8;
+var decodeI64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? decodeI64FixedArrayLE : decodeI64FixedArrayBE;
+function decodeI64Array(bc) {
+  return decodeI64FixedArray(bc, decodeUintSafe(bc));
+}
+function decodeI64FixedArrayLE(bc, len) {
+  const byteCount = len * I64_BYTE_COUNT;
+  return new BigInt64Array(decodeFixedData(bc, byteCount));
+}
+function decodeI64FixedArrayBE(bc, len) {
+  bc.check(len * I64_BYTE_COUNT);
+  const result = new BigInt64Array(len);
+  for (let i = 0; i < len; i++)
+    result[i] = decodeI64(bc);
+  return result;
+}
+var encodeI64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? encodeI64FixedArrayLE : encodeI64FixedArrayBE;
+function encodeI64Array(bc, x) {
+  encodeUintSafe(bc, x.length);
+  if (x.length !== 0) {
+    encodeI64FixedArray(bc, x, x.length);
+  }
+}
+function encodeI64FixedArrayLE(bc, x, len) {
+  (0, import_assert8.default)(x.length === len);
+  bc.write(new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
+}
+function encodeI64FixedArrayBE(bc, x, len) {
+  (0, import_assert8.default)(x.length === len);
+  bc.reserve(x.length * I64_BYTE_COUNT);
+  for (let i = 0; i < x.length; i++)
+    encodeI64(bc, x[i]);
+}
+
+// src/codec/i8-array.ts
+function decodeI8Array(bc) {
+  return decodeI8FixedArray(bc, decodeUintSafe(bc));
+}
+function encodeI8Array(bc, x) {
+  encodeUintSafe(bc, x.length);
+  encodeI8FixedArray(bc, x, x.length);
+}
+function decodeI8FixedArray(bc, len) {
+  return new Int8Array(decodeFixedData(bc, len));
+}
+function encodeI8FixedArray(bc, x, len) {
+  encodeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength), len);
+}
+
+// src/codec/string.ts
+function decodeString(bc) {
+  const strBytesLen = decodeUintSafe(bc);
+  const strBytes = bc.read(strBytesLen);
+  try {
+    return strBytesLen < bc.config.textDecoderThreshold ? decodeUtf8Js(strBytes) : UTF8_DECODER.decode(strBytes);
+  } catch (cause) {
+    throw new BareError(bc.offset - strBytesLen, "invalid UTF-8 string", {
+      cause
+    });
+  }
+}
+function encodeString(bc, x) {
+  if (x.length < bc.config.textEncoderThreshold) {
+    const byteLen = utf8ByteLength(x);
+    encodeUintSafe(bc, byteLen);
+    bc.reserve(byteLen);
+    encodeUtf8Js(bc, x);
+  } else {
+    const strBytes = UTF8_ENCODER.encode(x);
+    encodeUintSafe(bc, strBytes.length);
+    bc.write(strBytes);
+  }
+}
+function decodeUtf8Js(bytes) {
+  const bytesLen = bytes.length;
+  let result = "";
+  let i = 0;
+  while (i < bytesLen) {
+    let codePoint = bytes[i++] | 0;
+    switch (Math.clz32(~codePoint << 24)) {
+      case 0:
+        break;
+      case 2: {
+        if (i < bytesLen) {
+          codePoint = (codePoint & 31) << 6 | bytes[i] & 63;
+        }
+        if (codePoint >> 7 === 0 || bytes[i] >> 6 !== 2) {
+          throw TypeError("Decoding failed");
+        }
+        i += 1;
+        break;
+      }
+      case 3: {
+        if (i + 1 < bytesLen) {
+          codePoint = (codePoint & 15) << 12 | (bytes[i] & 63) << 6 | bytes[i + 1] & 63;
+        }
+        if (codePoint >> 11 === 0 || bytes[i] >> 6 !== 2 || bytes[i + 1] >> 6 !== 2 || codePoint >> 11 === 27) {
+          throw TypeError("Decoding failed");
+        }
+        i += 2;
+        break;
+      }
+      case 4: {
+        if (i + 2 < bytesLen) {
+          codePoint = (codePoint & 7) << 18 | (bytes[i] & 63) << 12 | (bytes[i + 1] & 63) << 6 | bytes[i + 2] & 63;
+        }
+        if (codePoint >> 16 === 0 || codePoint > 1114111 || bytes[i] >> 6 !== 2 || bytes[i + 1] >> 6 !== 2 || bytes[i + 2] >> 6 !== 2) {
+          throw TypeError("Decoding failed");
+        }
+        i += 3;
+        break;
+      }
+      default:
+        throw TypeError("Decoding failed");
+    }
+    result += String.fromCodePoint(codePoint);
+  }
+  return result;
+}
+function encodeUtf8Js(bc, s) {
+  const sLen = s.length;
+  let offset = bc.offset;
+  const view = bc.view;
+  let i = 0;
+  while (i < sLen) {
+    const codePoint = s.codePointAt(i++);
+    if (codePoint < 128) {
+      view.setUint8(offset++, codePoint);
+    } else if (codePoint < 2048) {
+      view.setUint8(offset++, 192 | codePoint >> 6);
+      view.setUint8(offset++, 128 | codePoint & 63);
+    } else if (codePoint < 65536) {
+      view.setUint8(offset++, 224 | codePoint >> 12);
+      view.setUint8(offset++, 128 | codePoint >> 6 & 63);
+      view.setUint8(offset++, 128 | codePoint & 63);
+    } else {
+      view.setUint8(offset++, 240 | codePoint >> 18);
+      view.setUint8(offset++, 128 | codePoint >> 12 & 63);
+      view.setUint8(offset++, 128 | codePoint >> 6 & 63);
+      view.setUint8(offset++, 128 | codePoint & 63);
+      i++;
+    }
+  }
+  bc.offset = offset;
+}
+function utf8ByteLength(s) {
+  const sLen = s.length;
+  let result = 0;
+  let i = 0;
+  while (i < sLen) {
+    const codePoint = s.codePointAt(i);
+    i++;
+    if (codePoint < 128) {
+      result++;
+    } else if (codePoint < 2048) {
+      result += 2;
+    } else if (codePoint < 65536) {
+      result += 3;
+    } else {
+      result += 4;
+      i++;
+    }
+  }
+  return result;
+}
+var UTF8_DECODER = new TextDecoder("utf-8", { fatal: true });
+var UTF8_ENCODER = new TextEncoder();
+
+// src/codec/u16-array.ts
+var import_assert9 = __toESM(require("assert"), 1);
+var U16_BYTE_COUNT = 2;
+var decodeU16FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? decodeU16FixedArrayLE : decodeU16FixedArrayBE;
+function decodeU16Array(bc) {
+  return decodeU16FixedArray(bc, decodeUintSafe(bc));
+}
+function decodeU16FixedArrayLE(bc, len) {
+  const byteCount = len * U16_BYTE_COUNT;
+  return new Uint16Array(decodeFixedData(bc, byteCount));
+}
+function decodeU16FixedArrayBE(bc, len) {
+  bc.check(len * U16_BYTE_COUNT);
+  const result = new Uint16Array(len);
+  for (let i = 0; i < len; i++)
+    result[i] = decodeU16(bc);
+  return result;
+}
+var encodeU16FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? encodeU16FixedArrayLE : encodeU16FixedArrayBE;
+function encodeU16Array(bc, x) {
+  encodeUintSafe(bc, x.length);
+  if (x.length !== 0) {
+    encodeU16FixedArray(bc, x, x.length);
+  }
+}
+function encodeU16FixedArrayLE(bc, x, len) {
+  (0, import_assert9.default)(x.length === len);
+  bc.write(new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
+}
+function encodeU16FixedArrayBE(bc, x, len) {
+  (0, import_assert9.default)(x.length === len);
+  bc.reserve(x.length * U16_BYTE_COUNT);
+  for (let i = 0; i < x.length; i++)
+    encodeU16(bc, x[i]);
+}
+
+// src/codec/u32-array.ts
+var import_assert10 = __toESM(require("assert"), 1);
+var U32_BYTE_COUNT = 4;
+var decodeU32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? decodeU32FixedArrayLE : decodeU32FixedArrayBE;
+function decodeU32Array(bc) {
+  return decodeU32FixedArray(bc, decodeUintSafe(bc));
+}
+function decodeU32FixedArrayLE(bc, len) {
+  const byteCount = len * U32_BYTE_COUNT;
+  return new Uint32Array(decodeFixedData(bc, byteCount));
+}
+function decodeU32FixedArrayBE(bc, len) {
+  bc.check(len * U32_BYTE_COUNT);
+  const result = new Uint32Array(len);
+  for (let i = 0; i < len; i++)
+    result[i] = decodeU32(bc);
+  return result;
+}
+var encodeU32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? encodeU32FixedArrayLE : encodeU32FixedArrayBE;
+function encodeU32Array(bc, x) {
+  encodeUintSafe(bc, x.length);
+  if (x.length !== 0) {
+    encodeU32FixedArray(bc, x, x.length);
+  }
+}
+function encodeU32FixedArrayLE(bc, x, len) {
+  (0, import_assert10.default)(x.length === len);
+  bc.write(new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
+}
+function encodeU32FixedArrayBE(bc, x, len) {
+  (0, import_assert10.default)(x.length === len);
+  bc.reserve(x.length * U32_BYTE_COUNT);
+  for (let i = 0; i < x.length; i++)
+    encodeU32(bc, x[i]);
+}
+
+// src/codec/u64-array.ts
+var import_assert11 = __toESM(require("assert"), 1);
+var U64_BYTE_COUNT = 8;
+var decodeU64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? decodeU64FixedArrayLE : decodeU64FixedArrayBE;
+function decodeU64Array(bc) {
+  return decodeU64FixedArray(bc, decodeUintSafe(bc));
+}
+function decodeU64FixedArrayLE(bc, len) {
+  const byteCount = len * U64_BYTE_COUNT;
+  return new BigUint64Array(decodeFixedData(bc, byteCount));
+}
+function decodeU64FixedArrayBE(bc, len) {
+  bc.check(len * U64_BYTE_COUNT);
+  const result = new BigUint64Array(len);
+  for (let i = 0; i < len; i++)
+    result[i] = decodeU64(bc);
+  return result;
+}
+var encodeU64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? encodeU64FixedArrayLE : encodeU64FixedArrayBE;
+function encodeU64Array(bc, x) {
+  encodeUintSafe(bc, x.length);
+  if (x.length !== 0) {
+    encodeU64FixedArray(bc, x, x.length);
+  }
+}
+function encodeU64FixedArrayLE(bc, x, len) {
+  (0, import_assert11.default)(x.length === len);
+  bc.write(new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
+}
+function encodeU64FixedArrayBE(bc, x, len) {
+  (0, import_assert11.default)(x.length === len);
+  bc.reserve(x.length * U64_BYTE_COUNT);
+  for (let i = 0; i < x.length; i++)
+    encodeU64(bc, x[i]);
+}
+
+// src/codec/u8-clamped-array.ts
+function decodeU8ClampedArray(bc) {
+  return decodeU8ClampedFixedArray(bc, decodeUintSafe(bc));
+}
+function encodeU8ClampedArray(bc, x) {
+  encodeUintSafe(bc, x.length);
+  encodeU8ClampedFixedArray(bc, x, x.length);
+}
+function decodeU8ClampedFixedArray(bc, len) {
+  return new Uint8ClampedArray(decodeFixedData(bc, len));
+}
+function encodeU8ClampedFixedArray(bc, x, len) {
+  encodeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength), len);
+}
+module.exports = __toCommonJS(src_exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BareError,
+  ByteCursor,
+  Config,
+  decodeBool,
+  decodeData,
+  decodeF32,
+  decodeF32Array,
+  decodeF32FixedArray,
+  decodeF64,
+  decodeF64Array,
+  decodeF64FixedArray,
+  decodeFixedData,
+  decodeI16,
+  decodeI16Array,
+  decodeI16FixedArray,
+  decodeI32,
+  decodeI32Array,
+  decodeI32FixedArray,
+  decodeI64,
+  decodeI64Array,
+  decodeI64FixedArray,
+  decodeI64Safe,
+  decodeI8,
+  decodeI8Array,
+  decodeI8FixedArray,
+  decodeInt,
+  decodeIntSafe,
+  decodeString,
+  decodeU16,
+  decodeU16Array,
+  decodeU16FixedArray,
+  decodeU32,
+  decodeU32Array,
+  decodeU32FixedArray,
+  decodeU64,
+  decodeU64Array,
+  decodeU64FixedArray,
+  decodeU64Safe,
+  decodeU8,
+  decodeU8Array,
+  decodeU8ClampedArray,
+  decodeU8ClampedFixedArray,
+  decodeU8FixedArray,
+  decodeUint,
+  decodeUintSafe,
+  decodeVoid,
+  encodeBool,
+  encodeData,
+  encodeF32,
+  encodeF32Array,
+  encodeF32FixedArray,
+  encodeF64,
+  encodeF64Array,
+  encodeF64FixedArray,
+  encodeFixedData,
+  encodeI16,
+  encodeI16Array,
+  encodeI16FixedArray,
+  encodeI32,
+  encodeI32Array,
+  encodeI32FixedArray,
+  encodeI64,
+  encodeI64Array,
+  encodeI64FixedArray,
+  encodeI64Safe,
+  encodeI8,
+  encodeI8Array,
+  encodeI8FixedArray,
+  encodeInt,
+  encodeIntSafe,
+  encodeString,
+  encodeU16,
+  encodeU16Array,
+  encodeU16FixedArray,
+  encodeU32,
+  encodeU32Array,
+  encodeU32FixedArray,
+  encodeU64,
+  encodeU64Array,
+  encodeU64FixedArray,
+  encodeU64Safe,
+  encodeU8,
+  encodeU8Array,
+  encodeU8ClampedArray,
+  encodeU8ClampedFixedArray,
+  encodeU8FixedArray,
+  encodeUint,
+  encodeUintSafe,
+  encodeVoid
+});
+//# sourceMappingURL=index.cjs.map