@bare-ts/lib 0.3.0 → 0.5.0

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

@@ -1,8 +1,5 @@
-import type { ByteCursor } from "../core/index.js";
-export declare const readU16FixedArray: typeof readU16FixedArrayLE;
-export declare function readU16Array(bc: ByteCursor): Uint16Array;
-declare function readU16FixedArrayLE(bc: ByteCursor, len: number): Uint16Array;
-export declare const writeU16FixedArray: typeof writeU16FixedArrayLE;
+import { type ByteCursor } from "../core/byte-cursor.js";
+export declare const readU16FixedArray: (bc: ByteCursor, len: number) => Uint16Array<ArrayBuffer>;
+export declare function readU16Array(bc: ByteCursor): Uint16Array<ArrayBuffer>;
+export declare const writeU16FixedArray: (bc: ByteCursor, x: Uint16Array) => void;
 export declare function writeU16Array(bc: ByteCursor, x: Uint16Array): void;
-declare function writeU16FixedArrayLE(bc: ByteCursor, x: Uint16Array): void;
-export {};

package/dist/codec/u16-array.js

@@ -1,43 +1,51 @@
-// src/codec/u16-array.ts
-import { U16_BYTE_COUNT } from "../util/constants.js";
-import { IS_LITTLE_ENDIAN_PLATFORM } from "../util/util.js";
+"use strict";
+import { check, reserve } from "../core/byte-cursor.js";
+import { assert, DEV } from "../util/assert.js";
+import { IS_LITTLE_ENDIAN_PLATFORM } from "../util/constants.js";
+import { isU32 } from "../util/validator.js";
 import { readFixedData } from "./data.js";
-import { readU16, readUintSafe, writeU16, writeUintSafe } from "./primitive.js";
+import {
+  readU16,
+  readUintSafe32,
+  writeU16,
+  writeUintSafe32
+} from "./primitive.js";
 import { writeU8FixedArray } from "./u8-array.js";
-var readU16FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readU16FixedArrayLE : readU16FixedArrayBE;
-function readU16Array(bc) {
-  return readU16FixedArray(bc, readUintSafe(bc));
+export const readU16FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readU16FixedArrayLe : readU16FixedArrayBe;
+export function readU16Array(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;
-function writeU16Array(bc, x) {
-  writeUintSafe(bc, x.length);
-  if (x.length !== 0) {
+export const writeU16FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeU16FixedArrayLe : writeU16FixedArrayBe;
+export function writeU16Array(bc, x) {
+  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]);
+  }
 }
-export {
-  readU16Array,
-  readU16FixedArray,
-  writeU16Array,
-  writeU16FixedArray
-};
-//# sourceMappingURL=u16-array.js.map

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

@@ -1,8 +1,5 @@
-import type { ByteCursor } from "../core/index.js";
-export declare const readU32FixedArray: typeof readU32FixedArrayLE;
-export declare function readU32Array(bc: ByteCursor): Uint32Array;
-declare function readU32FixedArrayLE(bc: ByteCursor, len: number): Uint32Array;
-export declare const writeU32FixedArray: typeof writeU32FixedArrayLE;
+import { type ByteCursor } from "../core/byte-cursor.js";
+export declare const readU32FixedArray: (bc: ByteCursor, len: number) => Uint32Array<ArrayBuffer>;
+export declare function readU32Array(bc: ByteCursor): Uint32Array<ArrayBuffer>;
+export declare const writeU32FixedArray: (bc: ByteCursor, x: Uint32Array) => void;
 export declare function writeU32Array(bc: ByteCursor, x: Uint32Array): void;
-declare function writeU32FixedArrayLE(bc: ByteCursor, x: Uint32Array): void;
-export {};

package/dist/codec/u32-array.js

@@ -1,43 +1,51 @@
-// src/codec/u32-array.ts
-import { U32_BYTE_COUNT } from "../util/constants.js";
-import { IS_LITTLE_ENDIAN_PLATFORM } from "../util/util.js";
+"use strict";
+import { check, reserve } from "../core/byte-cursor.js";
+import { assert, DEV } from "../util/assert.js";
+import { IS_LITTLE_ENDIAN_PLATFORM } from "../util/constants.js";
+import { isU32 } from "../util/validator.js";
 import { readFixedData } from "./data.js";
-import { readU32, readUintSafe, writeU32, writeUintSafe } from "./primitive.js";
+import {
+  readU32,
+  readUintSafe32,
+  writeU32,
+  writeUintSafe32
+} from "./primitive.js";
 import { writeU8FixedArray } from "./u8-array.js";
-var readU32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readU32FixedArrayLE : readU32FixedArrayBE;
-function readU32Array(bc) {
-  return readU32FixedArray(bc, readUintSafe(bc));
+export const readU32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readU32FixedArrayLe : readU32FixedArrayBe;
+export function readU32Array(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;
-function writeU32Array(bc, x) {
-  writeUintSafe(bc, x.length);
-  if (x.length !== 0) {
+export const writeU32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeU32FixedArrayLe : writeU32FixedArrayBe;
+export function writeU32Array(bc, x) {
+  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]);
+  }
 }
-export {
-  readU32Array,
-  readU32FixedArray,
-  writeU32Array,
-  writeU32FixedArray
-};
-//# sourceMappingURL=u32-array.js.map

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

@@ -1,8 +1,5 @@
-import type { ByteCursor } from "../core/index.js";
-export declare const readU64FixedArray: typeof readU64FixedArrayLE;
-export declare function readU64Array(bc: ByteCursor): BigUint64Array;
-declare function readU64FixedArrayLE(bc: ByteCursor, len: number): BigUint64Array;
-export declare const writeU64FixedArray: typeof writeU64FixedArrayLE;
+import { type ByteCursor } from "../core/byte-cursor.js";
+export declare const readU64FixedArray: (bc: ByteCursor, len: number) => BigUint64Array<ArrayBuffer>;
+export declare function readU64Array(bc: ByteCursor): BigUint64Array<ArrayBuffer>;
+export declare const writeU64FixedArray: (bc: ByteCursor, x: BigUint64Array) => void;
 export declare function writeU64Array(bc: ByteCursor, x: BigUint64Array): void;
-declare function writeU64FixedArrayLE(bc: ByteCursor, x: BigUint64Array): void;
-export {};

package/dist/codec/u64-array.js

@@ -1,43 +1,51 @@
-// src/codec/u64-array.ts
-import { U64_BYTE_COUNT } from "../util/constants.js";
-import { IS_LITTLE_ENDIAN_PLATFORM } from "../util/util.js";
+"use strict";
+import { check, reserve } from "../core/byte-cursor.js";
+import { assert, DEV } from "../util/assert.js";
+import { IS_LITTLE_ENDIAN_PLATFORM } from "../util/constants.js";
+import { isU32 } from "../util/validator.js";
 import { readFixedData } from "./data.js";
-import { readU64, readUintSafe, writeU64, writeUintSafe } from "./primitive.js";
+import {
+  readU64,
+  readUintSafe32,
+  writeU64,
+  writeUintSafe32
+} from "./primitive.js";
 import { writeU8FixedArray } from "./u8-array.js";
-var readU64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readU64FixedArrayLE : readU64FixedArrayBE;
-function readU64Array(bc) {
-  return readU64FixedArray(bc, readUintSafe(bc));
+export const readU64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readU64FixedArrayLe : readU64FixedArrayBe;
+export function readU64Array(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;
-function writeU64Array(bc, x) {
-  writeUintSafe(bc, x.length);
-  if (x.length !== 0) {
+export const writeU64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeU64FixedArrayLe : writeU64FixedArrayBe;
+export function writeU64Array(bc, x) {
+  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]);
+  }
 }
-export {
-  readU64Array,
-  readU64FixedArray,
-  writeU64Array,
-  writeU64FixedArray
-};
-//# sourceMappingURL=u64-array.js.map

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

@@ -1,5 +1,11 @@
-import type { ByteCursor } from "../core/index.js";
-export declare function readU8Array(bc: ByteCursor): Uint8Array;
+import { type ByteCursor } from "../core/byte-cursor.js";
+export declare function readU8Array(bc: ByteCursor): Uint8Array<ArrayBuffer>;
 export declare function writeU8Array(bc: ByteCursor, x: Uint8Array): void;
-export declare function readU8FixedArray(bc: ByteCursor, len: number): Uint8Array;
+export declare function readU8FixedArray(bc: ByteCursor, len: number): Uint8Array<ArrayBuffer>;
 export declare function writeU8FixedArray(bc: ByteCursor, x: Uint8Array): void;
+/**
+ * Advance `bc` by `len` bytes and return a view of the read bytes.
+ *
+ * WARNING: The returned array should not be modified.
+ */
+export declare function readUnsafeU8FixedArray(bc: ByteCursor, len: number): Uint8Array;

package/dist/codec/u8-array.js

@@ -1,27 +1,32 @@
-// src/codec/u8-array.ts
-import { readUintSafe, writeUintSafe } from "./primitive.js";
-function readU8Array(bc) {
-  return readU8FixedArray(bc, readUintSafe(bc));
+"use strict";
+import { check, reserve } from "../core/byte-cursor.js";
+import { assert, DEV } from "../util/assert.js";
+import { isU32 } from "../util/validator.js";
+import { readUintSafe32, writeUintSafe32 } from "./primitive.js";
+export function readU8Array(bc) {
+  return readU8FixedArray(bc, readUintSafe32(bc));
 }
-function writeU8Array(bc, x) {
-  writeUintSafe(bc, x.length);
+export function writeU8Array(bc, x) {
+  writeUintSafe32(bc, x.length);
   writeU8FixedArray(bc, x);
 }
-function readU8FixedArray(bc, len) {
-  return bc.read(len).slice();
+export function readU8FixedArray(bc, len) {
+  return readUnsafeU8FixedArray(bc, len).slice();
 }
-function writeU8FixedArray(bc, x) {
+export function writeU8FixedArray(bc, x) {
   const len = x.length;
-  if (len !== 0) {
-    bc.reserve(len);
+  if (len > 0) {
+    reserve(bc, len);
     bc.bytes.set(x, bc.offset);
     bc.offset += len;
   }
 }
-export {
-  readU8Array,
-  readU8FixedArray,
-  writeU8Array,
-  writeU8FixedArray
-};
-//# sourceMappingURL=u8-array.js.map
+export 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);
+}

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

@@ -1,5 +1,5 @@
-import type { ByteCursor } from "../core/index.js";
-export declare function readU8ClampedArray(bc: ByteCursor): Uint8ClampedArray;
+import type { ByteCursor } from "../core/byte-cursor.js";
+export declare function readU8ClampedArray(bc: ByteCursor): Uint8ClampedArray<ArrayBuffer>;
 export declare function writeU8ClampedArray(bc: ByteCursor, x: Uint8ClampedArray): void;
-export declare function readU8ClampedFixedArray(bc: ByteCursor, len: number): Uint8ClampedArray;
+export declare function readU8ClampedFixedArray(bc: ByteCursor, len: number): Uint8ClampedArray<ArrayBuffer>;
 export declare function writeU8ClampedFixedArray(bc: ByteCursor, x: Uint8ClampedArray): void;

package/dist/codec/u8-clamped-array.js

@@ -1,24 +1,22 @@
-// src/codec/u8-clamped-array.ts
+"use strict";
+import { assert, DEV } from "../util/assert.js";
+import { isU32 } from "../util/validator.js";
 import { readFixedData } from "./data.js";
-import { readUintSafe, writeUintSafe } from "./primitive.js";
+import { readUintSafe32, writeUintSafe32 } from "./primitive.js";
 import { writeU8FixedArray } from "./u8-array.js";
-function readU8ClampedArray(bc) {
-  return readU8ClampedFixedArray(bc, readUintSafe(bc));
+export function readU8ClampedArray(bc) {
+  return readU8ClampedFixedArray(bc, readUintSafe32(bc));
 }
-function writeU8ClampedArray(bc, x) {
-  writeUintSafe(bc, x.length);
+export function writeU8ClampedArray(bc, x) {
+  writeUintSafe32(bc, x.length);
   writeU8ClampedFixedArray(bc, x);
 }
-function readU8ClampedFixedArray(bc, len) {
+export function readU8ClampedFixedArray(bc, len) {
+  if (DEV) {
+    assert(isU32(len));
+  }
   return new Uint8ClampedArray(readFixedData(bc, len));
 }
-function writeU8ClampedFixedArray(bc, x) {
+export function writeU8ClampedFixedArray(bc, x) {
   writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
 }
-export {
-  readU8ClampedArray,
-  readU8ClampedFixedArray,
-  writeU8ClampedArray,
-  writeU8ClampedFixedArray
-};
-//# sourceMappingURL=u8-clamped-array.js.map

package/dist/core/bare-error.d.ts

@@ -1,5 +1,8 @@
+/**
+ * @sealed
+ */
 export declare class BareError extends Error {
-    readonly name: "BareError";
+    name: string;
     readonly cause: unknown;
     readonly issue: string;
     readonly offset: number;

package/dist/core/bare-error.js

@@ -1,14 +1,10 @@
-// src/core/bare-error.ts
-var BareError = class extends Error {
+"use strict";
+export class BareError 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;
+    this.cause = opts?.cause;
   }
-};
-export {
-  BareError
-};
-//# sourceMappingURL=bare-error.js.map
+}

package/dist/core/byte-cursor.d.ts

@@ -1,16 +1,20 @@
 import type { Config } from "./config.js";
 /**
- * @invariant bytes.buffer === view.buffer
- * @invariant bytes.byteOffset === view.byteOffset
- * @invariant bytes.byteLength === view.byteLength
- * @invariant 0 <= offset <= bytes.byteLength
- * @invariant bytes.byteLength <= config.maxBufferLength
+ * @invariant `bytes.buffer === view.buffer`
+ * @invariant `bytes.byteOffset === view.byteOffset`
+ * @invariant `bytes.byteLength === view.byteLength`
+ * @invariant `0 <= offset <= bytes.byteLength`
+ * @invariant `bytes.byteLength <= config.maxBufferLength`
  *
+ * ```txt
  * |         {bytes,view}.buffer                      |
  *        |          bytes                    |
  *        |          view                     |
  *        |<------ offset ------>|
  *        |<----------- config.maxBufferLength ------------>|
+ * ```
+ *
+ * @sealed
  */
 export declare class ByteCursor {
     bytes: Uint8Array;
@@ -21,29 +25,19 @@ export declare class ByteCursor {
     offset: number;
     view: DataView;
     /**
-     * @param bytes read and/or write buffer
-     * @param config runtime configuration
-     * @throw BareError when the buffer exceeds the maximum allowed length
-     *  `config.maxBufferLength`
+     * @throws {BareError} Buffer exceeds `config.maxBufferLength`
      */
     constructor(bytes: Uint8Array, config: Config);
-    /**
-     * @param min number of needed bytes
-     * @throw BareError when there is not enough bytes
-     */
-    check(min: number): void;
-    /**
-     * @param min number of bytes to reserve
-     * @throw BareError when the buffer exceeds the maximum allowed length
-     *  `config.maxBufferLength`
-     */
-    reserve(min: number): void;
-    /**
-     * Advance cursor by {@code len} bytes and return a view of the read bytes.
-     * The returned array should not be modified.
-     *
-     * @param len number of bytes to read
-     * @returns read bytes
-     */
-    read(len: number): Uint8Array;
 }
+/**
+ * Check that `min` number of bytes are available.
+ *
+ * @throws {BareError} bytes are missing.
+ */
+export declare function check(bc: ByteCursor, min: number): void;
+/**
+ * Reserve `min` number of bytes.
+ *
+ * @throws {BareError} Buffer exceeds `config.maxBufferLength`.
+ */
+export declare function reserve(bc: ByteCursor, min: number): void;

package/dist/core/byte-cursor.js

@@ -1,42 +1,46 @@
-// src/core/byte-cursor.ts
+"use strict";
+import { assert, DEV } from "../util/assert.js";
 import { TOO_LARGE_BUFFER } from "../util/constants.js";
+import { isU32 } from "../util/validator.js";
 import { BareError } from "./bare-error.js";
-var ByteCursor = class {
+export class ByteCursor {
+  /**
+   * @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");
-    }
+}
+export 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);
+}
+export 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);
   }
-};
-export {
-  ByteCursor
-};
-//# sourceMappingURL=byte-cursor.js.map
+}

package/dist/core/config.d.ts

@@ -1,12 +1,6 @@
-export interface Config {
+export type Config = {
     readonly initialBufferLength: number;
     readonly maxBufferLength: number;
-    readonly textDecoderThreshold: number;
-    readonly textEncoderThreshold: number;
-}
-export declare function Config({ initialBufferLength, maxBufferLength, textDecoderThreshold, textEncoderThreshold, }: {
-    initialBufferLength?: number | undefined;
-    maxBufferLength?: number | undefined;
-    textDecoderThreshold?: number | undefined;
-    textEncoderThreshold?: number | undefined;
-}): Config;
+};
+export declare function Config({ initialBufferLength, maxBufferLength, }: Partial<Config>): Config;
+export declare const DEFAULT_CONFIG: Config;

package/dist/core/config.js

@@ -1,27 +1,22 @@
-// src/core/config.ts
-import { assert } from "../util/assert.js";
+"use strict";
+import { assert, DEV } from "../util/assert.js";
 import { TOO_LARGE_NUMBER } from "../util/constants.js";
 import { isU32 } from "../util/validator.js";
-function Config({
+export function Config({
   initialBufferLength = 1024,
-  maxBufferLength = 1024 * 1024 * 32,
-  textDecoderThreshold = 256,
-  textEncoderThreshold = 256
+  maxBufferLength = 1024 * 1024 * 32
 }) {
-  const config = {
+  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,
-    textDecoderThreshold,
-    textEncoderThreshold
+    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;
 }
-export {
-  Config
-};
-//# sourceMappingURL=config.js.map
+export const DEFAULT_CONFIG = /* @__PURE__ */ Config({});

package/dist/env/dev.d.ts

@@ -0,0 +1 @@
+export declare const DEV = false;

package/dist/env/dev.development.d.ts

@@ -0,0 +1 @@
+export declare const DEV = true;

package/dist/env/dev.development.js

@@ -0,0 +1,2 @@
+"use strict";
+export const DEV = true;

package/dist/env/dev.js

@@ -0,0 +1,2 @@
+"use strict";
+export const DEV = false;

package/dist/env/dev.node.d.ts

@@ -0,0 +1 @@
+export declare const DEV: boolean;

package/dist/env/dev.node.js

@@ -0,0 +1,2 @@
+"use strict";
+export const DEV = process.env.NODE_ENV === "development";