@bare-ts/lib 0.6.0 → 0.7.0

package/dist/codec/fixed-primitive.js

@@ -97,7 +97,7 @@ export function writeI64(bc, x) {
     bc.offset += 8;
 }
 export function readI64Safe(bc) {
-    const result = readU32(bc) + readI32(bc) * /* 2**32 */ 4294967296;
+    const result = readU32(bc) + readI32(bc) * /* 2**32 */ 0x1_00_00_00_00;
     if (!Number.isSafeInteger(result)) {
         bc.offset -= 8;
         throw new BareError(bc.offset, TOO_LARGE_NUMBER);
@@ -110,12 +110,12 @@ export function writeI64Safe(bc, x) {
     }
     let lowest32 = x >>> 0;
     writeU32(bc, lowest32);
-    let highest32 = (x / /* 2**32 */ 4294967296) | 0;
+    let highest32 = (x / /* 2**32 */ 0x1_00_00_00_00) | 0;
     if (x < 0) {
         // get two's complement representation of the highest 21bits
-        highest32 = ~(Math.abs(highest32) & /* 2**21-1 */ 2097151) >>> 0;
+        highest32 = ~(Math.abs(highest32) & /* 2**21-1 */ 0x1f_ffff) >>> 0;
         if (lowest32 === 0) {
-            if (highest32 === 2097151) {
+            if (highest32 === 0x1f_ffff) {
                 // maps -2**53 to Number.MIN_SAFE_INTEGER
                 // this is useful when assertions are skipped
                 lowest32 = 1;
@@ -181,7 +181,7 @@ export function writeU64(bc, x) {
     bc.offset += 8;
 }
 export function readU64Safe(bc) {
-    const result = readU32(bc) + readU32(bc) * /* 2**32 */ 4294967296;
+    const result = readU32(bc) + readU32(bc) * /* 2**32 */ 0x1_00_00_00_00;
     if (!isU64Safe(result)) {
         bc.offset -= 8;
         throw new BareError(bc.offset, TOO_LARGE_NUMBER);
@@ -193,5 +193,5 @@ export function writeU64Safe(bc, x) {
         assert(isU64Safe(x), TOO_LARGE_NUMBER);
     }
     writeU32(bc, x >>> 0);
-    writeU32(bc, (x / /* 2**32 */ 4294967296) & /* 2**21-1 */ 2097151);
+    writeU32(bc, (x / /* 2**32 */ 0x1_00_00_00_00) & /* 2**21-1 */ 0x1f_ffff);
 }

package/dist/codec/int.js

@@ -53,22 +53,22 @@ export function writeIntSafe(bc, x) {
     let zigZag = x < 0 ? -(x + 1) : x;
     let first7Bits = ((zigZag & 0x3f) << 1) | sign;
     zigZag = Math.floor(zigZag / /* 2**6 */ 0x40);
-    if (zigZag > 0) {
-        if (!Number.isSafeInteger(x)) {
-            if (DEV) {
-                assert(false, TOO_LARGE_NUMBER);
-            }
-            // keep only the remaining 53 - 6 = 47 bits
+    if (!Number.isSafeInteger(x)) {
+        if (DEV) {
+            assert(false, TOO_LARGE_NUMBER);
+        }
+        // keep only the remaining 53 - 6 = 47 bits
+        // this is useful when assertions are skipped
+        const low = zigZag & 0x7fff;
+        const high = ((zigZag / 0x8000) >>> 0) * 0x8000;
+        if (first7Bits === 0x7f && low === 0x7fff && high === 0xffff_ffff) {
+            // maps -2**53 to Number.MIN_SAFE_INTEGER
             // this is useful when assertions are skipped
-            const low = zigZag & 0x7fff;
-            const high = ((zigZag / 0x8000) >>> 0) * 0x8000;
-            if (first7Bits === 0x7f && low === 0x7fff && high === 4294967295) {
-                // maps -2**53 to Number.MIN_SAFE_INTEGER
-                // this is useful when assertions are skipped
-                first7Bits &= ~0b10;
-            }
-            zigZag = high + low;
+            first7Bits &= ~0b10;
         }
+        zigZag = high + low;
+    }
+    if (zigZag > 0) {
         writeU8(bc, 0x80 | first7Bits);
         writeUintSafe(bc, zigZag);
     }

package/dist/codec/string.js

@@ -124,7 +124,7 @@ function writeUtf8Js(bc, s) {
                 bytes[offset++] = 0xc0 | (codePoint >> 6);
             }
             else {
-                if (codePoint < 65536) {
+                if (codePoint < 0x10_000) {
                     bytes[offset++] = 0xe0 | (codePoint >> 12);
                 }
                 else {
@@ -147,7 +147,7 @@ function utf8ByteLength(s) {
             result++;
             if (codePoint > 0x7ff) {
                 result++;
-                if (codePoint > 65535) {
+                if (codePoint > 0xff_ff) {
                     i++; // surrogate pair encoded as two ucs2 chars
                 }
             }

package/dist/codec/uint.js

@@ -87,12 +87,12 @@ export function writeUintSafe32(bc, x) {
     }
     // truncate to mimic other int encoders
     // this is useful when assertions are skipped
-    let zigZag = x >>> 0;
-    while (zigZag >= 0x80) {
-        writeU8(bc, 0x80 | (x & 0x7f));
-        zigZag >>>= 7;
+    let rest = x >>> 0;
+    while (rest >= 0x80) {
+        writeU8(bc, 0x80 | (rest & 0x7f));
+        rest >>>= 7;
     }
-    writeU8(bc, zigZag);
+    writeU8(bc, rest);
 }
 export function readUintSafe(bc) {
     let result = readU8(bc);
@@ -119,20 +119,27 @@ export function readUintSafe(bc) {
     return result;
 }
 export function writeUintSafe(bc, x) {
-    if (DEV) {
-        assert(isU64Safe(x), TOO_LARGE_NUMBER);
+    let rest = x;
+    if (!isU64Safe(x)) {
+        if (DEV) {
+            assert(false, TOO_LARGE_NUMBER);
+        }
+        // Truncate `rest` to 53 bits
+        // this is useful when assertions are skipped
+        const low = rest & 0x1fffff;
+        const high = ((rest / 0x200000) >>> 0) * 0x200000;
+        rest = high + low;
     }
     let byteCount = 1;
-    let zigZag = x;
-    while (zigZag >= 0x80 && byteCount < INT_SAFE_MAX_BYTE_COUNT) {
-        writeU8(bc, 0x80 | (zigZag & 0x7f));
-        zigZag = Math.floor(zigZag / /* 2**7 */ 0x80);
+    while (rest >= 0x80 && byteCount < INT_SAFE_MAX_BYTE_COUNT) {
+        writeU8(bc, 0x80 | (rest & 0x7f));
+        rest = Math.floor(rest / /* 2**7 */ 0x80);
         byteCount++;
     }
     if (byteCount === INT_SAFE_MAX_BYTE_COUNT) {
         // truncate to mimic other int encoders
         // this is useful when assertions are skipped
-        zigZag &= 0x0f;
+        rest &= 0x0f;
     }
-    writeU8(bc, zigZag);
+    writeU8(bc, rest);
 }

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

@@ -3,10 +3,10 @@
  */
 export declare class BareError extends Error {
     name: string;
-    readonly cause: unknown;
     readonly issue: string;
+    /**
+     * Byte offset in the read buffer where the error occurred.
+     */
     readonly offset: number;
-    constructor(offset: number, issue: string, opts?: {
-        cause: unknown;
-    });
+    constructor(offset: number, issue: string, options?: ErrorOptions);
 }

package/dist/core/bare-error.js

@@ -4,11 +4,15 @@
  * @sealed
  */
 export class BareError extends Error {
-    constructor(offset, issue, opts) {
-        super(`(byte:${offset}) ${issue}`);
-        this.name = "BareError";
+    name = "BareError";
+    issue;
+    /**
+     * Byte offset in the read buffer where the error occurred.
+     */
+    offset;
+    constructor(offset, issue, options) {
+        super(`(byte:${offset}) ${issue}`, options);
         this.issue = issue;
         this.offset = offset;
-        this.cause = opts?.cause;
     }
 }

package/dist/core/byte-cursor.js

@@ -22,14 +22,17 @@ import { BareError } from "./bare-error.js";
  * @sealed
  */
 export class ByteCursor {
+    bytes;
+    config;
+    /**
+     * Read and write Offset in {@link view} and {@link bytes}
+     */
+    offset = 0;
+    view;
     /**
      * @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);
         }

package/dist/index.cjs

@@ -144,10 +144,7 @@ function assert(test, message = "") {
   }
 }
 var AssertionError = class extends Error {
-  constructor() {
-    super(...arguments);
-    this.name = "AssertionError";
-  }
+  name = "AssertionError";
 };
 
 // src/util/validator.ts
@@ -193,25 +190,32 @@ var IS_LITTLE_ENDIAN_PLATFORM = /* @__PURE__ */ new DataView(Uint16Array.of(1).b
 
 // src/core/bare-error.ts
 var BareError = class extends Error {
-  constructor(offset, issue, opts) {
-    super(`(byte:${offset}) ${issue}`);
-    this.name = "BareError";
+  name = "BareError";
+  issue;
+  /**
+   * Byte offset in the read buffer where the error occurred.
+   */
+  offset;
+  constructor(offset, issue, options) {
+    super(`(byte:${offset}) ${issue}`, options);
     this.issue = issue;
     this.offset = offset;
-    this.cause = opts?.cause;
   }
 };
 
 // src/core/byte-cursor.ts
 var ByteCursor = class {
+  bytes;
+  config;
+  /**
+   * Read and write Offset in {@link view} and {@link bytes}
+   */
+  offset = 0;
+  view;
   /**
    * @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);
     }
@@ -551,12 +555,12 @@ function writeUintSafe32(bc, x) {
   if (DEV) {
     assert(isU32(x), TOO_LARGE_NUMBER);
   }
-  let zigZag = x >>> 0;
-  while (zigZag >= 128) {
-    writeU8(bc, 128 | x & 127);
-    zigZag >>>= 7;
+  let rest = x >>> 0;
+  while (rest >= 128) {
+    writeU8(bc, 128 | rest & 127);
+    rest >>>= 7;
   }
-  writeU8(bc, zigZag);
+  writeU8(bc, rest);
 }
 function readUintSafe(bc) {
   let result = readU8(bc);
@@ -590,21 +594,26 @@ function readUintSafe(bc) {
   return result;
 }
 function writeUintSafe(bc, x) {
-  if (DEV) {
-    assert(isU64Safe(x), TOO_LARGE_NUMBER);
+  let rest = x;
+  if (!isU64Safe(x)) {
+    if (DEV) {
+      assert(false, TOO_LARGE_NUMBER);
+    }
+    const low = rest & 2097151;
+    const high = (rest / 2097152 >>> 0) * 2097152;
+    rest = high + low;
   }
   let byteCount = 1;
-  let zigZag = x;
-  while (zigZag >= 128 && byteCount < INT_SAFE_MAX_BYTE_COUNT) {
-    writeU8(bc, 128 | zigZag & 127);
-    zigZag = Math.floor(zigZag / /* 2**7 */
+  while (rest >= 128 && byteCount < INT_SAFE_MAX_BYTE_COUNT) {
+    writeU8(bc, 128 | rest & 127);
+    rest = Math.floor(rest / /* 2**7 */
     128);
     byteCount++;
   }
   if (byteCount === INT_SAFE_MAX_BYTE_COUNT) {
-    zigZag &= 15;
+    rest &= 15;
   }
-  writeU8(bc, zigZag);
+  writeU8(bc, rest);
 }
 
 // src/codec/u8-array.ts
@@ -924,18 +933,18 @@ function writeIntSafe(bc, 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;
+  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;
+  }
+  if (zigZag > 0) {
     writeU8(bc, 128 | first7Bits);
     writeUintSafe(bc, zigZag);
   } else {

package/dist/util/assert.js

@@ -22,8 +22,5 @@ export function assert(test, message = "") {
  * @sealed
  */
 export class AssertionError extends Error {
-    constructor() {
-        super(...arguments);
-        this.name = "AssertionError";
-    }
+    name = "AssertionError";
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bare-ts/lib",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "TypeScript library for BARE, a compact and simple binary-serialization format",
   "keywords": [
     "bare",
@@ -21,7 +21,7 @@
     "url": "https://github.com/bare-ts/lib/issues"
   },
   "engines": {
-    "node": "^14.18.0 || >=16.0.0"
+    "node": ">=16.9.0"
   },
   "type": "module",
   "exports": {
@@ -56,7 +56,7 @@
   "scripts": {
     "build": "npm run build:esm && npm run build:d.cts && npm run build:cjs",
     "build:d.cts": "cp -f dist/index.d.ts dist/index.d.cts",
-    "build:cjs": "esbuild src/index.ts --bundle --target=es2020 --platform=node > dist/index.cjs",
+    "build:cjs": "esbuild src/index.ts --bundle --target=es2022 --platform=node > dist/index.cjs",
     "build:esm": "tsc --build src/",
     "check": "tsc --build src src/tsconfig-test.json && biome ci --error-on-warnings .",
     "clean": "rm -rf dist coverage",
@@ -64,13 +64,15 @@
     "format": "biome check --linter-enabled=false --write .",
     "lint": "biome lint --error-on-warnings .",
     "prepublishOnly": "npm run clean && npm run build && npm test",
-    "test": "NODE_ENV=development node --test && npm run check",
+    "test": "npm run test:dev && npm run test:prod",
+    "test:dev": "NODE_ENV=development node --test && npm run check",
+    "test:prod": "node --test && npm run check",
     "version": "sh ./scripts/version.sh"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.3.4",
-    "@types/node": "20.19.21",
-    "esbuild": "0.27.0",
+    "@biomejs/biome": "2.3.12",
+    "@types/node": "22.18.13",
+    "esbuild": "0.27.2",
     "typescript": "5.9.3"
   }
 }