@gsknnft/bigint-buffer 1.4.6 → 1.5.0

package/README.md

@@ -1,107 +1,150 @@
-![CI](https://github.com/gsknknft/bigint-buffer/actions/workflows/ci.yaml/badge.svg)
-![Release](https://github.com/gsknknft/bigint-buffer/actions/workflows/release.yaml/badge.svg)
-
-# @gsknnft/bigint-buffer
-
-Secure BigInt ⇆ Buffer conversion with native bindings, browser fallbacks, and the `bigint-conversion` helper APIs built in. This is the actively maintained fork of the original `bigint-buffer`.
-
-**Upgrade notice:** The current 1.4.x line ships chunked, allocation-free BE/LE converters (Buffer.read/writeBigUInt64* when available) that are fuzzed across empty, tiny, and huge buffers, alongside FixedPoint utilities and packaged native bindings. CI-verified for Node 20–24. Upgrade for the fastest conversions and consistent behaviour across environments.
-
-[![NPM Version](https://img.shields.io/npm/v/@gsknnft/bigint-buffer.svg?style=flat-square)](https://www.npmjs.com/package/@gsknnft/bigint-buffer)
-[![Node Version](https://img.shields.io/node/v/@gsknnft/bigint-buffer.svg?style=flat-square)](https://nodejs.org)
-
----
-
-## Why This Package
-
-- Native N-API binding with pure-JS fallback for browsers and constrained environments.
-- Conversion helpers from `bigint-conversion` in-core (no extra deps).
-- ESM and CJS exports plus a UMD/browser bundle.
-- Actively maintained; legacy `bigint-buffer` is deprecated and flagged by audits.
-
----
-
-## Install
-```bash
-npm install @gsknnft/bigint-buffer
-# or pnpm/yarn if preferred
-```
-
----
-
-## Quick Start
-```ts
-import {
-  toBigIntBE, toBigIntLE, toBufferBE, toBufferLE,
-  bigintToBuf, bufToBigint, bigintToHex, hexToBigint,
-  bigintToText, textToBigint, bigintToBase64, base64ToBigint,
-  // New in 1.4.5
-  toFixedPoint, fromFixedPoint, addFixedPoint, subtractFixedPoint,
-  averageFixedPoint, compareFixedPoint, type FixedPoint,
-} from "@gsknnft/bigint-buffer";
-
-toBigIntBE(Buffer.from("deadbeef", "hex")); // 3735928559n
-toBufferLE(0xdeadbeefn, 6);                 // <Buffer ef be ad de 00 00>
-bigintToHex(123456789n);                    // "075bcd15"
-textToBigint("Hello");                      // 0x48656c6c6f
-bigintToBase64(123456789n);                 // "B1vNFQ=="
-
-// FixedPoint usage
-const fp = toFixedPoint(123456789n, 18);    // Convert bigint to FixedPoint
-const sum = addFixedPoint(fp, fp);          // Add two FixedPoints
-const avg = averageFixedPoint([fp, fp]);    // Average FixedPoints
-```
-
-### Performance
-- BE/LE conversions now stream bytes directly from buffers (64-bit chunks via Buffer.read/writeBigUInt64* when available) with no intermediate hex copies.
-- JS fallback matches the native binding semantics and is exercised against empty, tiny, and very large inputs in CI.
-- Native bindings still load automatically when present; the optimized fallback keeps browser and non-native runtimes fast.
-- Browser bundlers must polyfill Node built-ins: add a node polyfill plugin (e.g. `rollup-plugin-polyfill-node`) or explicit aliases for `buffer`, `path`, and `fs` so the fallback loader can resolve.
-
-### Pushing Performance Further
-- For very large buffers, consider enabling the native binding (included in npm tarball) or adding SIMD/native glue in your host app if you need throughput beyond JS.
-
-### Conversion Utilities
-```ts
-import { conversionUtils } from "@gsknnft/bigint-buffer";
-
-const arrBuf = conversionUtils.bigintToBuf(123456789n, true); // ArrayBuffer
-const hex = conversionUtils.bigintToHex(123456789n, true);    // '0x...' format
-const text = conversionUtils.bigintToText(123456789n);
-```
-
----
-
-## Runtime
-- Native binary: `build/Release/bigint_buffer.node` (included in npm package; loads automatically when available).
-- Fallback: pure JS bundle for browser and non-native installs (now improved in 1.4.5).
-- Check which path loaded:
-  ```ts
-  import { isNative } from "@gsknnft/bigint-buffer";
-  console.log(isNative); // true when native binding is active
-  ```
-
----
-
-## Commands
-```bash
-npm run build           # bundle + declarations + type check
-npm test                # vitest with coverage
-npm run test:node       # mocha against built JS (after build/compile)
-npm run rebuild:native  # rebuild the N-API binding
-```
-
----
-
-## API Surface (high level)
-- Core: `toBigIntBE/LE`, `toBufferBE/LE`, `validateBigIntBuffer`, `isNative`
-- Conversion: `bigintToBuf`, `bufToBigint`, `bigintToHex`, `hexToBigint`, `bigintToText`, `textToBigint`, `bigintToBase64`, `base64ToBigint`, `bufToHex`, `hexToBuf`, `textToBuf`, `bufToText`, `parseHex`
-
-All helpers are endian-safe and validated across Node and browser builds.
-
----
- 
-## Support
-- Version: 1.4.5 (FixedPoint, native bindings out-of-the-box, improved JS fallback)
-- Node: 20+ (tested through 24 LTS under CI)
-- Issues: https://github.com/gsknnft/bigint-buffer/issues
+# @gsknnft/bigint-buffer
+
+[![NPM Version](https://img.shields.io/npm/v/@gsknnft/bigint-buffer.svg?style=flat-square)](https://www.npmjs.com/package/@gsknnft/bigint-buffer)
+[![Node Version](https://img.shields.io/node/v/@gsknnft/bigint-buffer.svg?style=flat-square)](https://nodejs.org)
+
+BigInt <-> Buffer conversion with native bindings, fast JS fallback paths, and built-in conversion helpers.
+
+## Install
+
+```bash
+npm install @gsknnft/bigint-buffer
+```
+
+## Quick Start
+
+```ts
+import {
+  toBigIntBE,
+  toBigIntLE,
+  toBufferBE,
+  toBufferLE,
+  bigintToHex,
+  hexToBigint,
+  bigintToBase64,
+  base64ToBigint,
+} from "@gsknnft/bigint-buffer";
+
+const value = toBigIntBE(Buffer.from("deadbeef", "hex"));
+const out = toBufferLE(value, 8);
+
+const hex = bigintToHex(123456789n); // "075bcd15"
+const roundTrip = hexToBigint(hex);
+
+const b64 = bigintToBase64(123456789n);
+const fromB64 = base64ToBigint(b64);
+```
+
+## FixedPoint Helpers
+
+```ts
+import {
+  toFixedPoint,
+  fromFixedPoint,
+  addFixedPoint,
+  subtractFixedPoint,
+  averageFixedPoint,
+  compareFixedPoint,
+} from "@gsknnft/bigint-buffer";
+
+const a = toFixedPoint(12.34, 9);
+const b = toFixedPoint(7.66, 9);
+const sum = addFixedPoint(a, b);
+const avg = averageFixedPoint([a, b]);
+const cmp = compareFixedPoint(a, b);
+const n = fromFixedPoint(sum, 9);
+```
+
+## Native Loading
+
+The package tries native first, then falls back to JS:
+
+1. `node-gyp-build` prebuild lookup from installed package root
+2. `bindings` lookup with explicit `module_root` when resolvable
+3. pure JS fallback
+
+Set `BIGINT_BUFFER_NATIVE_PATH` to override lookup root when needed.
+
+Enable debug logging:
+
+```bash
+BIGINT_BUFFER_DEBUG=1 node your-app.js
+```
+
+Silence fallback warning:
+
+```bash
+BIGINT_BUFFER_SILENT_NATIVE_FAIL=1 node your-app.js
+```
+
+## Electron Packaging
+
+Include the native binary in unpacked resources:
+
+- `node_modules/@gsknnft/bigint-buffer/build/Release/bigint_buffer.node`
+
+Common location at runtime:
+
+- `resources/app.asar.unpacked/node_modules/@gsknnft/bigint-buffer/build/Release/bigint_buffer.node`
+
+If your packager relocates native files, set `BIGINT_BUFFER_NATIVE_PATH` to the directory containing `build/Release/bigint_buffer.node`.
+
+## Browser Notes
+
+This package supports browser builds via fallback paths and conversion bundles.
+
+If your bundler does not polyfill Node globals/modules automatically, add polyfills for:
+
+- `Buffer`
+- `path`
+- `fs`
+
+## Exports
+
+Top-level package exports:
+
+- ESM: `dist/index.js`
+- CJS: `dist/index.cjs`
+- Types: `dist/index.d.ts`
+- Native binary export: `./build/Release/bigint_buffer.node`
+- Conversion subpath: `@gsknnft/bigint-buffer/conversion`
+
+## Commands
+
+```bash
+npm run build        # bundle + declarations + conversion sync + native sync
+npm run compile      # build + typecheck
+npm test             # vitest
+npm run check        # eslint
+npm run rebuild      # node-gyp rebuild + build + conversion build
+npm run prebuilds    # prebuildify for native binaries
+```
+
+Internal build scripts (`scripts/*.ts`) are executed via `tsx` for stable ESM compatibility in local and CI environments.
+
+## Quality Snapshot
+
+Latest local run (Node 24, Vitest v4, v8 coverage):
+
+- Tests: `141 passed`
+- Coverage: `Statements 84.15%`, `Branches 72.36%`, `Functions 88.37%`, `Lines 85.88%`
+- Benchmark snapshot: see `benchmark.md`
+- Publish dry-run: clean tarball (no test/bench JS artifacts)
+
+Reproduce:
+
+```bash
+pnpm exec vitest run --coverage --pool=forks
+pnpm run benchmark
+pnpm pack --dry-run
+```
+
+## Runtime Compatibility
+
+- Node: `>=20`
+- Package format: ESM + CJS
+- Native addon: N-API (`bigint_buffer.node`)
+
+## License
+
+Apache-2.0

package/dist/conversion/bundle.iife.js

@@ -0,0 +1,421 @@
+(function () {
+    'use strict';
+
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.toBigIntValue = exports.toHexString = exports.ZERO_FIXED_POINT = exports.FIXED_POINT_PATTERN = exports.FIXED_POINT_DECIMALS = void 0;
+    exports.toBigIntLE = toBigIntLE;
+    exports.validateBigIntBuffer = validateBigIntBuffer;
+    exports.toBigIntBE = toBigIntBE;
+    exports.toBufferLE = toBufferLE;
+    exports.toBufferBE = toBufferBE;
+    exports.parseHex = parseHex;
+    exports.bigintToBuf = bigintToBuf;
+    exports.bufToBigint = bufToBigint;
+    exports.bigintToHex = bigintToHex;
+    exports.hexToBigint = hexToBigint;
+    exports.bigintToText = bigintToText;
+    exports.textToBigint = textToBigint;
+    exports.bufToText = bufToText;
+    exports.textToBuf = textToBuf;
+    exports.bufToHex = bufToHex;
+    exports.hexToBuf = hexToBuf;
+    exports.bigintToBase64 = bigintToBase64;
+    exports.base64ToBigint = base64ToBigint;
+    exports.toFixedPoint = toFixedPoint;
+    exports.fromFixedPoint = fromFixedPoint;
+    exports.addFixedPoint = addFixedPoint;
+    exports.subtractFixedPoint = subtractFixedPoint;
+    exports.averageFixedPoint = averageFixedPoint;
+    exports.compareFixedPoint = compareFixedPoint;
+    exports.fixedPointToBigInt = fixedPointToBigInt;
+    const converter_1 = require("./converter");
+    let converter;
+    const hasRead64LE = typeof Buffer.prototype.readBigUInt64LE === "function";
+    const hasRead64BE = typeof Buffer.prototype.readBigUInt64BE === "function";
+    const hasWrite64LE = typeof Buffer.prototype.writeBigUInt64LE === "function";
+    const hasWrite64BE = typeof Buffer.prototype.writeBigUInt64BE === "function";
+    const read64LE = hasRead64LE
+        ? (buf, offset) => buf.readBigUInt64LE(offset)
+        : (buf, offset) => {
+            let out = 0n;
+            for (let i = 7; i >= 0; i--) {
+                out = (out << 8n) + BigInt(buf[offset + i]);
+            }
+            return out;
+        };
+    const read64BE = hasRead64BE
+        ? (buf, offset) => buf.readBigUInt64BE(offset)
+        : (buf, offset) => {
+            let out = 0n;
+            for (let i = 0; i < 8; i++) {
+                out = (out << 8n) + BigInt(buf[offset + i]);
+            }
+            return out;
+        };
+    const write64LE = hasWrite64LE
+        ? (buf, offset, value) => {
+            buf.writeBigUInt64LE(value, offset);
+        }
+        : (buf, offset, value) => {
+            let temp = value;
+            for (let i = 0; i < 8; i++) {
+                buf[offset + i] = Number(temp & 0xffn);
+                temp >>= 8n;
+            }
+        };
+    const write64BE = hasWrite64BE
+        ? (buf, offset, value) => {
+            buf.writeBigUInt64BE(value, offset);
+        }
+        : (buf, offset, value) => {
+            let temp = value;
+            for (let i = 7; i >= 0; i--) {
+                buf[offset + i] = Number(temp & 0xffn);
+                temp >>= 8n;
+            }
+        };
+    const bufferToBigIntLE = (buf) => {
+        let result = 0n;
+        let multiplier = 1n;
+        const len = buf.length;
+        const remainder = len & 7;
+        for (let i = 0; i < remainder; i++) {
+            result += BigInt(buf[i]) * multiplier;
+            multiplier <<= 8n;
+        }
+        for (let offset = remainder; offset < len; offset += 8) {
+            const chunk = read64LE(buf, offset);
+            result += chunk * multiplier;
+            multiplier <<= 64n;
+        }
+        return result;
+    };
+    const bufferToBigIntBE = (buf) => {
+        const len = buf.length;
+        if (len === 0)
+            return 0n;
+        let result = 0n;
+        const remainder = len & 7;
+        let offset = 0;
+        if (remainder !== 0) {
+            for (; offset < remainder; offset++) {
+                result = (result << 8n) + BigInt(buf[offset]);
+            }
+        }
+        for (; offset < len; offset += 8) {
+            const chunk = read64BE(buf, offset);
+            result = (result << 64n) + chunk;
+        }
+        return result;
+    };
+    const writeBigIntToBufferLE = (num, target) => {
+        const width = target.length;
+        let remaining = num;
+        let offset = 0;
+        const limit = width - (width % 8);
+        for (; offset < limit; offset += 8) {
+            write64LE(target, offset, remaining & 0xffffffffffffffffn);
+            remaining >>= 64n;
+        }
+        for (; offset < width; offset++) {
+            target[offset] = Number(remaining & 0xffn);
+            remaining >>= 8n;
+        }
+        return target;
+    };
+    const writeBigIntToBufferBE = (num, target) => {
+        const width = target.length;
+        let remaining = num;
+        let offset = width;
+        const limit = width & ~7;
+        while (offset > limit) {
+            offset--;
+            target[offset] = Number(remaining & 0xffn);
+            remaining >>= 8n;
+        }
+        for (; offset > 0; offset -= 8) {
+            const chunk = remaining & 0xffffffffffffffffn;
+            write64BE(target, offset - 8, chunk);
+            remaining >>= 64n;
+        }
+        return target;
+    };
+    const toBufferInput = (input) => {
+        if (Buffer.isBuffer(input))
+            return input;
+        if (input instanceof Uint8Array) {
+            return Buffer.from(input.buffer, input.byteOffset, input.byteLength);
+        }
+        return Buffer.from(input);
+    };
+    const assertWidth = (width, fnName) => {
+        if (!Number.isInteger(width) || width < 0) {
+            throw new RangeError(`${fnName} width must be a non-negative integer`);
+        }
+    };
+    if (!converter_1.IS_BROWSER) {
+        converter = (0, converter_1.loadNative)();
+    }
+    if (converter === undefined) {
+        converter = {
+            toBigInt: (buf, bigEndian = true) => bigEndian ? bufferToBigIntBE(buf) : bufferToBigIntLE(buf),
+            fromBigInt: (num, buf, bigEndian = true) => bigEndian
+                ? writeBigIntToBufferBE(num, buf)
+                : writeBigIntToBufferLE(num, buf),
+        };
+    }
+    function toBigIntLE(buf) {
+        if (converter === undefined)
+            return 0n;
+        return converter.toBigInt(toBufferInput(buf), false);
+    }
+    function validateBigIntBuffer() {
+        try {
+            const test = toBigIntLE(Buffer.from([0x01, 0x00]));
+            return test === BigInt(1);
+        }
+        catch {
+            return false;
+        }
+    }
+    function toBigIntBE(buf) {
+        if (converter === undefined)
+            return 0n;
+        return converter.toBigInt(toBufferInput(buf), true);
+    }
+    function toBufferLE(num, width) {
+        assertWidth(width, "toBufferLE");
+        if (converter === undefined)
+            return Buffer.alloc(0);
+        return converter.fromBigInt(num, Buffer.allocUnsafe(width), false);
+    }
+    function toBufferBE(num, width) {
+        assertWidth(width, "toBufferBE");
+        if (converter === undefined)
+            return Buffer.alloc(0);
+        return converter.fromBigInt(num, Buffer.allocUnsafe(width), true);
+    }
+    function parseHex(a, prefix0x = false, byteLength) {
+        const hexMatch = a.match(/^(0x)?([\da-fA-F]+)$/);
+        if (hexMatch == null) {
+            throw new RangeError("input must be a hexadecimal string, e.g. '0x124fe3a' or '0214f1b2'");
+        }
+        let hex = hexMatch[2];
+        if (byteLength !== undefined) {
+            if (byteLength < hex.length / 2) {
+                throw new RangeError(`expected byte length ${byteLength} < input hex byte length ${Math.ceil(hex.length / 2)}`);
+            }
+            hex = hex.padStart(byteLength * 2, "0");
+        }
+        return prefix0x ? "0x" + hex : hex;
+    }
+    function bigintToBuf(a, returnArrayBuffer = false) {
+        if (a < 0) {
+            throw RangeError("a should be a non-negative integer. Negative values are not supported");
+        }
+        return hexToBuf(bigintToHex(a), returnArrayBuffer);
+    }
+    function bufToBigint(buf) {
+        let bits = 8n;
+        if (ArrayBuffer.isView(buf)) {
+            bits = BigInt(buf.BYTES_PER_ELEMENT * 8);
+        }
+        else {
+            buf = new Uint8Array(buf);
+        }
+        let ret = 0n;
+        for (const i of buf.values()) {
+            const bi = BigInt(i);
+            ret = (ret << bits) + bi;
+        }
+        return ret;
+    }
+    function bigintToHex(a, prefix0x = false, byteLength) {
+        if (a < 0) {
+            throw RangeError("a should be a non-negative integer. Negative values are not supported");
+        }
+        return parseHex(a.toString(16), prefix0x, byteLength);
+    }
+    function hexToBigint(hexStr) {
+        return BigInt(parseHex(hexStr, true));
+    }
+    function bigintToText(a) {
+        if (a < 0) {
+            throw RangeError("a should be a non-negative integer. Negative values are not supported");
+        }
+        return bufToText(hexToBuf(a.toString(16)));
+    }
+    function textToBigint(text) {
+        return hexToBigint(bufToHex(textToBuf(text)));
+    }
+    function toBuffer(input) {
+        if (Buffer.isBuffer(input)) {
+            return input;
+        }
+        if (ArrayBuffer.isView(input)) {
+            return Buffer.from(input.buffer, input.byteOffset, input.byteLength);
+        }
+        if (input instanceof ArrayBuffer) {
+            return Buffer.from(new Uint8Array(input));
+        }
+        throw new TypeError("Unsupported input type for Buffer.from");
+    }
+    function bufToText(buf) {
+        const input = toBuffer(buf);
+        if (converter_1.IS_BROWSER) {
+            return new TextDecoder().decode(new Uint8Array(input));
+        }
+        else {
+            return Buffer.from(input).toString();
+        }
+    }
+    function textToBuf(str, returnArrayBuffer = false) {
+        if (!converter_1.IS_BROWSER && !returnArrayBuffer) {
+            return Buffer.from(new TextEncoder().encode(str).buffer);
+        }
+        return new TextEncoder().encode(str).buffer;
+    }
+    function bufToHex(buf, prefix0x = false, byteLength) {
+        if (converter_1.IS_BROWSER) {
+            let s = "";
+            const h = "0123456789abcdef";
+            if (ArrayBuffer.isView(buf)) {
+                buf = new Uint8Array(buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength));
+            }
+            else {
+                buf = new Uint8Array(buf);
+            }
+            buf.forEach((v) => {
+                s += h[v >> 4] + h[v & 15];
+            });
+            return parseHex(s, prefix0x, byteLength);
+        }
+        else {
+            const input = toBuffer(buf);
+            if (ArrayBuffer.isView(input)) {
+                buf = new Uint8Array(input.buffer.slice(input.byteOffset, input.byteOffset + input.byteLength));
+            }
+            return parseHex(Buffer.from(toBuffer(buf)).toString("hex"), prefix0x, byteLength);
+        }
+    }
+    function hexToBuf(hexStr, returnArrayBuffer = false) {
+        let hex = parseHex(hexStr);
+        hex = parseHex(hexStr, false, Math.ceil(hex.length / 2));
+        if (converter_1.IS_BROWSER) {
+            return Uint8Array.from(hex.match(/[\da-fA-F]{2}/g).map((h) => {
+                return Number("0x" + h);
+            })).buffer;
+        }
+        else {
+            const b = Buffer.from(hex, "hex");
+            return returnArrayBuffer
+                ? b.buffer.slice(b.byteOffset, b.byteOffset + b.byteLength)
+                : b;
+        }
+    }
+    function bigintToBase64(a, urlsafe = false, padding = true) {
+        if (a < 0n) {
+            throw new RangeError("negative bigint");
+        }
+        const buf = bigintToBuf(a);
+        let base64 = Buffer.isBuffer(buf)
+            ? buf.toString("base64")
+            : Buffer.from(buf).toString("base64");
+        if (urlsafe) {
+            base64 = base64.replace(/\+/g, "-").replace(/\//g, "_");
+        }
+        if (!padding) {
+            base64 = base64.replace(/=+$/, "");
+        }
+        return base64;
+    }
+    function base64ToBigint(a) {
+        if (!a || a.trim() === "") {
+            return 0n;
+        }
+        const cleaned = a.trim();
+        if (!/^[A-Za-z0-9+/=_-]*$/.test(cleaned)) {
+            throw new RangeError("invalid base64");
+        }
+        let base64 = cleaned.replace(/-/g, "+").replace(/_/g, "/");
+        while (base64.length % 4 !== 0) {
+            base64 += "=";
+        }
+        const buf = Buffer.from(base64, "base64");
+        return bufToBigint(buf);
+    }
+    exports.FIXED_POINT_DECIMALS = 9;
+    exports.FIXED_POINT_PATTERN = /^-?0x[0-9a-f]+$/i;
+    exports.ZERO_FIXED_POINT = "0x0";
+    const normalizeHex = (value) => value.startsWith("0x") || value.startsWith("0X") ? value : `0x${value}`;
+    const toHexString = (value) => {
+        if (value === 0n) {
+            return exports.ZERO_FIXED_POINT;
+        }
+        const isNegative = value < 0n;
+        const absValue = isNegative ? -value : value;
+        const hexValue = bigintToHex(absValue);
+        return `${isNegative ? "-" : ""}0x${hexValue}`;
+    };
+    exports.toHexString = toHexString;
+    const toBigIntValue = (value) => {
+        if (!value) {
+            return 0n;
+        }
+        const trimmed = value.trim();
+        if (trimmed.length === 0) {
+            return 0n;
+        }
+        const isNegative = trimmed.startsWith("-");
+        const body = isNegative ? trimmed.slice(1) : trimmed;
+        const normalized = normalizeHex(body);
+        const bigValue = hexToBigint(normalized);
+        return isNegative ? -bigValue : bigValue;
+    };
+    exports.toBigIntValue = toBigIntValue;
+    function toFixedPoint(value, decimals = exports.FIXED_POINT_DECIMALS) {
+        if (!Number.isFinite(value)) {
+            return exports.ZERO_FIXED_POINT;
+        }
+        const scale = 10n ** BigInt(decimals);
+        const scaled = BigInt(Math.round(value * Number(scale)));
+        return (0, exports.toHexString)(scaled);
+    }
+    function fromFixedPoint(value, decimals = 9) {
+        if (!value)
+            return 0;
+        const trimmed = value.trim();
+        if (trimmed.length === 0)
+            return 0;
+        const isNegative = trimmed.startsWith('-');
+        const body = isNegative ? trimmed.slice(1) : trimmed;
+        const bigValue = isNegative ? -BigInt(body) : BigInt(body);
+        const scale = 10 ** decimals;
+        return Number(bigValue) / scale;
+    }
+    function addFixedPoint(a, b) {
+        return (0, exports.toHexString)((0, exports.toBigIntValue)(a) + (0, exports.toBigIntValue)(b));
+    }
+    function subtractFixedPoint(a, b) {
+        return (0, exports.toHexString)((0, exports.toBigIntValue)(a) - (0, exports.toBigIntValue)(b));
+    }
+    function averageFixedPoint(values) {
+        if (values.length === 0) {
+            return exports.ZERO_FIXED_POINT;
+        }
+        const sum = values.reduce((acc, value) => acc + (0, exports.toBigIntValue)(value), 0n);
+        return (0, exports.toHexString)(sum / BigInt(values.length));
+    }
+    function compareFixedPoint(a, b) {
+        const diff = (0, exports.toBigIntValue)(a) - (0, exports.toBigIntValue)(b);
+        if (diff === 0n) {
+            return 0;
+        }
+        return diff > 0n ? 1 : -1;
+    }
+    function fixedPointToBigInt(value) {
+        return (0, exports.toBigIntValue)(value);
+    }
+
+})();