@bare-ts/lib 0.2.0 → 0.3.0

package/dist/codec/float-array.js

@@ -1,6 +1,4 @@
 // src/codec/float-array.ts
-import { ok as assert } from "assert";
-import { BareError } from "../core/index.js";
 import { IS_LITTLE_ENDIAN_PLATFORM } from "../util/util.js";
 import { readFixedData } from "./data.js";
 import {
@@ -12,14 +10,10 @@ import {
   writeUintSafe
 } from "./primitive.js";
 import { writeU8FixedArray } from "./u8-array.js";
-var NAN_NOT_ALLOWED = "NaN is not allowed";
 var readF32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readF32FixedArrayLE : readF32FixedArrayBE;
 function readF32FixedArrayLE(bc, len) {
   const byteLen = len * 4;
   const result = new Float32Array(readFixedData(bc, byteLen));
-  if (result.some(Number.isNaN)) {
-    throw new BareError(bc.offset, NAN_NOT_ALLOWED);
-  }
   return result;
 }
 function readF32FixedArrayBE(bc, len) {
@@ -31,7 +25,6 @@ function readF32FixedArrayBE(bc, len) {
 }
 var writeF32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeF32FixedArrayLE : writeF32FixedArrayBE;
 function writeF32FixedArrayLE(bc, x) {
-  assert(!x.every(Number.isNaN), NAN_NOT_ALLOWED);
   writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
 }
 function writeF32FixedArrayBE(bc, val) {
@@ -52,9 +45,6 @@ var readF64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readF64FixedArrayLE : readF6
 function readF64FixedArrayLE(bc, len) {
   const byteLen = len * 8;
   const result = new Float64Array(readFixedData(bc, byteLen));
-  if (result.some(Number.isNaN)) {
-    throw new BareError(bc.offset, NAN_NOT_ALLOWED);
-  }
   return result;
 }
 function readF64FixedArrayBE(bc, len) {
@@ -66,7 +56,6 @@ function readF64FixedArrayBE(bc, len) {
 }
 var writeF64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeF64FixedArrayLE : writeF64FixedArrayBE;
 function writeF64FixedArrayLE(bc, x) {
-  assert(!x.every(Number.isNaN), NAN_NOT_ALLOWED);
   writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
 }
 function writeF64FixedArrayBE(bc, x) {

package/dist/codec/i16-array.js

@@ -1,9 +1,9 @@
 // src/codec/i16-array.ts
+import { I16_BYTE_COUNT } from "../util/constants.js";
 import { IS_LITTLE_ENDIAN_PLATFORM } from "../util/util.js";
 import { readFixedData } from "./data.js";
 import { readI16, readUintSafe, writeI16, writeUintSafe } from "./primitive.js";
 import { writeU8FixedArray } from "./u8-array.js";
-var I16_BYTE_COUNT = 2;
 var readI16FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readI16FixedArrayLE : readI16FixedArrayBE;
 function readI16Array(bc) {
   return readI16FixedArray(bc, readUintSafe(bc));

package/dist/codec/i32-array.js

@@ -1,9 +1,9 @@
 // src/codec/i32-array.ts
+import { I32_BYTE_COUNT } from "../util/constants.js";
 import { IS_LITTLE_ENDIAN_PLATFORM } from "../util/util.js";
 import { readFixedData } from "./data.js";
 import { readI32, readUintSafe, writeI32, writeUintSafe } from "./primitive.js";
 import { writeU8FixedArray } from "./u8-array.js";
-var I32_BYTE_COUNT = 4;
 var readI32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readI32FixedArrayLE : readI32FixedArrayBE;
 function readI32Array(bc) {
   return readI32FixedArray(bc, readUintSafe(bc));

package/dist/codec/i64-array.js

@@ -1,9 +1,9 @@
 // src/codec/i64-array.ts
+import { I64_BYTE_COUNT } from "../util/constants.js";
 import { IS_LITTLE_ENDIAN_PLATFORM } from "../util/util.js";
 import { readFixedData } from "./data.js";
 import { readI64, readUintSafe, writeI64, writeUintSafe } from "./primitive.js";
 import { writeU8FixedArray } from "./u8-array.js";
-var I64_BYTE_COUNT = 8;
 var readI64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readI64FixedArrayLE : readI64FixedArrayBE;
 function readI64Array(bc) {
   return readI64FixedArray(bc, readUintSafe(bc));

package/dist/codec/primitive.d.ts

@@ -33,5 +33,3 @@ export declare function readUint(bc: ByteCursor): bigint;
 export declare function writeUint(bc: ByteCursor, x: bigint): void;
 export declare function readUintSafe(bc: ByteCursor): number;
 export declare function writeUintSafe(bc: ByteCursor, x: number): void;
-export declare function readVoid(_dc: ByteCursor): undefined;
-export declare function writeVoid(_dc: ByteCursor, _x: undefined): void;

package/dist/codec/primitive.js

@@ -1,6 +1,13 @@
 // src/codec/primitive.ts
-import { ok as assert } from "assert";
+import { assert } from "../util/assert.js";
 import { BareError } from "../core/index.js";
+import {
+  INT_SAFE_MAX_BYTE_COUNT,
+  NON_CANONICAL_REPRESENTATION,
+  TOO_LARGE_NUMBER,
+  UINT_MAX_BYTE_COUNT,
+  UINT_SAFE_MAX_BYTE_COUNT
+} from "../util/constants.js";
 import {
   isI16,
   isI32,
@@ -12,9 +19,6 @@ import {
   isU64,
   isU8
 } from "../util/validator.js";
-var NAN_NOT_ALLOWED = "NaN is not allowed";
-var NON_CANONICAL_REPRESENTATION = "must be canonical";
-var TOO_LARGE_NUMBER = "too large number";
 function readBool(bc) {
   const val = readU8(bc);
   if (val > 1) {
@@ -29,30 +33,22 @@ function writeBool(bc, x) {
 function readF32(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 writeF32(bc, x) {
-  assert(!Number.isNaN(x), NAN_NOT_ALLOWED);
   bc.reserve(4);
   bc.view.setFloat32(bc.offset, x, true);
-  assert(Math.abs(bc.view.getFloat32(bc.offset, true) - x) <= Number.EPSILON, TOO_LARGE_NUMBER);
+  assert(Number.isNaN(x) || Math.abs(bc.view.getFloat32(bc.offset, true) - x) <= Number.EPSILON, TOO_LARGE_NUMBER);
   bc.offset += 4;
 }
 function readF64(bc) {
   bc.check(8);
   const result = bc.view.getFloat64(bc.offset, true);
-  if (Number.isNaN(result)) {
-    throw new BareError(bc.offset, NAN_NOT_ALLOWED);
-  }
   bc.offset += 8;
   return result;
 }
 function writeF64(bc, x) {
-  assert(!Number.isNaN(x), NAN_NOT_ALLOWED);
   bc.reserve(8);
   bc.view.setFloat64(bc.offset, x, true);
   bc.offset += 8;
@@ -132,7 +128,6 @@ function writeInt(bc, x) {
   const zigZag = x >> BigInt(63) ^ x << BigInt(1);
   writeUint(bc, zigZag);
 }
-var INT_SAFE_MAX_BYTE_COUNT = 8;
 function readIntSafe(bc) {
   const firstByte = readU8(bc);
   let result = (firstByte & 127) >> 1;
@@ -234,7 +229,6 @@ function writeU64Safe(bc, x) {
   writeU32(bc, x >>> 0);
   writeU32(bc, x / 4294967296 >>> 0);
 }
-var UINT_MAX_BYTE_COUNT = 10;
 function readUint(bc) {
   let low = readU8(bc);
   if (low >= 128) {
@@ -280,7 +274,6 @@ function writeUint(bc, x) {
   }
   writeU8(bc, tmp);
 }
-var UINT_SAFE_MAX_BYTE_COUNT = 8;
 function readUintSafe(bc) {
   let result = readU8(bc);
   if (result >= 128) {
@@ -313,11 +306,6 @@ function writeUintSafe(bc, x) {
   }
   writeU8(bc, x);
 }
-function readVoid(_dc) {
-  return void 0;
-}
-function writeVoid(_dc, _x) {
-}
 export {
   readBool,
   readF32,
@@ -336,7 +324,6 @@ export {
   readU8,
   readUint,
   readUintSafe,
-  readVoid,
   writeBool,
   writeF32,
   writeF64,
@@ -353,7 +340,6 @@ export {
   writeU64Safe,
   writeU8,
   writeUint,
-  writeUintSafe,
-  writeVoid
+  writeUintSafe
 };
 //# sourceMappingURL=primitive.js.map

package/dist/codec/string.js

@@ -1,8 +1,8 @@
 // src/codec/string.ts
 import { BareError } from "../core/bare-error.js";
+import { INVALID_UTF8_STRING } from "../util/constants.js";
 import { readUintSafe, writeUintSafe } from "./primitive.js";
 import { writeU8FixedArray } from "./u8-array.js";
-var INVALID_UTF8_STRING = "invalid UTF-8 string";
 function readString(bc) {
   return readFixedString(bc, readUintSafe(bc));
 }
@@ -115,8 +115,8 @@ 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();
 export {
   readFixedString,
   readString,

package/dist/codec/u16-array.js

@@ -1,9 +1,9 @@
 // src/codec/u16-array.ts
+import { U16_BYTE_COUNT } from "../util/constants.js";
 import { IS_LITTLE_ENDIAN_PLATFORM } from "../util/util.js";
 import { readFixedData } from "./data.js";
 import { readU16, readUintSafe, writeU16, writeUintSafe } from "./primitive.js";
 import { writeU8FixedArray } from "./u8-array.js";
-var U16_BYTE_COUNT = 2;
 var readU16FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readU16FixedArrayLE : readU16FixedArrayBE;
 function readU16Array(bc) {
   return readU16FixedArray(bc, readUintSafe(bc));

package/dist/codec/u32-array.js

@@ -1,9 +1,9 @@
 // src/codec/u32-array.ts
+import { U32_BYTE_COUNT } from "../util/constants.js";
 import { IS_LITTLE_ENDIAN_PLATFORM } from "../util/util.js";
 import { readFixedData } from "./data.js";
 import { readU32, readUintSafe, writeU32, writeUintSafe } from "./primitive.js";
 import { writeU8FixedArray } from "./u8-array.js";
-var U32_BYTE_COUNT = 4;
 var readU32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readU32FixedArrayLE : readU32FixedArrayBE;
 function readU32Array(bc) {
   return readU32FixedArray(bc, readUintSafe(bc));

package/dist/codec/u64-array.js

@@ -1,9 +1,9 @@
 // src/codec/u64-array.ts
+import { U64_BYTE_COUNT } from "../util/constants.js";
 import { IS_LITTLE_ENDIAN_PLATFORM } from "../util/util.js";
 import { readFixedData } from "./data.js";
 import { readU64, readUintSafe, writeU64, writeUintSafe } from "./primitive.js";
 import { writeU8FixedArray } from "./u8-array.js";
-var U64_BYTE_COUNT = 8;
 var readU64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readU64FixedArrayLE : readU64FixedArrayBE;
 function readU64Array(bc) {
   return readU64FixedArray(bc, readUintSafe(bc));

package/dist/core/byte-cursor.js

@@ -1,6 +1,6 @@
 // src/core/byte-cursor.ts
+import { TOO_LARGE_BUFFER } from "../util/constants.js";
 import { BareError } from "./bare-error.js";
-var TOO_LARGE_BUFFER = "too large buffer";
 var ByteCursor = class {
   constructor(bytes, config) {
     if (bytes.length > config.maxBufferLength) {

package/dist/core/config.d.ts

@@ -4,4 +4,9 @@ export interface Config {
     readonly textDecoderThreshold: number;
     readonly textEncoderThreshold: number;
 }
-export declare function Config(part: Partial<Config>): Config;
+export declare function Config({ initialBufferLength, maxBufferLength, textDecoderThreshold, textEncoderThreshold, }: {
+    initialBufferLength?: number | undefined;
+    maxBufferLength?: number | undefined;
+    textDecoderThreshold?: number | undefined;
+    textEncoderThreshold?: number | undefined;
+}): Config;

package/dist/core/config.js

@@ -1,18 +1,19 @@
 // src/core/config.ts
-import { ok as assert } from "assert";
+import { assert } from "../util/assert.js";
+import { TOO_LARGE_NUMBER } from "../util/constants.js";
 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({
+function Config({
+  initialBufferLength = 1024,
+  maxBufferLength = 1024 * 1024 * 32,
+  textDecoderThreshold = 256,
+  textEncoderThreshold = 256
+}) {
+  const config = {
     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);

package/dist/index.cjs

@@ -70,7 +70,6 @@ __export(src_exports, {
   readU8FixedArray: () => readU8FixedArray,
   readUint: () => readUint,
   readUintSafe: () => readUintSafe,
-  readVoid: () => readVoid,
   writeBool: () => writeBool,
   writeData: () => writeData,
   writeF32: () => writeF32,
@@ -113,12 +112,25 @@ __export(src_exports, {
   writeU8ClampedFixedArray: () => writeU8ClampedFixedArray,
   writeU8FixedArray: () => writeU8FixedArray,
   writeUint: () => writeUint,
-  writeUintSafe: () => writeUintSafe,
-  writeVoid: () => writeVoid
+  writeUintSafe: () => writeUintSafe
 });
 
-// src/codec/primitive.ts
-var import_assert2 = require("assert");
+// src/util/assert.ts
+var AssertionError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AssertionError";
+  }
+};
+function assert(test, message) {
+  if (!test) {
+    const e = new AssertionError(message);
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(e, assert);
+    }
+    throw e;
+  }
+}
 
 // src/core/bare-error.ts
 var BareError = class extends Error {
@@ -131,8 +143,20 @@ var BareError = class extends Error {
   }
 };
 
-// src/core/config.ts
-var import_assert = require("assert");
+// src/util/constants.ts
+var I16_BYTE_COUNT = 2;
+var I32_BYTE_COUNT = 4;
+var I64_BYTE_COUNT = 8;
+var U16_BYTE_COUNT = 2;
+var U32_BYTE_COUNT = 4;
+var U64_BYTE_COUNT = 8;
+var INT_SAFE_MAX_BYTE_COUNT = 8;
+var UINT_MAX_BYTE_COUNT = 10;
+var UINT_SAFE_MAX_BYTE_COUNT = 8;
+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";
 
 // src/util/validator.ts
 function isI8(val) {
@@ -164,28 +188,27 @@ function isU64(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({
+function Config({
+  initialBufferLength = 1024,
+  maxBufferLength = 1024 * 1024 * 32,
+  textDecoderThreshold = 256,
+  textEncoderThreshold = 256
+}) {
+  const config = {
     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");
+  };
+  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;
 }
 
 // src/core/byte-cursor.ts
-var TOO_LARGE_BUFFER = "too large buffer";
 var ByteCursor = class {
   constructor(bytes, config) {
     if (bytes.length > config.maxBufferLength) {
@@ -223,9 +246,6 @@ var ByteCursor = class {
 };
 
 // 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) {
@@ -240,30 +260,22 @@ function writeBool(bc, x) {
 function readF32(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 writeF32(bc, x) {
-  (0, import_assert2.ok)(!Number.isNaN(x), NAN_NOT_ALLOWED);
   bc.reserve(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);
+  assert(Number.isNaN(x) || Math.abs(bc.view.getFloat32(bc.offset, true) - x) <= Number.EPSILON, TOO_LARGE_NUMBER);
   bc.offset += 4;
 }
 function readF64(bc) {
   bc.check(8);
   const result = bc.view.getFloat64(bc.offset, true);
-  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);
   bc.view.setFloat64(bc.offset, x, true);
   bc.offset += 8;
@@ -273,7 +285,7 @@ function readI8(bc) {
   return bc.view.getInt8(bc.offset++);
 }
 function writeI8(bc, x) {
-  (0, import_assert2.ok)(isI8(x), TOO_LARGE_NUMBER2);
+  assert(isI8(x), TOO_LARGE_NUMBER);
   bc.reserve(1);
   bc.view.setInt8(bc.offset++, x);
 }
@@ -284,7 +296,7 @@ function readI16(bc) {
   return result;
 }
 function writeI16(bc, x) {
-  (0, import_assert2.ok)(isI16(x), TOO_LARGE_NUMBER2);
+  assert(isI16(x), TOO_LARGE_NUMBER);
   bc.reserve(2);
   bc.view.setInt16(bc.offset, x, true);
   bc.offset += 2;
@@ -296,7 +308,7 @@ function readI32(bc) {
   return result;
 }
 function writeI32(bc, x) {
-  (0, import_assert2.ok)(isI32(x), TOO_LARGE_NUMBER2);
+  assert(isI32(x), TOO_LARGE_NUMBER);
   bc.reserve(4);
   bc.view.setInt32(bc.offset, x, true);
   bc.offset += 4;
@@ -308,7 +320,7 @@ function readI64(bc) {
   return result;
 }
 function writeI64(bc, x) {
-  (0, import_assert2.ok)(isI64(x), TOO_LARGE_NUMBER2);
+  assert(isI64(x), TOO_LARGE_NUMBER);
   bc.reserve(8);
   bc.view.setBigInt64(bc.offset, x, true);
   bc.offset += 8;
@@ -317,12 +329,12 @@ function readI64Safe(bc) {
   const result = readU32(bc) + readI32(bc) * 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);
+  assert(Number.isSafeInteger(x), TOO_LARGE_NUMBER);
   const lowest32 = x >>> 0;
   writeU32(bc, lowest32);
   let highest32 = x / 4294967296 | 0;
@@ -339,11 +351,10 @@ function readInt(bc) {
   return zigZag >> BigInt(1) ^ -(zigZag & BigInt(1));
 }
 function writeInt(bc, x) {
-  (0, import_assert2.ok)(isI64(x), TOO_LARGE_NUMBER2);
+  assert(isI64(x), TOO_LARGE_NUMBER);
   const zigZag = x >> BigInt(63) ^ x << BigInt(1);
   writeUint(bc, zigZag);
 }
-var INT_SAFE_MAX_BYTE_COUNT = 8;
 function readIntSafe(bc) {
   const firstByte = readU8(bc);
   let result = (firstByte & 127) >> 1;
@@ -363,7 +374,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,7 +384,7 @@ function readIntSafe(bc) {
   return result;
 }
 function writeIntSafe(bc, x) {
-  (0, import_assert2.ok)(Number.isSafeInteger(x), TOO_LARGE_NUMBER2);
+  assert(Number.isSafeInteger(x), TOO_LARGE_NUMBER);
   const sign = x < 0 ? 1 : 0;
   if (x < 0) {
     x = -(x + 1);
@@ -392,7 +403,7 @@ function readU8(bc) {
   return bc.bytes[bc.offset++];
 }
 function writeU8(bc, x) {
-  (0, import_assert2.ok)(isU8(x), TOO_LARGE_NUMBER2);
+  assert(isU8(x), TOO_LARGE_NUMBER);
   bc.reserve(1);
   bc.bytes[bc.offset++] = x;
 }
@@ -403,7 +414,7 @@ function readU16(bc) {
   return result;
 }
 function writeU16(bc, x) {
-  (0, import_assert2.ok)(isU16(x), TOO_LARGE_NUMBER2);
+  assert(isU16(x), TOO_LARGE_NUMBER);
   bc.reserve(2);
   bc.view.setUint16(bc.offset, x, true);
   bc.offset += 2;
@@ -415,7 +426,7 @@ function readU32(bc) {
   return result;
 }
 function writeU32(bc, x) {
-  (0, import_assert2.ok)(isU32(x), TOO_LARGE_NUMBER2);
+  assert(isU32(x), TOO_LARGE_NUMBER);
   bc.reserve(4);
   bc.view.setUint32(bc.offset, x, true);
   bc.offset += 4;
@@ -427,7 +438,7 @@ function readU64(bc) {
   return result;
 }
 function writeU64(bc, x) {
-  (0, import_assert2.ok)(isU64(x), TOO_LARGE_NUMBER2);
+  assert(isU64(x), TOO_LARGE_NUMBER);
   bc.reserve(8);
   bc.view.setBigUint64(bc.offset, x, true);
   bc.offset += 8;
@@ -436,16 +447,15 @@ function readU64Safe(bc) {
   const result = readU32(bc) + readU32(bc) * 4294967296;
   if (!isSafeU64(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);
+  assert(isSafeU64(x), TOO_LARGE_NUMBER);
   writeU32(bc, x >>> 0);
   writeU32(bc, x / 4294967296 >>> 0);
 }
-var UINT_MAX_BYTE_COUNT = 10;
 function readUint(bc) {
   let low = readU8(bc);
   if (low >= 128) {
@@ -476,7 +486,7 @@ function readUint(bc) {
   return BigInt(low);
 }
 function writeUint(bc, x) {
-  (0, import_assert2.ok)(isU64(x), TOO_LARGE_NUMBER2);
+  assert(isU64(x), TOO_LARGE_NUMBER);
   let tmp = Number(BigInt.asUintN(7 * 7, x));
   let rest = Number(x >> BigInt(7 * 7));
   let byteCount = 0;
@@ -491,7 +501,6 @@ function writeUint(bc, x) {
   }
   writeU8(bc, tmp);
 }
-var UINT_SAFE_MAX_BYTE_COUNT = 8;
 function readUintSafe(bc) {
   let result = readU8(bc);
   if (result >= 128) {
@@ -511,24 +520,19 @@ function readUintSafe(bc) {
     }
     if (byteCount === UINT_SAFE_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);
+  assert(isSafeU64(x), TOO_LARGE_NUMBER);
   while (x >= 128) {
     writeU8(bc, 128 | x & 127);
     x = Math.floor(x / 128);
   }
   writeU8(bc, x);
 }
-function readVoid(_dc) {
-  return void 0;
-}
-function writeVoid(_dc, _x) {
-}
 
 // src/codec/u8-array.ts
 function readU8Array(bc) {
@@ -564,21 +568,14 @@ function writeFixedData(bc, x) {
   writeU8FixedArray(bc, new Uint8Array(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;
+var IS_LITTLE_ENDIAN_PLATFORM = /* @__PURE__ */ 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) {
   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) {
@@ -590,7 +587,6 @@ function readF32FixedArrayBE(bc, len) {
 }
 var writeF32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeF32FixedArrayLE : writeF32FixedArrayBE;
 function writeF32FixedArrayLE(bc, x) {
-  (0, import_assert3.ok)(!x.every(Number.isNaN), NAN_NOT_ALLOWED2);
   writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
 }
 function writeF32FixedArrayBE(bc, val) {
@@ -611,9 +607,6 @@ var readF64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readF64FixedArrayLE : readF6
 function readF64FixedArrayLE(bc, 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) {
@@ -625,7 +618,6 @@ function readF64FixedArrayBE(bc, len) {
 }
 var writeF64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeF64FixedArrayLE : writeF64FixedArrayBE;
 function writeF64FixedArrayLE(bc, x) {
-  (0, import_assert3.ok)(!x.every(Number.isNaN), NAN_NOT_ALLOWED2);
   writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
 }
 function writeF64FixedArrayBE(bc, x) {
@@ -644,7 +636,6 @@ function writeF64Array(bc, x) {
 }
 
 // src/codec/i16-array.ts
-var I16_BYTE_COUNT = 2;
 var readI16FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readI16FixedArrayLE : readI16FixedArrayBE;
 function readI16Array(bc) {
   return readI16FixedArray(bc, readUintSafe(bc));
@@ -677,7 +668,6 @@ function writeI16FixedArrayBE(bc, x) {
 }
 
 // src/codec/i32-array.ts
-var I32_BYTE_COUNT = 4;
 var readI32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readI32FixedArrayLE : readI32FixedArrayBE;
 function readI32Array(bc) {
   return readI32FixedArray(bc, readUintSafe(bc));
@@ -710,7 +700,6 @@ function writeI32FixedArrayBE(bc, x) {
 }
 
 // src/codec/i64-array.ts
-var I64_BYTE_COUNT = 8;
 var readI64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readI64FixedArrayLE : readI64FixedArrayBE;
 function readI64Array(bc) {
   return readI64FixedArray(bc, readUintSafe(bc));
@@ -758,7 +747,6 @@ function writeI8FixedArray(bc, x) {
 }
 
 // src/codec/string.ts
-var INVALID_UTF8_STRING = "invalid UTF-8 string";
 function readString(bc) {
   return readFixedString(bc, readUintSafe(bc));
 }
@@ -871,11 +859,10 @@ 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;
 function readU16Array(bc) {
   return readU16FixedArray(bc, readUintSafe(bc));
@@ -908,7 +895,6 @@ function writeU16FixedArrayBE(bc, x) {
 }
 
 // src/codec/u32-array.ts
-var U32_BYTE_COUNT = 4;
 var readU32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readU32FixedArrayLE : readU32FixedArrayBE;
 function readU32Array(bc) {
   return readU32FixedArray(bc, readUintSafe(bc));
@@ -941,7 +927,6 @@ function writeU32FixedArrayBE(bc, x) {
 }
 
 // src/codec/u64-array.ts
-var U64_BYTE_COUNT = 8;
 var readU64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readU64FixedArrayLE : readU64FixedArrayBE;
 function readU64Array(bc) {
   return readU64FixedArray(bc, readUintSafe(bc));
@@ -1036,7 +1021,6 @@ module.exports = __toCommonJS(src_exports);
   readU8FixedArray,
   readUint,
   readUintSafe,
-  readVoid,
   writeBool,
   writeData,
   writeF32,
@@ -1079,6 +1063,5 @@ module.exports = __toCommonJS(src_exports);
   writeU8ClampedFixedArray,
   writeU8FixedArray,
   writeUint,
-  writeUintSafe,
-  writeVoid
+  writeUintSafe
 });

package/dist/util/assert.d.ts

@@ -2,5 +2,9 @@ export declare class AssertionError extends Error {
     readonly name: "AssertionError";
     constructor(message: string);
 }
-export default function assert(test: boolean, message: Error | string): asserts test;
-export declare const ok: typeof assert;
+export declare function assert(test: boolean, message: string): asserts test;
+declare const Error: V8ErrorConstructor;
+interface V8ErrorConstructor extends ErrorConstructor {
+    readonly captureStackTrace?: (e: Error, f: unknown) => void;
+}
+export {};

package/dist/util/assert.js

@@ -7,9 +7,6 @@ var AssertionError = class extends Error {
 };
 function assert(test, message) {
   if (!test) {
-    if (message instanceof Error) {
-      throw message;
-    }
     const e = new AssertionError(message);
     if (Error.captureStackTrace) {
       Error.captureStackTrace(e, assert);
@@ -17,10 +14,8 @@ function assert(test, message) {
     throw e;
   }
 }
-var ok = assert;
 export {
   AssertionError,
-  assert as default,
-  ok
+  assert
 };
 //# sourceMappingURL=assert.js.map

package/dist/util/constants.d.ts

@@ -0,0 +1,13 @@
+export declare const I16_BYTE_COUNT = 2;
+export declare const I32_BYTE_COUNT = 4;
+export declare const I64_BYTE_COUNT = 8;
+export declare const U16_BYTE_COUNT = 2;
+export declare const U32_BYTE_COUNT = 4;
+export declare const U64_BYTE_COUNT = 8;
+export declare const INT_SAFE_MAX_BYTE_COUNT = 8;
+export declare const UINT_MAX_BYTE_COUNT = 10;
+export declare const UINT_SAFE_MAX_BYTE_COUNT = 8;
+export declare const INVALID_UTF8_STRING = "invalid UTF-8 string";
+export declare const NON_CANONICAL_REPRESENTATION = "must be canonical";
+export declare const TOO_LARGE_BUFFER = "too large buffer";
+export declare const TOO_LARGE_NUMBER = "too large number";

package/dist/util/constants.js

@@ -0,0 +1,30 @@
+// src/util/constants.ts
+var I16_BYTE_COUNT = 2;
+var I32_BYTE_COUNT = 4;
+var I64_BYTE_COUNT = 8;
+var U16_BYTE_COUNT = 2;
+var U32_BYTE_COUNT = 4;
+var U64_BYTE_COUNT = 8;
+var INT_SAFE_MAX_BYTE_COUNT = 8;
+var UINT_MAX_BYTE_COUNT = 10;
+var UINT_SAFE_MAX_BYTE_COUNT = 8;
+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";
+export {
+  I16_BYTE_COUNT,
+  I32_BYTE_COUNT,
+  I64_BYTE_COUNT,
+  INT_SAFE_MAX_BYTE_COUNT,
+  INVALID_UTF8_STRING,
+  NON_CANONICAL_REPRESENTATION,
+  TOO_LARGE_BUFFER,
+  TOO_LARGE_NUMBER,
+  U16_BYTE_COUNT,
+  U32_BYTE_COUNT,
+  U64_BYTE_COUNT,
+  UINT_MAX_BYTE_COUNT,
+  UINT_SAFE_MAX_BYTE_COUNT
+};
+//# sourceMappingURL=constants.js.map

package/dist/util/util.js

@@ -1,5 +1,5 @@
 // src/util/util.ts
-var IS_LITTLE_ENDIAN_PLATFORM = new DataView(Uint16Array.of(1).buffer).getUint8(0) === 1;
+var IS_LITTLE_ENDIAN_PLATFORM = /* @__PURE__ */ new DataView(Uint16Array.of(1).buffer).getUint8(0) === 1;
 export {
   IS_LITTLE_ENDIAN_PLATFORM
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bare-ts/lib",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "TypeScript library for BARE, a compact and simple binary-serialization format",
   "keywords": [
     "bare",
@@ -28,12 +28,9 @@
   "module": "./dist/index.js",
   "es2015": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "browser": {
-    "assert": "./dist/util/assert.js"
-  },
   "exports": {
-    "import": "./dist/index.js",
-    "require": "./dist/index.cjs"
+    "require": "./dist/index.cjs",
+    "default": "./dist/index.js"
   },
   "sideEffects": false,
   "files": [
@@ -50,6 +47,7 @@
   "scripts": {
     "build": "sh ./scripts/build.sh",
     "clean": "rm -rf dist coverage",
+    "prepare": "validate-commit-msg",
     "prepublishOnly": "npm run clean && npm test",
     "test": "npm run build && tsc -b tests && oletus tests/**/*.test.js",
     "test:coverage": "c8 --reporter=lcovonly npm test"
@@ -61,7 +59,6 @@
     }
   ],
   "devDependencies": {
-    "@types/node": "^17.0.6",
     "esbuild": "~0.14.10",
     "oletus": "^3.2.0",
     "prettier": "~2.5.1",

package/dist/util/assert.cjs

@@ -1,55 +0,0 @@
-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 });
-  }
-  return target;
-};
-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/util/assert.ts
-var assert_exports = {};
-__export(assert_exports, {
-  AssertionError: () => AssertionError,
-  default: () => assert,
-  ok: () => ok
-});
-var AssertionError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "AssertionError";
-  }
-};
-function assert(test, message) {
-  if (!test) {
-    if (message instanceof Error) {
-      throw message;
-    }
-    const e = new AssertionError(message);
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(e, assert);
-    }
-    throw e;
-  }
-}
-var ok = assert;
-module.exports = __toCommonJS(assert_exports);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  AssertionError,
-  ok
-});