@bare-ts/lib 0.2.0 → 0.4.0

package/dist/index.cjs

@@ -1,25 +1,21 @@
+"use strict";
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 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 });
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
-  return target;
+  return to;
 };
-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);
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var src_exports = {};
@@ -27,6 +23,7 @@ __export(src_exports, {
   BareError: () => BareError,
   ByteCursor: () => ByteCursor,
   Config: () => Config,
+  check: () => check,
   readBool: () => readBool,
   readData: () => readData,
   readF32: () => readF32,
@@ -70,7 +67,9 @@ __export(src_exports, {
   readU8FixedArray: () => readU8FixedArray,
   readUint: () => readUint,
   readUintSafe: () => readUintSafe,
-  readVoid: () => readVoid,
+  readUintSafe32: () => readUintSafe32,
+  readUnsafeU8FixedArray: () => readUnsafeU8FixedArray,
+  reserve: () => reserve,
   writeBool: () => writeBool,
   writeData: () => writeData,
   writeF32: () => writeF32,
@@ -114,25 +113,30 @@ __export(src_exports, {
   writeU8FixedArray: () => writeU8FixedArray,
   writeUint: () => writeUint,
   writeUintSafe: () => writeUintSafe,
-  writeVoid: () => writeVoid
+  writeUintSafe32: () => writeUintSafe32
 });
+module.exports = __toCommonJS(src_exports);
 
-// src/codec/primitive.ts
-var import_assert2 = require("assert");
+// dist/env/dev.node.js
+var DEV = process.env.NODE_ENV === "development";
 
-// 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/util/assert.ts
+var AssertionError = class extends Error {
+  constructor() {
+    super(...arguments);
+    this.name = "AssertionError";
   }
 };
-
-// src/core/config.ts
-var import_assert = require("assert");
+var V8Error = Error;
+function assert(test, message = "") {
+  if (!test) {
+    const e = new AssertionError(message);
+    if (V8Error.captureStackTrace) {
+      V8Error.captureStackTrace(e, assert);
+    }
+    throw e;
+  }
+}
 
 // src/util/validator.ts
 function isI8(val) {
@@ -147,9 +151,6 @@ function isI32(val) {
 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);
 }
@@ -162,70 +163,77 @@ function isU32(val) {
 function isU64(val) {
   return val === BigInt.asUintN(64, val);
 }
+function isU64Safe(val) {
+  return Number.isSafeInteger(val) && val >= 0;
+}
 
-// src/core/config.ts
+// src/util/constants.ts
+var TEXT_DECODER_THRESHOLD = 256;
+var TEXT_ENCODER_THRESHOLD = 256;
+var INT_SAFE_MAX_BYTE_COUNT = 8;
+var UINT_MAX_BYTE_COUNT = 10;
+var UINT_SAFE32_MAX_BYTE_COUNT = 5;
+var INVALID_UTF8_STRING = "invalid UTF-8 string";
+var NON_CANONICAL_REPRESENTATION = "must be canonical";
+var TOO_LARGE_BUFFER = "too large buffer";
 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.ok)(isU32(config.initialBufferLength), TOO_LARGE_NUMBER);
-  (0, import_assert.ok)(isU32(config.maxBufferLength), TOO_LARGE_NUMBER);
-  (0, import_assert.ok)(isU32(config.textDecoderThreshold), TOO_LARGE_NUMBER);
-  (0, import_assert.ok)(isU32(config.textEncoderThreshold), TOO_LARGE_NUMBER);
-  (0, import_assert.ok)(config.initialBufferLength <= config.maxBufferLength, "initialBufferLength must be lower than or equal to maxBufferLength");
-  return config;
-}
+var IS_LITTLE_ENDIAN_PLATFORM = /* @__PURE__ */ new DataView(Uint16Array.of(1).buffer).getUint8(0) === 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?.cause;
+  }
+};
 
 // src/core/byte-cursor.ts
-var TOO_LARGE_BUFFER = "too large buffer";
 var ByteCursor = class {
+  /**
+   * @throws {BareError} Buffer exceeds `config.maxBufferLength`
+   */
   constructor(bytes, config) {
+    /**
+     * Read and write Offset in {@link view} and {@link bytes}
+     */
+    this.offset = 0;
     if (bytes.length > config.maxBufferLength) {
       throw new BareError(0, TOO_LARGE_BUFFER);
     }
     this.bytes = bytes;
     this.config = config;
-    this.offset = 0;
     this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.length);
   }
-  check(min) {
-    if (this.offset + min > this.bytes.length) {
-      throw new BareError(this.offset, "missing bytes");
-    }
+};
+function check(bc, min) {
+  if (DEV) {
+    assert(isU32(min));
   }
-  reserve(min) {
-    const minLen = this.offset + min | 0;
-    if (minLen > this.bytes.length) {
-      if (minLen > this.config.maxBufferLength) {
-        throw new BareError(0, TOO_LARGE_BUFFER);
-      }
-      const newLen = Math.min(minLen << 1, this.config.maxBufferLength);
-      const newBytes = new Uint8Array(newLen);
-      newBytes.set(this.bytes);
-      this.bytes = newBytes;
-      this.view = new DataView(newBytes.buffer);
-    }
+  if (bc.offset + min > bc.bytes.length) {
+    throw new BareError(bc.offset, "missing bytes");
   }
-  read(len) {
-    this.check(len);
-    const offset = this.offset;
-    this.offset += len;
-    return this.bytes.subarray(offset, offset + len);
+}
+function reserve(bc, min) {
+  if (DEV) {
+    assert(isU32(min));
   }
-};
+  const minLen = bc.offset + min | 0;
+  if (minLen > bc.bytes.length) {
+    if (minLen > bc.config.maxBufferLength) {
+      throw new BareError(0, TOO_LARGE_BUFFER);
+    }
+    const newLen = Math.min(minLen << 1, bc.config.maxBufferLength);
+    const newBytes = new Uint8Array(newLen);
+    newBytes.set(bc.bytes);
+    bc.bytes = newBytes;
+    bc.view = new DataView(newBytes.buffer);
+  }
+}
 
 // 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 readBool(bc) {
   const val = readU8(bc);
   if (val > 1) {
@@ -238,98 +246,112 @@ function writeBool(bc, x) {
   writeU8(bc, x ? 1 : 0);
 }
 function readF32(bc) {
-  bc.check(4);
+  check(bc, 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 writeF32(bc, x) {
-  (0, import_assert2.ok)(!Number.isNaN(x), NAN_NOT_ALLOWED);
-  bc.reserve(4);
+  reserve(bc, 4);
   bc.view.setFloat32(bc.offset, x, true);
-  (0, import_assert2.ok)(Math.abs(bc.view.getFloat32(bc.offset, true) - x) <= Number.EPSILON, TOO_LARGE_NUMBER2);
+  if (DEV) {
+    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);
+  check(bc, 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 writeF64(bc, x) {
-  (0, import_assert2.ok)(!Number.isNaN(x), NAN_NOT_ALLOWED);
-  bc.reserve(8);
+  reserve(bc, 8);
   bc.view.setFloat64(bc.offset, x, true);
   bc.offset += 8;
 }
 function readI8(bc) {
-  bc.check(1);
+  check(bc, 1);
   return bc.view.getInt8(bc.offset++);
 }
 function writeI8(bc, x) {
-  (0, import_assert2.ok)(isI8(x), TOO_LARGE_NUMBER2);
-  bc.reserve(1);
+  if (DEV) {
+    assert(isI8(x), TOO_LARGE_NUMBER);
+  }
+  reserve(bc, 1);
   bc.view.setInt8(bc.offset++, x);
 }
 function readI16(bc) {
-  bc.check(2);
+  check(bc, 2);
   const result = bc.view.getInt16(bc.offset, true);
   bc.offset += 2;
   return result;
 }
 function writeI16(bc, x) {
-  (0, import_assert2.ok)(isI16(x), TOO_LARGE_NUMBER2);
-  bc.reserve(2);
+  if (DEV) {
+    assert(isI16(x), TOO_LARGE_NUMBER);
+  }
+  reserve(bc, 2);
   bc.view.setInt16(bc.offset, x, true);
   bc.offset += 2;
 }
 function readI32(bc) {
-  bc.check(4);
+  check(bc, 4);
   const result = bc.view.getInt32(bc.offset, true);
   bc.offset += 4;
   return result;
 }
 function writeI32(bc, x) {
-  (0, import_assert2.ok)(isI32(x), TOO_LARGE_NUMBER2);
-  bc.reserve(4);
+  if (DEV) {
+    assert(isI32(x), TOO_LARGE_NUMBER);
+  }
+  reserve(bc, 4);
   bc.view.setInt32(bc.offset, x, true);
   bc.offset += 4;
 }
 function readI64(bc) {
-  bc.check(8);
+  check(bc, 8);
   const result = bc.view.getBigInt64(bc.offset, true);
   bc.offset += 8;
   return result;
 }
 function writeI64(bc, x) {
-  (0, import_assert2.ok)(isI64(x), TOO_LARGE_NUMBER2);
-  bc.reserve(8);
+  if (DEV) {
+    assert(isI64(x), TOO_LARGE_NUMBER);
+  }
+  reserve(bc, 8);
   bc.view.setBigInt64(bc.offset, x, true);
   bc.offset += 8;
 }
 function readI64Safe(bc) {
-  const result = readU32(bc) + readI32(bc) * 4294967296;
+  const result = readU32(bc) + readI32(bc) * /* 2**32 */
+  4294967296;
   if (!Number.isSafeInteger(result)) {
     bc.offset -= 8;
-    throw new BareError(bc.offset, TOO_LARGE_NUMBER2);
+    throw new BareError(bc.offset, TOO_LARGE_NUMBER);
   }
   return result;
 }
 function writeI64Safe(bc, x) {
-  (0, import_assert2.ok)(Number.isSafeInteger(x), TOO_LARGE_NUMBER2);
-  const lowest32 = x >>> 0;
+  if (DEV) {
+    assert(Number.isSafeInteger(x), TOO_LARGE_NUMBER);
+  }
+  let lowest32 = x >>> 0;
   writeU32(bc, lowest32);
-  let highest32 = x / 4294967296 | 0;
+  let highest32 = x / /* 2**32 */
+  4294967296 | 0;
   if (x < 0) {
-    highest32 = ~Math.abs(highest32) >>> 0;
+    highest32 = ~(Math.abs(highest32) & /* 2**21-1 */
+    2097151) >>> 0;
     if (lowest32 === 0) {
-      highest32++;
+      if (highest32 === 2097151) {
+        lowest32 = 1;
+      } else {
+        highest32++;
+      }
     }
   }
   writeU32(bc, highest32);
@@ -339,22 +361,28 @@ function readInt(bc) {
   return zigZag >> BigInt(1) ^ -(zigZag & BigInt(1));
 }
 function writeInt(bc, x) {
-  (0, import_assert2.ok)(isI64(x), TOO_LARGE_NUMBER2);
-  const zigZag = x >> BigInt(63) ^ x << BigInt(1);
-  writeUint(bc, zigZag);
+  const truncated = BigInt.asIntN(64, x);
+  if (DEV) {
+    assert(truncated === x, TOO_LARGE_NUMBER);
+  }
+  const zigZag = truncated >> BigInt(63) ^ truncated << BigInt(1);
+  writeTruncatedUint(bc, zigZag);
 }
-var INT_SAFE_MAX_BYTE_COUNT = 8;
 function readIntSafe(bc) {
   const firstByte = readU8(bc);
   let result = (firstByte & 127) >> 1;
   if (firstByte >= 128) {
-    let shiftMul = 64;
+    let shiftMul = (
+      /* 2**6 */
+      64
+    );
     let byteCount = 1;
     let byte;
     do {
       byte = readU8(bc);
       result += (byte & 127) * shiftMul;
-      shiftMul *= 128;
+      shiftMul *= /* 2**7 */
+      128;
       byteCount++;
     } while (byte >= 128 && byteCount < INT_SAFE_MAX_BYTE_COUNT);
     if (byte === 0) {
@@ -363,7 +391,7 @@ function readIntSafe(bc) {
     }
     if (byteCount === INT_SAFE_MAX_BYTE_COUNT && (byte > 31 || firstByte === 255)) {
       bc.offset -= byteCount - 1;
-      throw new BareError(bc.offset, TOO_LARGE_NUMBER2);
+      throw new BareError(bc.offset, TOO_LARGE_NUMBER);
     }
   }
   const isNeg = (firstByte & 1) === 1;
@@ -373,79 +401,100 @@ function readIntSafe(bc) {
   return result;
 }
 function writeIntSafe(bc, x) {
-  (0, import_assert2.ok)(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) {
-    writeU8(bc, 128 | firstByte);
-    writeUintSafe(bc, x);
+  let zigZag = x < 0 ? -(x + 1) : x;
+  let first7Bits = (zigZag & 63) << 1 | sign;
+  zigZag = Math.floor(zigZag / /* 2**6 */
+  64);
+  if (zigZag > 0) {
+    if (!Number.isSafeInteger(x)) {
+      if (DEV) {
+        assert(false, TOO_LARGE_NUMBER);
+      }
+      const low = zigZag & 32767;
+      const high = (zigZag / 32768 >>> 0) * 32768;
+      if (first7Bits === 127 && low === 32767 && high === 4294967295) {
+        first7Bits &= ~2;
+      }
+      zigZag = high + low;
+    }
+    writeU8(bc, 128 | first7Bits);
+    writeUintSafe(bc, zigZag);
   } else {
-    writeU8(bc, firstByte);
+    writeU8(bc, first7Bits);
   }
 }
 function readU8(bc) {
-  bc.check(1);
+  check(bc, 1);
   return bc.bytes[bc.offset++];
 }
 function writeU8(bc, x) {
-  (0, import_assert2.ok)(isU8(x), TOO_LARGE_NUMBER2);
-  bc.reserve(1);
+  if (DEV) {
+    assert(isU8(x), TOO_LARGE_NUMBER);
+  }
+  reserve(bc, 1);
   bc.bytes[bc.offset++] = x;
 }
 function readU16(bc) {
-  bc.check(2);
+  check(bc, 2);
   const result = bc.view.getUint16(bc.offset, true);
   bc.offset += 2;
   return result;
 }
 function writeU16(bc, x) {
-  (0, import_assert2.ok)(isU16(x), TOO_LARGE_NUMBER2);
-  bc.reserve(2);
+  if (DEV) {
+    assert(isU16(x), TOO_LARGE_NUMBER);
+  }
+  reserve(bc, 2);
   bc.view.setUint16(bc.offset, x, true);
   bc.offset += 2;
 }
 function readU32(bc) {
-  bc.check(4);
+  check(bc, 4);
   const result = bc.view.getUint32(bc.offset, true);
   bc.offset += 4;
   return result;
 }
 function writeU32(bc, x) {
-  (0, import_assert2.ok)(isU32(x), TOO_LARGE_NUMBER2);
-  bc.reserve(4);
+  if (DEV) {
+    assert(isU32(x), TOO_LARGE_NUMBER);
+  }
+  reserve(bc, 4);
   bc.view.setUint32(bc.offset, x, true);
   bc.offset += 4;
 }
 function readU64(bc) {
-  bc.check(8);
+  check(bc, 8);
   const result = bc.view.getBigUint64(bc.offset, true);
   bc.offset += 8;
   return result;
 }
 function writeU64(bc, x) {
-  (0, import_assert2.ok)(isU64(x), TOO_LARGE_NUMBER2);
-  bc.reserve(8);
+  if (DEV) {
+    assert(isU64(x), TOO_LARGE_NUMBER);
+  }
+  reserve(bc, 8);
   bc.view.setBigUint64(bc.offset, x, true);
   bc.offset += 8;
 }
 function readU64Safe(bc) {
-  const result = readU32(bc) + readU32(bc) * 4294967296;
-  if (!isSafeU64(result)) {
+  const result = readU32(bc) + readU32(bc) * /* 2**32 */
+  4294967296;
+  if (!isU64Safe(result)) {
     bc.offset -= 8;
-    throw new BareError(bc.offset, TOO_LARGE_NUMBER2);
+    throw new BareError(bc.offset, TOO_LARGE_NUMBER);
   }
   return result;
 }
 function writeU64Safe(bc, x) {
-  (0, import_assert2.ok)(isSafeU64(x), TOO_LARGE_NUMBER2);
+  if (DEV) {
+    assert(isU64Safe(x), TOO_LARGE_NUMBER);
+  }
   writeU32(bc, x >>> 0);
-  writeU32(bc, x / 4294967296 >>> 0);
+  writeU32(bc, x / /* 2**32 */
+  4294967296 & /* 2**21-1 */
+  2097151);
 }
-var UINT_MAX_BYTE_COUNT = 10;
 function readUint(bc) {
   let low = readU8(bc);
   if (low >= 128) {
@@ -456,7 +505,8 @@ function readUint(bc) {
     do {
       byte = readU8(bc);
       low += (byte & 127) * shiftMul;
-      shiftMul *= 128;
+      shiftMul *= /* 2**7 */
+      128;
       byteCount++;
     } while (byte >= 128 && byteCount < 7);
     let height = 0;
@@ -464,7 +514,8 @@ function readUint(bc) {
     while (byte >= 128 && byteCount < UINT_MAX_BYTE_COUNT) {
       byte = readU8(bc);
       height += (byte & 127) * shiftMul;
-      shiftMul *= 128;
+      shiftMul *= /* 2**7 */
+      128;
       byteCount++;
     }
     if (byte === 0 || byteCount === UINT_MAX_BYTE_COUNT && byte > 1) {
@@ -476,13 +527,20 @@ function readUint(bc) {
   return BigInt(low);
 }
 function writeUint(bc, x) {
-  (0, import_assert2.ok)(isU64(x), TOO_LARGE_NUMBER2);
+  const truncated = BigInt.asUintN(64, x);
+  if (DEV) {
+    assert(truncated === x, TOO_LARGE_NUMBER);
+  }
+  writeTruncatedUint(bc, truncated);
+}
+function writeTruncatedUint(bc, x) {
   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);
+    tmp = Math.floor(tmp / /* 2**7 */
+    128);
     byteCount++;
     if (byteCount === 7) {
       tmp = rest;
@@ -491,64 +549,121 @@ function writeUint(bc, x) {
   }
   writeU8(bc, tmp);
 }
-var UINT_SAFE_MAX_BYTE_COUNT = 8;
-function readUintSafe(bc) {
+function readUintSafe32(bc) {
   let result = readU8(bc);
   if (result >= 128) {
     result &= 127;
-    let shiftMul = 128;
+    let shift = 7;
     let byteCount = 1;
     let byte;
     do {
       byte = readU8(bc);
-      result += (byte & 127) * shiftMul;
-      shiftMul *= 128;
+      result += (byte & 127) << shift >>> 0;
+      shift += 7;
       byteCount++;
-    } while (byte >= 128 && byteCount < UINT_SAFE_MAX_BYTE_COUNT);
+    } while (byte >= 128 && byteCount < UINT_SAFE32_MAX_BYTE_COUNT);
     if (byte === 0) {
       bc.offset -= byteCount - 1;
-      throw new BareError(bc.offset - byteCount + 1, NON_CANONICAL_REPRESENTATION);
+      throw new BareError(
+        bc.offset - byteCount + 1,
+        NON_CANONICAL_REPRESENTATION
+      );
     }
-    if (byteCount === UINT_SAFE_MAX_BYTE_COUNT && byte > 15) {
+    if (byteCount === UINT_SAFE32_MAX_BYTE_COUNT && byte > 15) {
       bc.offset -= byteCount - 1;
-      throw new BareError(bc.offset, TOO_LARGE_NUMBER2);
+      throw new BareError(bc.offset, TOO_LARGE_NUMBER);
     }
   }
   return result;
 }
-function writeUintSafe(bc, x) {
-  (0, import_assert2.ok)(isSafeU64(x), TOO_LARGE_NUMBER2);
-  while (x >= 128) {
+function writeUintSafe32(bc, x) {
+  if (DEV) {
+    assert(isU32(x), TOO_LARGE_NUMBER);
+  }
+  let zigZag = x >>> 0;
+  while (zigZag >= 128) {
     writeU8(bc, 128 | x & 127);
-    x = Math.floor(x / 128);
+    zigZag >>>= 7;
   }
-  writeU8(bc, x);
+  writeU8(bc, zigZag);
 }
-function readVoid(_dc) {
-  return void 0;
+function readUintSafe(bc) {
+  let result = readU8(bc);
+  if (result >= 128) {
+    result &= 127;
+    let shiftMul = (
+      /* 2**7 */
+      128
+    );
+    let byteCount = 1;
+    let byte;
+    do {
+      byte = readU8(bc);
+      result += (byte & 127) * shiftMul;
+      shiftMul *= /* 2**7 */
+      128;
+      byteCount++;
+    } while (byte >= 128 && byteCount < INT_SAFE_MAX_BYTE_COUNT);
+    if (byte === 0) {
+      bc.offset -= byteCount - 1;
+      throw new BareError(
+        bc.offset - byteCount + 1,
+        NON_CANONICAL_REPRESENTATION
+      );
+    }
+    if (byteCount === INT_SAFE_MAX_BYTE_COUNT && byte > 15) {
+      bc.offset -= byteCount - 1;
+      throw new BareError(bc.offset, TOO_LARGE_NUMBER);
+    }
+  }
+  return result;
 }
-function writeVoid(_dc, _x) {
+function writeUintSafe(bc, x) {
+  if (DEV) {
+    assert(isU64Safe(x), TOO_LARGE_NUMBER);
+  }
+  let byteCount = 1;
+  let zigZag = x;
+  while (zigZag >= 128 && byteCount < INT_SAFE_MAX_BYTE_COUNT) {
+    writeU8(bc, 128 | zigZag & 127);
+    zigZag = Math.floor(zigZag / /* 2**7 */
+    128);
+    byteCount++;
+  }
+  if (byteCount === INT_SAFE_MAX_BYTE_COUNT) {
+    zigZag &= 15;
+  }
+  writeU8(bc, zigZag);
 }
 
 // src/codec/u8-array.ts
 function readU8Array(bc) {
-  return readU8FixedArray(bc, readUintSafe(bc));
+  return readU8FixedArray(bc, readUintSafe32(bc));
 }
 function writeU8Array(bc, x) {
-  writeUintSafe(bc, x.length);
+  writeUintSafe32(bc, x.length);
   writeU8FixedArray(bc, x);
 }
 function readU8FixedArray(bc, len) {
-  return bc.read(len).slice();
+  return readUnsafeU8FixedArray(bc, len).slice();
 }
 function writeU8FixedArray(bc, x) {
   const len = x.length;
   if (len !== 0) {
-    bc.reserve(len);
+    reserve(bc, len);
     bc.bytes.set(x, bc.offset);
     bc.offset += len;
   }
 }
+function readUnsafeU8FixedArray(bc, len) {
+  if (DEV) {
+    assert(isU32(len));
+  }
+  check(bc, len);
+  const offset = bc.offset;
+  bc.offset += len;
+  return bc.bytes.subarray(offset, offset + len);
+}
 
 // src/codec/data.ts
 function readData(bc) {
@@ -558,6 +673,9 @@ function writeData(bc, x) {
   writeU8Array(bc, new Uint8Array(x));
 }
 function readFixedData(bc, len) {
+  if (DEV) {
+    assert(isU32(len));
+  }
   return readU8FixedArray(bc, len).buffer;
 }
 function writeFixedData(bc, x) {
@@ -565,181 +683,203 @@ function writeFixedData(bc, x) {
 }
 
 // src/codec/float-array.ts
-var import_assert3 = require("assert");
-
-// 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 readF32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readF32FixedArrayLE : readF32FixedArrayBE;
-function readF32FixedArrayLE(bc, len) {
+var readF32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readF32FixedArrayLe : readF32FixedArrayBe;
+function readF32FixedArrayLe(bc, len) {
+  if (DEV) {
+    assert(isU32(len));
+  }
   const byteLen = len * 4;
   const result = new Float32Array(readFixedData(bc, byteLen));
-  if (result.some(Number.isNaN)) {
-    throw new BareError(bc.offset, NAN_NOT_ALLOWED2);
-  }
   return result;
 }
-function readF32FixedArrayBE(bc, len) {
-  bc.check(len * 4);
+function readF32FixedArrayBe(bc, len) {
+  if (DEV) {
+    assert(isU32(len));
+  }
+  check(bc, len * 4);
   const result = new Float32Array(len);
-  for (let i = 0; i < len; i++)
+  for (let i = 0; i < len; i++) {
     result[i] = readF32(bc);
+  }
   return result;
 }
-var writeF32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeF32FixedArrayLE : writeF32FixedArrayBE;
-function writeF32FixedArrayLE(bc, x) {
-  (0, import_assert3.ok)(!x.every(Number.isNaN), NAN_NOT_ALLOWED2);
+var writeF32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeF32FixedArrayLe : writeF32FixedArrayBe;
+function writeF32FixedArrayLe(bc, x) {
   writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
 }
-function writeF32FixedArrayBE(bc, val) {
-  bc.reserve(val.length * 4);
-  for (let i = 0; i < val.length; i++)
+function writeF32FixedArrayBe(bc, val) {
+  reserve(bc, val.length * 4);
+  for (let i = 0; i < val.length; i++) {
     writeF32(bc, val[i]);
+  }
 }
 function readF32Array(bc) {
-  return readF32FixedArray(bc, readUintSafe(bc));
+  return readF32FixedArray(bc, readUintSafe32(bc));
 }
 function writeF32Array(bc, x) {
-  writeUintSafe(bc, x.length);
+  writeUintSafe32(bc, x.length);
   if (x.length !== 0) {
     writeF32FixedArray(bc, x);
   }
 }
-var readF64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readF64FixedArrayLE : readF64FixedArrayBE;
-function readF64FixedArrayLE(bc, len) {
+var readF64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readF64FixedArrayLe : readF64FixedArrayBe;
+function readF64FixedArrayLe(bc, len) {
+  if (DEV) {
+    assert(isU32(len));
+  }
   const byteLen = len * 8;
   const result = new Float64Array(readFixedData(bc, byteLen));
-  if (result.some(Number.isNaN)) {
-    throw new BareError(bc.offset, NAN_NOT_ALLOWED2);
-  }
   return result;
 }
-function readF64FixedArrayBE(bc, len) {
-  bc.check(len * 8);
+function readF64FixedArrayBe(bc, len) {
+  if (DEV) {
+    assert(isU32(len));
+  }
+  check(bc, len * 8);
   const result = new Float64Array(len);
-  for (let i = 0; i < len; i++)
+  for (let i = 0; i < len; i++) {
     result[i] = readF64(bc);
+  }
   return result;
 }
-var writeF64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeF64FixedArrayLE : writeF64FixedArrayBE;
-function writeF64FixedArrayLE(bc, x) {
-  (0, import_assert3.ok)(!x.every(Number.isNaN), NAN_NOT_ALLOWED2);
+var writeF64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeF64FixedArrayLe : writeF64FixedArrayBe;
+function writeF64FixedArrayLe(bc, x) {
   writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
 }
-function writeF64FixedArrayBE(bc, x) {
-  bc.reserve(x.length * 8);
-  for (let i = 0; i < x.length; i++)
+function writeF64FixedArrayBe(bc, x) {
+  reserve(bc, x.length * 8);
+  for (let i = 0; i < x.length; i++) {
     writeF64(bc, x[i]);
+  }
 }
 function readF64Array(bc) {
-  return readF64FixedArray(bc, readUintSafe(bc));
+  return readF64FixedArray(bc, readUintSafe32(bc));
 }
 function writeF64Array(bc, x) {
-  writeUintSafe(bc, x.length);
+  writeUintSafe32(bc, x.length);
   if (x.length !== 0) {
     writeF64FixedArray(bc, x);
   }
 }
 
 // src/codec/i16-array.ts
-var I16_BYTE_COUNT = 2;
-var readI16FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readI16FixedArrayLE : readI16FixedArrayBE;
+var readI16FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readI16FixedArrayLe : readI16FixedArrayBe;
 function readI16Array(bc) {
-  return readI16FixedArray(bc, readUintSafe(bc));
+  return readI16FixedArray(bc, readUintSafe32(bc));
 }
-function readI16FixedArrayLE(bc, len) {
-  const byteCount = len * I16_BYTE_COUNT;
+function readI16FixedArrayLe(bc, len) {
+  if (DEV) {
+    assert(isU32(len));
+  }
+  const byteCount = len * 2;
   return new Int16Array(readFixedData(bc, byteCount));
 }
-function readI16FixedArrayBE(bc, len) {
-  bc.check(len * I16_BYTE_COUNT);
+function readI16FixedArrayBe(bc, len) {
+  if (DEV) {
+    assert(isU32(len));
+  }
+  check(bc, len * 2);
   const result = new Int16Array(len);
-  for (let i = 0; i < len; i++)
+  for (let i = 0; i < len; i++) {
     result[i] = readI16(bc);
+  }
   return result;
 }
-var writeI16FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeI16FixedArrayLE : writeI16FixedArrayBE;
+var writeI16FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeI16FixedArrayLe : writeI16FixedArrayBe;
 function writeI16Array(bc, x) {
-  writeUintSafe(bc, x.length);
+  writeUintSafe32(bc, x.length);
   if (x.length !== 0) {
     writeI16FixedArray(bc, x);
   }
 }
-function writeI16FixedArrayLE(bc, x) {
+function writeI16FixedArrayLe(bc, x) {
   writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
 }
-function writeI16FixedArrayBE(bc, x) {
-  bc.reserve(x.length * I16_BYTE_COUNT);
-  for (let i = 0; i < x.length; i++)
+function writeI16FixedArrayBe(bc, x) {
+  reserve(bc, x.length * 2);
+  for (let i = 0; i < x.length; i++) {
     writeI16(bc, x[i]);
+  }
 }
 
 // src/codec/i32-array.ts
-var I32_BYTE_COUNT = 4;
-var readI32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readI32FixedArrayLE : readI32FixedArrayBE;
+var readI32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readI32FixedArrayLe : readI32FixedArrayBe;
 function readI32Array(bc) {
-  return readI32FixedArray(bc, readUintSafe(bc));
+  return readI32FixedArray(bc, readUintSafe32(bc));
 }
-function readI32FixedArrayLE(bc, len) {
-  const byteCount = len * I32_BYTE_COUNT;
+function readI32FixedArrayLe(bc, len) {
+  if (DEV) {
+    assert(isU32(len));
+  }
+  const byteCount = len * 4;
   return new Int32Array(readFixedData(bc, byteCount));
 }
-function readI32FixedArrayBE(bc, len) {
-  bc.check(len * I32_BYTE_COUNT);
+function readI32FixedArrayBe(bc, len) {
+  if (DEV) {
+    assert(isU32(len));
+  }
+  check(bc, len * 4);
   const result = new Int32Array(len);
-  for (let i = 0; i < len; i++)
+  for (let i = 0; i < len; i++) {
     result[i] = readI32(bc);
+  }
   return result;
 }
-var writeI32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeI32FixedArrayLE : writeI32FixedArrayBE;
+var writeI32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeI32FixedArrayLe : writeI32FixedArrayBe;
 function writeI32Array(bc, x) {
-  writeUintSafe(bc, x.length);
+  writeUintSafe32(bc, x.length);
   if (x.length !== 0) {
     writeI32FixedArray(bc, x);
   }
 }
-function writeI32FixedArrayLE(bc, x) {
+function writeI32FixedArrayLe(bc, x) {
   writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
 }
-function writeI32FixedArrayBE(bc, x) {
-  bc.reserve(x.length * I32_BYTE_COUNT);
-  for (let i = 0; i < x.length; i++)
+function writeI32FixedArrayBe(bc, x) {
+  reserve(bc, x.length * 4);
+  for (let i = 0; i < x.length; i++) {
     writeI32(bc, x[i]);
+  }
 }
 
 // src/codec/i64-array.ts
-var I64_BYTE_COUNT = 8;
-var readI64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readI64FixedArrayLE : readI64FixedArrayBE;
+var readI64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readI64FixedArrayLe : readI64FixedArrayBe;
 function readI64Array(bc) {
-  return readI64FixedArray(bc, readUintSafe(bc));
+  return readI64FixedArray(bc, readUintSafe32(bc));
 }
-function readI64FixedArrayLE(bc, len) {
-  const byteCount = len * I64_BYTE_COUNT;
+function readI64FixedArrayLe(bc, len) {
+  if (DEV) {
+    assert(isU32(len));
+  }
+  const byteCount = len * 8;
   return new BigInt64Array(readFixedData(bc, byteCount));
 }
-function readI64FixedArrayBE(bc, len) {
-  bc.check(len * I64_BYTE_COUNT);
+function readI64FixedArrayBe(bc, len) {
+  if (DEV) {
+    assert(isU32(len));
+  }
+  check(bc, len * 8);
   const result = new BigInt64Array(len);
-  for (let i = 0; i < len; i++)
+  for (let i = 0; i < len; i++) {
     result[i] = readI64(bc);
+  }
   return result;
 }
-var writeI64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeI64FixedArrayLE : writeI64FixedArrayBE;
+var writeI64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeI64FixedArrayLe : writeI64FixedArrayBe;
 function writeI64Array(bc, x) {
-  writeUintSafe(bc, x.length);
+  writeUintSafe32(bc, x.length);
   if (x.length !== 0) {
     writeI64FixedArray(bc, x);
   }
 }
-function writeI64FixedArrayLE(bc, x) {
+function writeI64FixedArrayLe(bc, x) {
   writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
 }
-function writeI64FixedArrayBE(bc, x) {
-  bc.reserve(x.length * I64_BYTE_COUNT);
-  for (let i = 0; i < x.length; i++)
+function writeI64FixedArrayBe(bc, x) {
+  reserve(bc, x.length * 8);
+  for (let i = 0; i < x.length; i++) {
     writeI64(bc, x[i]);
+  }
 }
 
 // src/codec/i8-array.ts
@@ -747,10 +887,13 @@ function readI8Array(bc) {
   return readI8FixedArray(bc, readUintSafe(bc));
 }
 function writeI8Array(bc, x) {
-  writeUintSafe(bc, x.length);
+  writeUintSafe32(bc, x.length);
   writeI8FixedArray(bc, x);
 }
 function readI8FixedArray(bc, len) {
+  if (DEV) {
+    assert(isU32(len));
+  }
   return new Int8Array(readFixedData(bc, len));
 }
 function writeI8FixedArray(bc, x) {
@@ -758,43 +901,45 @@ function writeI8FixedArray(bc, x) {
 }
 
 // src/codec/string.ts
-var INVALID_UTF8_STRING = "invalid UTF-8 string";
 function readString(bc) {
-  return readFixedString(bc, readUintSafe(bc));
+  return readFixedString(bc, readUintSafe32(bc));
 }
 function writeString(bc, x) {
-  if (x.length < bc.config.textEncoderThreshold) {
+  if (x.length < TEXT_ENCODER_THRESHOLD) {
     const byteLen = utf8ByteLength(x);
-    writeUintSafe(bc, byteLen);
-    bc.reserve(byteLen);
+    writeUintSafe32(bc, byteLen);
+    reserve(bc, byteLen);
     writeUtf8Js(bc, x);
   } else {
     const strBytes = UTF8_ENCODER.encode(x);
-    writeUintSafe(bc, strBytes.length);
+    writeUintSafe32(bc, strBytes.length);
     writeU8FixedArray(bc, strBytes);
   }
 }
 function readFixedString(bc, byteLen) {
-  if (byteLen < bc.config.textDecoderThreshold) {
+  if (DEV) {
+    assert(isU32(byteLen));
+  }
+  if (byteLen < TEXT_DECODER_THRESHOLD) {
     return readUtf8Js(bc, byteLen);
   }
   try {
-    return UTF8_DECODER.decode(bc.read(byteLen));
-  } catch (cause) {
+    return UTF8_DECODER.decode(readUnsafeU8FixedArray(bc, byteLen));
+  } catch (_cause) {
     throw new BareError(bc.offset, INVALID_UTF8_STRING);
   }
 }
 function writeFixedString(bc, x) {
-  if (x.length < bc.config.textEncoderThreshold) {
+  if (x.length < TEXT_ENCODER_THRESHOLD) {
     const byteLen = utf8ByteLength(x);
-    bc.reserve(byteLen);
+    reserve(bc, byteLen);
     writeUtf8Js(bc, x);
   } else {
     writeU8FixedArray(bc, UTF8_ENCODER.encode(x));
   }
 }
 function readUtf8Js(bc, byteLen) {
-  bc.check(byteLen);
+  check(bc, byteLen);
   let result = "";
   const bytes = bc.bytes;
   let offset = bc.offset;
@@ -807,18 +952,29 @@ function readUtf8Js(bc, byteLen) {
       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;
+        malformed = codePoint >> 7 === 0 || // non-canonical char
+        byte1 >> 5 !== 6 || // invalid tag
+        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;
+        malformed = codePoint >> 11 === 0 || // non-canonical char or missing data
+        codePoint >> 11 === 27 || // surrogate char (0xD800 <= codePoint <= 0xDFFF)
+        byte1 >> 4 !== 14 || // invalid tag
+        byte2 >> 6 !== 2 || // invalid tag
+        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;
+        malformed = codePoint >> 16 === 0 || // non-canonical char or missing data
+        codePoint > 1114111 || // too large code point
+        byte1 >> 3 !== 30 || // invalid tag
+        byte2 >> 6 !== 2 || // invalid tag
+        byte3 >> 6 !== 2 || // invalid tag
+        byte4 >> 6 !== 2;
       }
       if (malformed) {
         throw new BareError(bc.offset, INVALID_UTF8_STRING);
@@ -871,128 +1027,171 @@ function utf8ByteLength(s) {
   }
   return result;
 }
-var UTF8_DECODER = new TextDecoder("utf-8", { fatal: true });
-var UTF8_ENCODER = new TextEncoder();
+var UTF8_DECODER = /* @__PURE__ */ new TextDecoder("utf-8", { fatal: true });
+var UTF8_ENCODER = /* @__PURE__ */ new TextEncoder();
 
 // src/codec/u16-array.ts
-var U16_BYTE_COUNT = 2;
-var readU16FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readU16FixedArrayLE : readU16FixedArrayBE;
+var readU16FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readU16FixedArrayLe : readU16FixedArrayBe;
 function readU16Array(bc) {
-  return readU16FixedArray(bc, readUintSafe(bc));
+  return readU16FixedArray(bc, readUintSafe32(bc));
 }
-function readU16FixedArrayLE(bc, len) {
-  const byteCount = len * U16_BYTE_COUNT;
+function readU16FixedArrayLe(bc, len) {
+  if (DEV) {
+    assert(isU32(len));
+  }
+  const byteCount = len * 2;
   return new Uint16Array(readFixedData(bc, byteCount));
 }
-function readU16FixedArrayBE(bc, len) {
-  bc.check(len * U16_BYTE_COUNT);
+function readU16FixedArrayBe(bc, len) {
+  if (DEV) {
+    assert(isU32(len));
+  }
+  check(bc, len * 2);
   const result = new Uint16Array(len);
-  for (let i = 0; i < len; i++)
+  for (let i = 0; i < len; i++) {
     result[i] = readU16(bc);
+  }
   return result;
 }
-var writeU16FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeU16FixedArrayLE : writeU16FixedArrayBE;
+var writeU16FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeU16FixedArrayLe : writeU16FixedArrayBe;
 function writeU16Array(bc, x) {
-  writeUintSafe(bc, x.length);
+  writeUintSafe32(bc, x.length);
   if (x.length !== 0) {
     writeU16FixedArray(bc, x);
   }
 }
-function writeU16FixedArrayLE(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++)
+function writeU16FixedArrayBe(bc, x) {
+  reserve(bc, x.length * 2);
+  for (let i = 0; i < x.length; i++) {
     writeU16(bc, x[i]);
+  }
 }
 
 // src/codec/u32-array.ts
-var U32_BYTE_COUNT = 4;
-var readU32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readU32FixedArrayLE : readU32FixedArrayBE;
+var readU32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readU32FixedArrayLe : readU32FixedArrayBe;
 function readU32Array(bc) {
-  return readU32FixedArray(bc, readUintSafe(bc));
+  return readU32FixedArray(bc, readUintSafe32(bc));
 }
-function readU32FixedArrayLE(bc, len) {
-  const byteCount = len * U32_BYTE_COUNT;
+function readU32FixedArrayLe(bc, len) {
+  if (DEV) {
+    assert(isU32(len));
+  }
+  const byteCount = len * 4;
   return new Uint32Array(readFixedData(bc, byteCount));
 }
-function readU32FixedArrayBE(bc, len) {
-  bc.check(len * U32_BYTE_COUNT);
+function readU32FixedArrayBe(bc, len) {
+  if (DEV) {
+    assert(isU32(len));
+  }
+  check(bc, len * 4);
   const result = new Uint32Array(len);
-  for (let i = 0; i < len; i++)
+  for (let i = 0; i < len; i++) {
     result[i] = readU32(bc);
+  }
   return result;
 }
-var writeU32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeU32FixedArrayLE : writeU32FixedArrayBE;
+var writeU32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeU32FixedArrayLe : writeU32FixedArrayBe;
 function writeU32Array(bc, x) {
-  writeUintSafe(bc, x.length);
+  writeUintSafe32(bc, x.length);
   if (x.length !== 0) {
     writeU32FixedArray(bc, x);
   }
 }
-function writeU32FixedArrayLE(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++)
+function writeU32FixedArrayBe(bc, x) {
+  reserve(bc, x.length * 4);
+  for (let i = 0; i < x.length; i++) {
     writeU32(bc, x[i]);
+  }
 }
 
 // src/codec/u64-array.ts
-var U64_BYTE_COUNT = 8;
-var readU64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readU64FixedArrayLE : readU64FixedArrayBE;
+var readU64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readU64FixedArrayLe : readU64FixedArrayBe;
 function readU64Array(bc) {
-  return readU64FixedArray(bc, readUintSafe(bc));
+  return readU64FixedArray(bc, readUintSafe32(bc));
 }
-function readU64FixedArrayLE(bc, len) {
-  const byteCount = len * U64_BYTE_COUNT;
+function readU64FixedArrayLe(bc, len) {
+  if (DEV) {
+    assert(isU32(len));
+  }
+  const byteCount = len * 8;
   return new BigUint64Array(readFixedData(bc, byteCount));
 }
-function readU64FixedArrayBE(bc, len) {
-  bc.check(len * U64_BYTE_COUNT);
+function readU64FixedArrayBe(bc, len) {
+  if (DEV) {
+    assert(isU32(len));
+  }
+  check(bc, len * 8);
   const result = new BigUint64Array(len);
-  for (let i = 0; i < len; i++)
+  for (let i = 0; i < len; i++) {
     result[i] = readU64(bc);
+  }
   return result;
 }
-var writeU64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeU64FixedArrayLE : writeU64FixedArrayBE;
+var writeU64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeU64FixedArrayLe : writeU64FixedArrayBe;
 function writeU64Array(bc, x) {
-  writeUintSafe(bc, x.length);
+  writeUintSafe32(bc, x.length);
   if (x.length !== 0) {
     writeU64FixedArray(bc, x);
   }
 }
-function writeU64FixedArrayLE(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++)
+function writeU64FixedArrayBe(bc, x) {
+  reserve(bc, x.length * 8);
+  for (let i = 0; i < x.length; i++) {
     writeU64(bc, x[i]);
+  }
 }
 
 // src/codec/u8-clamped-array.ts
 function readU8ClampedArray(bc) {
-  return readU8ClampedFixedArray(bc, readUintSafe(bc));
+  return readU8ClampedFixedArray(bc, readUintSafe32(bc));
 }
 function writeU8ClampedArray(bc, x) {
-  writeUintSafe(bc, x.length);
+  writeUintSafe32(bc, x.length);
   writeU8ClampedFixedArray(bc, x);
 }
 function readU8ClampedFixedArray(bc, len) {
+  if (DEV) {
+    assert(isU32(len));
+  }
   return new Uint8ClampedArray(readFixedData(bc, len));
 }
 function writeU8ClampedFixedArray(bc, x) {
   writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
 }
-module.exports = __toCommonJS(src_exports);
+
+// src/core/config.ts
+function Config({
+  initialBufferLength = 1024,
+  maxBufferLength = 1024 * 1024 * 32
+}) {
+  if (DEV) {
+    assert(isU32(initialBufferLength), TOO_LARGE_NUMBER);
+    assert(isU32(maxBufferLength), TOO_LARGE_NUMBER);
+    assert(
+      initialBufferLength <= maxBufferLength,
+      "initialBufferLength must be lower than or equal to maxBufferLength"
+    );
+  }
+  return {
+    initialBufferLength,
+    maxBufferLength
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BareError,
   ByteCursor,
   Config,
+  check,
   readBool,
   readData,
   readF32,
@@ -1036,7 +1235,9 @@ module.exports = __toCommonJS(src_exports);
   readU8FixedArray,
   readUint,
   readUintSafe,
-  readVoid,
+  readUintSafe32,
+  readUnsafeU8FixedArray,
+  reserve,
   writeBool,
   writeData,
   writeF32,
@@ -1080,5 +1281,5 @@ module.exports = __toCommonJS(src_exports);
   writeU8FixedArray,
   writeUint,
   writeUintSafe,
-  writeVoid
+  writeUintSafe32
 });