@bare-ts/lib 0.5.0 → 0.6.1

package/dist/index.cjs

@@ -20,11 +20,23 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AssertionError: () => AssertionError,
   BareError: () => BareError,
   ByteCursor: () => ByteCursor,
   Config: () => Config,
   DEFAULT_CONFIG: () => DEFAULT_CONFIG,
+  DEV: () => DEV,
+  assert: () => assert,
   check: () => check,
+  isI16: () => isI16,
+  isI32: () => isI32,
+  isI64: () => isI64,
+  isI8: () => isI8,
+  isU16: () => isU16,
+  isU32: () => isU32,
+  isU64: () => isU64,
+  isU64Safe: () => isU64Safe,
+  isU8: () => isU8,
   readBool: () => readBool,
   readData: () => readData,
   readF32: () => readF32,
@@ -114,30 +126,29 @@ __export(index_exports, {
   writeU8FixedArray: () => writeU8FixedArray,
   writeUint: () => writeUint,
   writeUintSafe: () => writeUintSafe,
-  writeUintSafe32: () => writeUintSafe32
+  writeUintSafe32: () => writeUintSafe32,
+  writeUintTruncated: () => writeUintTruncated
 });
 module.exports = __toCommonJS(index_exports);
 
-// dist/env/dev.node.js
+// imports/dev.node.js
 var DEV = process.env.NODE_ENV === "development";
 
 // src/util/assert.ts
-var AssertionError = class extends Error {
-  constructor() {
-    super(...arguments);
-    this.name = "AssertionError";
-  }
-};
 var V8Error = Error;
 function assert(test, message = "") {
   if (!test) {
     const e = new AssertionError(message);
-    if (V8Error.captureStackTrace) {
-      V8Error.captureStackTrace(e, assert);
-    }
+    V8Error.captureStackTrace?.(e, assert);
     throw e;
   }
 }
+var AssertionError = class extends Error {
+  constructor() {
+    super(...arguments);
+    this.name = "AssertionError";
+  }
+};
 
 // src/util/validator.ts
 function isI8(val) {
@@ -223,18 +234,43 @@ function reserve(bc, min) {
   }
   const minLen = bc.offset + min | 0;
   if (minLen > bc.bytes.length) {
-    if (minLen > bc.config.maxBufferLength) {
-      throw new BareError(0, TOO_LARGE_BUFFER);
+    grow(bc, minLen);
+  }
+}
+function grow(bc, minLen) {
+  if (minLen > bc.config.maxBufferLength) {
+    throw new BareError(0, TOO_LARGE_BUFFER);
+  }
+  const buffer = bc.bytes.buffer;
+  let newBytes;
+  if (isEs2024ArrayBufferLike(buffer) && // Make sure that the view covers the end of the buffer.
+  // If it is not the case, this indicates that the user don't want
+  // to override the trailing bytes.
+  bc.bytes.byteOffset + bc.bytes.byteLength === buffer.byteLength && bc.bytes.byteLength + minLen <= buffer.maxByteLength) {
+    const newLen = Math.min(
+      minLen << 1,
+      bc.config.maxBufferLength,
+      buffer.maxByteLength
+    );
+    if (buffer instanceof ArrayBuffer) {
+      buffer.resize(newLen);
+    } else {
+      buffer.grow(newLen);
     }
+    newBytes = new Uint8Array(buffer, bc.bytes.byteOffset, newLen);
+  } else {
     const newLen = Math.min(minLen << 1, bc.config.maxBufferLength);
-    const newBytes = new Uint8Array(newLen);
+    newBytes = new Uint8Array(newLen);
     newBytes.set(bc.bytes);
-    bc.bytes = newBytes;
-    bc.view = new DataView(newBytes.buffer);
   }
+  bc.bytes = newBytes;
+  bc.view = new DataView(newBytes.buffer);
+}
+function isEs2024ArrayBufferLike(buffer) {
+  return "maxByteLength" in buffer;
 }
 
-// src/codec/primitive.ts
+// src/codec/fixed-primitive.ts
 function readBool(bc) {
   const val = readU8(bc);
   if (val > 1) {
@@ -357,74 +393,6 @@ function writeI64Safe(bc, x) {
   }
   writeU32(bc, highest32);
 }
-function readInt(bc) {
-  const zigZag = readUint(bc);
-  return zigZag >> BigInt(1) ^ -(zigZag & BigInt(1));
-}
-function writeInt(bc, x) {
-  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);
-}
-function readIntSafe(bc) {
-  const firstByte = readU8(bc);
-  let result = (firstByte & 127) >> 1;
-  if (firstByte >= 128) {
-    let shiftMul = (
-      /* 2**6 */
-      64
-    );
-    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, "must be canonical");
-    }
-    if (byteCount === INT_SAFE_MAX_BYTE_COUNT && (byte > 31 || firstByte === 255)) {
-      bc.offset -= byteCount - 1;
-      throw new BareError(bc.offset, TOO_LARGE_NUMBER);
-    }
-  }
-  const isNeg = (firstByte & 1) === 1;
-  if (isNeg) {
-    result = -result - 1;
-  }
-  return result;
-}
-function writeIntSafe(bc, x) {
-  const sign = x < 0 ? 1 : 0;
-  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, first7Bits);
-  }
-}
 function readU8(bc) {
   check(bc, 1);
   return bc.bytes[bc.offset++];
@@ -496,6 +464,8 @@ function writeU64Safe(bc, x) {
   4294967296 & /* 2**21-1 */
   2097151);
 }
+
+// src/codec/uint.ts
 function readUint(bc) {
   let low = readU8(bc);
   if (low >= 128) {
@@ -532,9 +502,9 @@ function writeUint(bc, x) {
   if (DEV) {
     assert(truncated === x, TOO_LARGE_NUMBER);
   }
-  writeTruncatedUint(bc, truncated);
+  writeUintTruncated(bc, truncated);
 }
-function writeTruncatedUint(bc, x) {
+function writeUintTruncated(bc, x) {
   let tmp = Number(BigInt.asUintN(7 * 7, x));
   let rest = Number(x >> BigInt(7 * 7));
   let byteCount = 0;
@@ -583,7 +553,7 @@ function writeUintSafe32(bc, x) {
   }
   let zigZag = x >>> 0;
   while (zigZag >= 128) {
-    writeU8(bc, 128 | x & 127);
+    writeU8(bc, 128 | zigZag & 127);
     zigZag >>>= 7;
   }
   writeU8(bc, zigZag);
@@ -683,7 +653,7 @@ function writeFixedData(bc, x) {
   writeU8FixedArray(bc, new Uint8Array(x));
 }
 
-// src/codec/float-array.ts
+// src/codec/f32-array.ts
 var readF32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readF32FixedArrayLe : readF32FixedArrayBe;
 function readF32FixedArrayLe(bc, len) {
   if (DEV) {
@@ -723,6 +693,8 @@ function writeF32Array(bc, x) {
     writeF32FixedArray(bc, x);
   }
 }
+
+// src/codec/f64-array.ts
 var readF64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readF64FixedArrayLe : readF64FixedArrayBe;
 function readF64FixedArrayLe(bc, len) {
   if (DEV) {
@@ -901,6 +873,76 @@ function writeI64FixedArrayBe(bc, x) {
   }
 }
 
+// src/codec/int.ts
+function readInt(bc) {
+  const zigZag = readUint(bc);
+  return zigZag >> BigInt(1) ^ -(zigZag & BigInt(1));
+}
+function writeInt(bc, x) {
+  const truncated = BigInt.asIntN(64, x);
+  if (DEV) {
+    assert(truncated === x, TOO_LARGE_NUMBER);
+  }
+  const zigZag = truncated >> BigInt(63) ^ truncated << BigInt(1);
+  writeUintTruncated(bc, zigZag);
+}
+function readIntSafe(bc) {
+  const firstByte = readU8(bc);
+  let result = (firstByte & 127) >> 1;
+  if (firstByte >= 128) {
+    let shiftMul = (
+      /* 2**6 */
+      64
+    );
+    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, "must be canonical");
+    }
+    if (byteCount === INT_SAFE_MAX_BYTE_COUNT && (byte > 31 || firstByte === 255)) {
+      bc.offset -= byteCount - 1;
+      throw new BareError(bc.offset, TOO_LARGE_NUMBER);
+    }
+  }
+  const isNeg = (firstByte & 1) === 1;
+  if (isNeg) {
+    result = -result - 1;
+  }
+  return result;
+}
+function writeIntSafe(bc, x) {
+  const sign = x < 0 ? 1 : 0;
+  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, first7Bits);
+  }
+}
+
 // src/codec/string.ts
 function readString(bc) {
   return readFixedString(bc, readUintSafe32(bc));
@@ -1190,11 +1232,23 @@ function Config({
 var DEFAULT_CONFIG = /* @__PURE__ */ Config({});
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AssertionError,
   BareError,
   ByteCursor,
   Config,
   DEFAULT_CONFIG,
+  DEV,
+  assert,
   check,
+  isI16,
+  isI32,
+  isI64,
+  isI8,
+  isU16,
+  isU32,
+  isU64,
+  isU64Safe,
+  isU8,
   readBool,
   readData,
   readF32,
@@ -1284,5 +1338,8 @@ var DEFAULT_CONFIG = /* @__PURE__ */ Config({});
   writeU8FixedArray,
   writeUint,
   writeUintSafe,
-  writeUintSafe32
+  writeUintSafe32,
+  writeUintTruncated
 });
+//! Copyright (c) 2022 Victorien Elvinger
+//! Licensed under the MIT License (https://mit-license.org/)

package/dist/index.d.cts

@@ -1,16 +1,21 @@
-export * from "./codec/data.js";
-export * from "./codec/float-array.js";
-export * from "./codec/i8-array.js";
-export * from "./codec/i16-array.js";
-export * from "./codec/i32-array.js";
-export * from "./codec/i64-array.js";
-export * from "./codec/primitive.js";
-export * from "./codec/string.js";
-export * from "./codec/u8-array.js";
-export * from "./codec/u8-clamped-array.js";
-export * from "./codec/u16-array.js";
-export * from "./codec/u32-array.js";
-export * from "./codec/u64-array.js";
-export * from "./core/bare-error.js";
-export * from "./core/byte-cursor.js";
-export * from "./core/config.js";
+export * from "./codec/data.ts";
+export * from "./codec/f32-array.ts";
+export * from "./codec/f64-array.ts";
+export * from "./codec/fixed-primitive.ts";
+export * from "./codec/i8-array.ts";
+export * from "./codec/i16-array.ts";
+export * from "./codec/i32-array.ts";
+export * from "./codec/i64-array.ts";
+export * from "./codec/int.ts";
+export * from "./codec/string.ts";
+export * from "./codec/u8-array.ts";
+export * from "./codec/u8-clamped-array.ts";
+export * from "./codec/u16-array.ts";
+export * from "./codec/u32-array.ts";
+export * from "./codec/u64-array.ts";
+export * from "./codec/uint.ts";
+export * from "./core/bare-error.ts";
+export * from "./core/byte-cursor.ts";
+export * from "./core/config.ts";
+export * from "./util/assert.ts";
+export * from "./util/validator.ts";

package/dist/index.d.ts

@@ -1,16 +1,21 @@
-export * from "./codec/data.js";
-export * from "./codec/float-array.js";
-export * from "./codec/i8-array.js";
-export * from "./codec/i16-array.js";
-export * from "./codec/i32-array.js";
-export * from "./codec/i64-array.js";
-export * from "./codec/primitive.js";
-export * from "./codec/string.js";
-export * from "./codec/u8-array.js";
-export * from "./codec/u8-clamped-array.js";
-export * from "./codec/u16-array.js";
-export * from "./codec/u32-array.js";
-export * from "./codec/u64-array.js";
-export * from "./core/bare-error.js";
-export * from "./core/byte-cursor.js";
-export * from "./core/config.js";
+export * from "./codec/data.ts";
+export * from "./codec/f32-array.ts";
+export * from "./codec/f64-array.ts";
+export * from "./codec/fixed-primitive.ts";
+export * from "./codec/i8-array.ts";
+export * from "./codec/i16-array.ts";
+export * from "./codec/i32-array.ts";
+export * from "./codec/i64-array.ts";
+export * from "./codec/int.ts";
+export * from "./codec/string.ts";
+export * from "./codec/u8-array.ts";
+export * from "./codec/u8-clamped-array.ts";
+export * from "./codec/u16-array.ts";
+export * from "./codec/u32-array.ts";
+export * from "./codec/u64-array.ts";
+export * from "./codec/uint.ts";
+export * from "./core/bare-error.ts";
+export * from "./core/byte-cursor.ts";
+export * from "./core/config.ts";
+export * from "./util/assert.ts";
+export * from "./util/validator.ts";

package/dist/index.js

@@ -1,17 +1,23 @@
-"use strict";
+//! Copyright (c) 2022 Victorien Elvinger
+//! Licensed under the MIT License (https://mit-license.org/)
 export * from "./codec/data.js";
-export * from "./codec/float-array.js";
+export * from "./codec/f32-array.js";
+export * from "./codec/f64-array.js";
+export * from "./codec/fixed-primitive.js";
 export * from "./codec/i8-array.js";
 export * from "./codec/i16-array.js";
 export * from "./codec/i32-array.js";
 export * from "./codec/i64-array.js";
-export * from "./codec/primitive.js";
+export * from "./codec/int.js";
 export * from "./codec/string.js";
 export * from "./codec/u8-array.js";
 export * from "./codec/u8-clamped-array.js";
 export * from "./codec/u16-array.js";
 export * from "./codec/u32-array.js";
 export * from "./codec/u64-array.js";
+export * from "./codec/uint.js";
 export * from "./core/bare-error.js";
 export * from "./core/byte-cursor.js";
 export * from "./core/config.js";
+export * from "./util/assert.js";
+export * from "./util/validator.js";

package/dist/util/assert.d.ts

@@ -1,8 +1,17 @@
 export { DEV } from "#dev";
 /**
+ * @throws {AssertionError} if `test` is `false`.
+ *  The message of the error is set to `message`.
+ */
+export declare function assert(test: boolean, message?: string): asserts test;
+/**
+ * Indicates the failure of an assertion.
+ * This error is thrown by {@link assert }.
+ *
+ * This error should not be caught.
+ *
  * @sealed
  */
 export declare class AssertionError extends Error {
     name: string;
 }
-export declare function assert(test: boolean, message?: string): asserts test;

package/dist/util/assert.js

@@ -1,18 +1,29 @@
-"use strict";
+//! Copyright (c) 2022 Victorien Elvinger
+//! Licensed under the MIT License (https://mit-license.org/)
 export { DEV } from "#dev";
-export class AssertionError extends Error {
-  constructor() {
-    super(...arguments);
-    this.name = "AssertionError";
-  }
-}
 const V8Error = Error;
+/**
+ * @throws {AssertionError} if `test` is `false`.
+ *  The message of the error is set to `message`.
+ */
 export function assert(test, message = "") {
-  if (!test) {
-    const e = new AssertionError(message);
-    if (V8Error.captureStackTrace) {
-      V8Error.captureStackTrace(e, assert);
+    if (!test) {
+        const e = new AssertionError(message);
+        V8Error.captureStackTrace?.(e, assert);
+        throw e;
+    }
+}
+/**
+ * Indicates the failure of an assertion.
+ * This error is thrown by {@link assert }.
+ *
+ * This error should not be caught.
+ *
+ * @sealed
+ */
+export class AssertionError extends Error {
+    constructor() {
+        super(...arguments);
+        this.name = "AssertionError";
     }
-    throw e;
-  }
 }

package/dist/util/constants.js

@@ -1,4 +1,7 @@
-"use strict";
+//! Copyright (c) 2022 Victorien Elvinger
+//! Licensed under the MIT License (https://mit-license.org/)
+// To make constants inlinable by bundlers like esbuild, we group them in this module.
+// The module must be without any imports.
 export const TEXT_DECODER_THRESHOLD = 256;
 export const TEXT_ENCODER_THRESHOLD = 256;
 export const INT_SAFE_MAX_BYTE_COUNT = 8;
@@ -8,4 +11,5 @@ export const INVALID_UTF8_STRING = "invalid UTF-8 string";
 export const NON_CANONICAL_REPRESENTATION = "must be canonical";
 export const TOO_LARGE_BUFFER = "too large buffer";
 export const TOO_LARGE_NUMBER = "too large number";
-export const IS_LITTLE_ENDIAN_PLATFORM = /* @__PURE__ */ new DataView(Uint16Array.of(1).buffer).getUint8(0) === 1;
+export const IS_LITTLE_ENDIAN_PLATFORM = 
+/* @__PURE__ */ new DataView(Uint16Array.of(1).buffer).getUint8(0) === 1;

package/dist/util/validator.d.ts

@@ -1,9 +1,36 @@
+/**
+ * Can `val` be stored as a signed integer in 8 bits?
+ */
 export declare function isI8(val: number): boolean;
+/**
+ * Can `val` be stored as a signed integer in 16 bits?
+ */
 export declare function isI16(val: number): boolean;
+/**
+ * Can `val` be stored as a signed integer in 32 bits?
+ */
 export declare function isI32(val: number): boolean;
+/**
+ * Can `val` be stored as a signed integer in 64 bits?
+ */
 export declare function isI64(val: bigint): boolean;
+/**
+ * Can `val` be stored as an unsigned integer in 8 bits?
+ */
 export declare function isU8(val: number): boolean;
+/**
+ * Can `val` be stored as an unsigned integer in 16 bits?
+ */
 export declare function isU16(val: number): boolean;
+/**
+ * Can `val` be stored as an unsigned integer in 32 bits?
+ */
 export declare function isU32(val: number): boolean;
+/**
+ * Can `val` be stored as an unsigned integer in 64 bits?
+ */
 export declare function isU64(val: bigint): boolean;
+/**
+ * Is `val` an unsigned integer that can be safely represented as a float?
+ */
 export declare function isU64Safe(val: number): boolean;

package/dist/util/validator.js

@@ -1,28 +1,56 @@
-"use strict";
+//! Copyright (c) 2022 Victorien Elvinger
+//! Licensed under the MIT License (https://mit-license.org/)
+/**
+ * Can `val` be stored as a signed integer in 8 bits?
+ */
 export function isI8(val) {
-  return val === val << 24 >> 24;
+    return val === (val << 24) >> 24;
 }
+/**
+ * Can `val` be stored as a signed integer in 16 bits?
+ */
 export function isI16(val) {
-  return val === val << 16 >> 16;
+    return val === (val << 16) >> 16;
 }
+/**
+ * Can `val` be stored as a signed integer in 32 bits?
+ */
 export function isI32(val) {
-  return val === (val | 0);
+    return val === (val | 0);
 }
+/**
+ * Can `val` be stored as a signed integer in 64 bits?
+ */
 export function isI64(val) {
-  return val === BigInt.asIntN(64, val);
+    return val === BigInt.asIntN(64, val);
 }
+/**
+ * Can `val` be stored as an unsigned integer in 8 bits?
+ */
 export function isU8(val) {
-  return val === (val & 255);
+    return val === (val & 0xff);
 }
+/**
+ * Can `val` be stored as an unsigned integer in 16 bits?
+ */
 export function isU16(val) {
-  return val === (val & 65535);
+    return val === (val & 0xffff);
 }
+/**
+ * Can `val` be stored as an unsigned integer in 32 bits?
+ */
 export function isU32(val) {
-  return val === val >>> 0;
+    return val === val >>> 0;
 }
+/**
+ * Can `val` be stored as an unsigned integer in 64 bits?
+ */
 export function isU64(val) {
-  return val === BigInt.asUintN(64, val);
+    return val === BigInt.asUintN(64, val);
 }
+/**
+ * Is `val` an unsigned integer that can be safely represented as a float?
+ */
 export function isU64Safe(val) {
-  return Number.isSafeInteger(val) && val >= 0;
+    return Number.isSafeInteger(val) && val >= 0;
 }

package/imports/dev.d.ts

@@ -0,0 +1,4 @@
+//! Copyright (c) 2022 Victorien Elvinger
+//! Licensed under the MIT License (https://mit-license.org/)
+
+export declare const DEV = false

package/imports/dev.development.d.ts

@@ -0,0 +1,4 @@
+//! Copyright (c) 2022 Victorien Elvinger
+//! Licensed under the MIT License (https://mit-license.org/)
+
+export declare const DEV = true

package/imports/dev.development.js

@@ -0,0 +1,4 @@
+//! Copyright (c) 2022 Victorien Elvinger
+//! Licensed under the MIT License (https://mit-license.org/)
+
+export const DEV = true

package/imports/dev.js

@@ -0,0 +1,4 @@
+//! Copyright (c) 2022 Victorien Elvinger
+//! Licensed under the MIT License (https://mit-license.org/)
+
+export const DEV = false

package/imports/dev.node.d.ts

@@ -0,0 +1,4 @@
+//! Copyright (c) 2022 Victorien Elvinger
+//! Licensed under the MIT License (https://mit-license.org/)
+
+export declare const DEV: boolean

package/imports/dev.node.js

@@ -0,0 +1,4 @@
+//! Copyright (c) 2022 Victorien Elvinger
+//! Licensed under the MIT License (https://mit-license.org/)
+
+export const DEV = process.env.NODE_ENV === "development"