@bare-ts/lib 0.1.0 → 0.1.1

package/dist/core/byte-cursor.js

@@ -0,0 +1,52 @@
+// src/core/byte-cursor.ts
+import { ok as assert } from "assert";
+import { BareError } from "../core/bare-error.js";
+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;
+      assert(bytes.length === view.byteOffset + view.byteLength, "un-growable buffer");
+      assert(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 bufferOffset = this.view.byteOffset + this.offset;
+      const buffer = new Uint8Array(this.view.buffer);
+      buffer.set(bytes, bufferOffset);
+      this.offset += len;
+    }
+  }
+};
+export {
+  ByteCursor
+};
+//# sourceMappingURL=byte-cursor.js.map

package/dist/core/config.js

@@ -0,0 +1,26 @@
+// src/core/config.ts
+import { ok as assert } from "assert";
+import { isU32 } from "../util/validator.js";
+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);
+  assert(isU32(config.initialBufferLength), TOO_LARGE_NUMBER);
+  assert(isU32(config.maxBufferLength), TOO_LARGE_NUMBER);
+  assert(isU32(config.textDecoderThreshold), TOO_LARGE_NUMBER);
+  assert(isU32(config.textEncoderThreshold), TOO_LARGE_NUMBER);
+  assert(config.initialBufferLength <= config.maxBufferLength, "initialBufferLength must be lower than or equal to maxBufferLength");
+  return config;
+}
+export {
+  Config
+};
+//# sourceMappingURL=config.js.map

package/dist/core/index.js

@@ -0,0 +1,5 @@
+// src/core/index.ts
+export * from "./bare-error.js";
+export * from "./config.js";
+export * from "./byte-cursor.js";
+//# sourceMappingURL=index.js.map

package/dist/index.cjs

@@ -1,8 +1,6 @@
-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) => {
@@ -17,9 +15,6 @@ var __reExport = (target, module2, copyDefault, desc) => {
   }
   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);
@@ -121,10 +116,10 @@ __export(src_exports, {
 });
 
 // src/codec/u8-array.ts
-var import_assert4 = __toESM(require("assert"), 1);
+var import_assert4 = require("assert");
 
 // src/codec/primitive.ts
-var import_assert3 = __toESM(require("assert"), 1);
+var import_assert3 = require("assert");
 
 // src/core/bare-error.ts
 var BareError = class extends Error {
@@ -138,7 +133,7 @@ var BareError = class extends Error {
 };
 
 // src/core/config.ts
-var import_assert = __toESM(require("assert"), 1);
+var import_assert = require("assert");
 
 // src/util/validator.ts
 function isI8(val) {
@@ -182,16 +177,16 @@ function Config(part) {
     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");
+  (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;
 }
 
 // src/core/byte-cursor.ts
-var import_assert2 = __toESM(require("assert"), 1);
+var import_assert2 = require("assert");
 var TOO_LARGE_BUFFER = "too large buffer";
 var ByteCursor = class {
   constructor(bytes, config) {
@@ -212,8 +207,8 @@ var ByteCursor = class {
     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);
+      (0, import_assert2.ok)(bytes.length === view.byteOffset + view.byteLength, "un-growable buffer");
+      (0, import_assert2.ok)(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);
@@ -230,8 +225,9 @@ var ByteCursor = class {
     const len = bytes.length;
     if (len !== 0) {
       this.reserve(len);
-      const writableArea = new Uint8Array(this.view.buffer, this.offset, len);
-      writableArea.set(bytes);
+      const bufferOffset = this.view.byteOffset + this.offset;
+      const buffer = new Uint8Array(this.view.buffer);
+      buffer.set(bytes, bufferOffset);
       this.offset += len;
     }
   }
@@ -262,10 +258,10 @@ function decodeF32(bc) {
   return result;
 }
 function encodeF32(bc, x) {
-  (0, import_assert3.default)(!Number.isNaN(x), NAN_NOT_ALLOWED);
+  (0, import_assert3.ok)(!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);
+  (0, import_assert3.ok)(Math.abs(bc.view.getFloat32(bc.offset, true) - x) <= Number.EPSILON, TOO_LARGE_NUMBER2);
   bc.offset += 4;
 }
 function decodeF64(bc) {
@@ -278,7 +274,7 @@ function decodeF64(bc) {
   return result;
 }
 function encodeF64(bc, x) {
-  (0, import_assert3.default)(!Number.isNaN(x), NAN_NOT_ALLOWED);
+  (0, import_assert3.ok)(!Number.isNaN(x), NAN_NOT_ALLOWED);
   bc.reserve(8);
   bc.view.setFloat64(bc.offset, x, true);
   bc.offset += 8;
@@ -288,7 +284,7 @@ function decodeI8(bc) {
   return bc.view.getInt8(bc.offset++);
 }
 function encodeI8(bc, x) {
-  (0, import_assert3.default)(isI8(x), TOO_LARGE_NUMBER2);
+  (0, import_assert3.ok)(isI8(x), TOO_LARGE_NUMBER2);
   bc.reserve(1);
   bc.view.setInt8(bc.offset++, x);
 }
@@ -299,7 +295,7 @@ function decodeI16(bc) {
   return result;
 }
 function encodeI16(bc, x) {
-  (0, import_assert3.default)(isI16(x), TOO_LARGE_NUMBER2);
+  (0, import_assert3.ok)(isI16(x), TOO_LARGE_NUMBER2);
   bc.reserve(2);
   bc.view.setInt16(bc.offset, x, true);
   bc.offset += 2;
@@ -311,7 +307,7 @@ function decodeI32(bc) {
   return result;
 }
 function encodeI32(bc, x) {
-  (0, import_assert3.default)(isI32(x), TOO_LARGE_NUMBER2);
+  (0, import_assert3.ok)(isI32(x), TOO_LARGE_NUMBER2);
   bc.reserve(4);
   bc.view.setInt32(bc.offset, x, true);
   bc.offset += 4;
@@ -323,7 +319,7 @@ function decodeI64(bc) {
   return result;
 }
 function encodeI64(bc, x) {
-  (0, import_assert3.default)(isI64(x), TOO_LARGE_NUMBER2);
+  (0, import_assert3.ok)(isI64(x), TOO_LARGE_NUMBER2);
   bc.reserve(8);
   bc.view.setBigInt64(bc.offset, x, true);
   bc.offset += 8;
@@ -337,7 +333,7 @@ function decodeI64Safe(bc) {
   return result;
 }
 function encodeI64Safe(bc, x) {
-  (0, import_assert3.default)(Number.isSafeInteger(x), TOO_LARGE_NUMBER2);
+  (0, import_assert3.ok)(Number.isSafeInteger(x), TOO_LARGE_NUMBER2);
   const lowest32 = x >>> 0;
   encodeU32(bc, lowest32);
   let highest32 = x / 4294967296 | 0;
@@ -354,7 +350,7 @@ function decodeInt(bc) {
   return zigZag >> BigInt(1) ^ -(zigZag & BigInt(1));
 }
 function encodeInt(bc, x) {
-  (0, import_assert3.default)(isI64(x), TOO_LARGE_NUMBER2);
+  (0, import_assert3.ok)(isI64(x), TOO_LARGE_NUMBER2);
   const zigZag = x >> BigInt(63) ^ x << BigInt(1);
   encodeUint(bc, zigZag);
 }
@@ -388,7 +384,7 @@ function decodeIntSafe(bc) {
   return result;
 }
 function encodeIntSafe(bc, x) {
-  (0, import_assert3.default)(Number.isSafeInteger(x), TOO_LARGE_NUMBER2);
+  (0, import_assert3.ok)(Number.isSafeInteger(x), TOO_LARGE_NUMBER2);
   const sign = x < 0 ? 1 : 0;
   if (x < 0) {
     x = -(x + 1);
@@ -407,7 +403,7 @@ function decodeU8(bc) {
   return bc.view.getUint8(bc.offset++);
 }
 function encodeU8(bc, x) {
-  (0, import_assert3.default)(isU8(x), TOO_LARGE_NUMBER2);
+  (0, import_assert3.ok)(isU8(x), TOO_LARGE_NUMBER2);
   bc.reserve(1);
   bc.view.setUint8(bc.offset++, x);
 }
@@ -418,7 +414,7 @@ function decodeU16(bc) {
   return result;
 }
 function encodeU16(bc, x) {
-  (0, import_assert3.default)(isU16(x), TOO_LARGE_NUMBER2);
+  (0, import_assert3.ok)(isU16(x), TOO_LARGE_NUMBER2);
   bc.reserve(2);
   bc.view.setUint16(bc.offset, x, true);
   bc.offset += 2;
@@ -430,7 +426,7 @@ function decodeU32(bc) {
   return result;
 }
 function encodeU32(bc, x) {
-  (0, import_assert3.default)(isU32(x), TOO_LARGE_NUMBER2);
+  (0, import_assert3.ok)(isU32(x), TOO_LARGE_NUMBER2);
   bc.reserve(4);
   bc.view.setUint32(bc.offset, x, true);
   bc.offset += 4;
@@ -442,7 +438,7 @@ function decodeU64(bc) {
   return result;
 }
 function encodeU64(bc, x) {
-  (0, import_assert3.default)(isU64(x), TOO_LARGE_NUMBER2);
+  (0, import_assert3.ok)(isU64(x), TOO_LARGE_NUMBER2);
   bc.reserve(8);
   bc.view.setBigUint64(bc.offset, x, true);
   bc.offset += 8;
@@ -456,7 +452,7 @@ function decodeU64Safe(bc) {
   return result;
 }
 function encodeU64Safe(bc, x) {
-  (0, import_assert3.default)(isSafeU64(x), TOO_LARGE_NUMBER2);
+  (0, import_assert3.ok)(isSafeU64(x), TOO_LARGE_NUMBER2);
   encodeU32(bc, x >>> 0);
   encodeU32(bc, x / 4294967296 >>> 0);
 }
@@ -487,7 +483,7 @@ function decodeUint(bc) {
   return BigInt(low) + (BigInt(height) << BigInt(7 * 7));
 }
 function encodeUint(bc, x) {
-  (0, import_assert3.default)(isU64(x), TOO_LARGE_NUMBER2);
+  (0, import_assert3.ok)(isU64(x), TOO_LARGE_NUMBER2);
   let tmp = Number(BigInt.asUintN(7 * 7, x));
   let rest = Number(x >> BigInt(7 * 7));
   let byteCount = 0;
@@ -525,7 +521,7 @@ function decodeUintSafe(bc) {
   return result;
 }
 function encodeUintSafe(bc, x) {
-  (0, import_assert3.default)(isSafeU64(x), TOO_LARGE_NUMBER2);
+  (0, import_assert3.ok)(isSafeU64(x), TOO_LARGE_NUMBER2);
   while (x >= 128) {
     encodeU8(bc, 128 | x & 127);
     x = Math.floor(x / 128);
@@ -551,7 +547,7 @@ function decodeU8FixedArray(bc, len) {
   return bc.read(len).slice();
 }
 function encodeU8FixedArray(bc, x, len) {
-  (0, import_assert4.default)(x.length === len);
+  (0, import_assert4.ok)(x.length === len);
   bc.write(x);
 }
 
@@ -570,7 +566,7 @@ function encodeFixedData(bc, x, len) {
 }
 
 // src/codec/float-array.ts
-var import_assert5 = __toESM(require("assert"), 1);
+var import_assert5 = require("assert");
 
 // src/util/util.ts
 var IS_LITTLE_ENDIAN_PLATFORM = new DataView(Uint16Array.of(1).buffer).getUint8(0) === 1;
@@ -595,12 +591,12 @@ function decodeF32FixedArrayBE(bc, len) {
 }
 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);
+  (0, import_assert5.ok)(x.length === len);
+  (0, import_assert5.ok)(!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);
+  (0, import_assert5.ok)(val.length === len);
   bc.reserve(val.length * 4);
   for (let i = 0; i < val.length; i++)
     encodeF32(bc, val[i]);
@@ -632,12 +628,12 @@ function decodeF64FixedArrayBE(bc, len) {
 }
 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);
+  (0, import_assert5.ok)(x.length === len);
+  (0, import_assert5.ok)(!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);
+  (0, import_assert5.ok)(x.length === len);
   bc.reserve(x.length * 8);
   for (let i = 0; i < x.length; i++)
     encodeF64(bc, x[i]);
@@ -653,7 +649,7 @@ function encodeF64Array(bc, x) {
 }
 
 // src/codec/i16-array.ts
-var import_assert6 = __toESM(require("assert"), 1);
+var import_assert6 = require("assert");
 var I16_BYTE_COUNT = 2;
 var decodeI16FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? decodeI16FixedArrayLE : decodeI16FixedArrayBE;
 function decodeI16Array(bc) {
@@ -678,18 +674,18 @@ function encodeI16Array(bc, x) {
   }
 }
 function encodeI16FixedArrayLE(bc, x, len) {
-  (0, import_assert6.default)(x.length === len);
+  (0, import_assert6.ok)(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);
+  (0, import_assert6.ok)(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 import_assert7 = require("assert");
 var I32_BYTE_COUNT = 4;
 var decodeI32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? decodeI32FixedArrayLE : decodeI32FixedArrayBE;
 function decodeI32Array(bc) {
@@ -714,18 +710,18 @@ function encodeI32Array(bc, x) {
   }
 }
 function encodeI32FixedArrayLE(bc, x, len) {
-  (0, import_assert7.default)(x.length === len);
+  (0, import_assert7.ok)(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);
+  (0, import_assert7.ok)(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 import_assert8 = require("assert");
 var I64_BYTE_COUNT = 8;
 var decodeI64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? decodeI64FixedArrayLE : decodeI64FixedArrayBE;
 function decodeI64Array(bc) {
@@ -750,11 +746,11 @@ function encodeI64Array(bc, x) {
   }
 }
 function encodeI64FixedArrayLE(bc, x, len) {
-  (0, import_assert8.default)(x.length === len);
+  (0, import_assert8.ok)(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);
+  (0, import_assert8.ok)(x.length === len);
   bc.reserve(x.length * I64_BYTE_COUNT);
   for (let i = 0; i < x.length; i++)
     encodeI64(bc, x[i]);
@@ -873,20 +869,17 @@ function encodeUtf8Js(bc, s) {
 }
 function utf8ByteLength(s) {
   const sLen = s.length;
-  let result = 0;
-  let i = 0;
-  while (i < sLen) {
+  let result = sLen;
+  for (let i = 0; i < sLen; i++) {
     const codePoint = s.codePointAt(i);
-    i++;
-    if (codePoint < 128) {
+    if (codePoint >= 128) {
       result++;
-    } else if (codePoint < 2048) {
-      result += 2;
-    } else if (codePoint < 65536) {
-      result += 3;
-    } else {
-      result += 4;
-      i++;
+      if (codePoint >= 2048) {
+        result++;
+        if (codePoint >= 65536) {
+          i++;
+        }
+      }
     }
   }
   return result;
@@ -895,7 +888,7 @@ 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 import_assert9 = require("assert");
 var U16_BYTE_COUNT = 2;
 var decodeU16FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? decodeU16FixedArrayLE : decodeU16FixedArrayBE;
 function decodeU16Array(bc) {
@@ -920,18 +913,18 @@ function encodeU16Array(bc, x) {
   }
 }
 function encodeU16FixedArrayLE(bc, x, len) {
-  (0, import_assert9.default)(x.length === len);
+  (0, import_assert9.ok)(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);
+  (0, import_assert9.ok)(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 import_assert10 = require("assert");
 var U32_BYTE_COUNT = 4;
 var decodeU32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? decodeU32FixedArrayLE : decodeU32FixedArrayBE;
 function decodeU32Array(bc) {
@@ -956,18 +949,18 @@ function encodeU32Array(bc, x) {
   }
 }
 function encodeU32FixedArrayLE(bc, x, len) {
-  (0, import_assert10.default)(x.length === len);
+  (0, import_assert10.ok)(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);
+  (0, import_assert10.ok)(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 import_assert11 = require("assert");
 var U64_BYTE_COUNT = 8;
 var decodeU64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? decodeU64FixedArrayLE : decodeU64FixedArrayBE;
 function decodeU64Array(bc) {
@@ -992,11 +985,11 @@ function encodeU64Array(bc, x) {
   }
 }
 function encodeU64FixedArrayLE(bc, x, len) {
-  (0, import_assert11.default)(x.length === len);
+  (0, import_assert11.ok)(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);
+  (0, import_assert11.ok)(x.length === len);
   bc.reserve(x.length * U64_BYTE_COUNT);
   for (let i = 0; i < x.length; i++)
     encodeU64(bc, x[i]);
@@ -1109,4 +1102,3 @@ module.exports = __toCommonJS(src_exports);
   encodeUintSafe,
   encodeVoid
 });
-//# sourceMappingURL=index.cjs.map