@gsknnft/bigint-buffer 1.4.3 → 1.4.5

package/README.md

@@ -1,89 +1,98 @@
-![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:** Use `@gsknnft/bigint-buffer@1.4.3+` for verified bindings, fresh CI, and npm-based workflows across Node 18–24.
-
-[![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,
-} 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=="
-```
-
-### 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` (loads automatically when available).
-- Fallback: pure JS bundle for browser and non-native installs.
-- 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.3
-- Node: 18+ (tested through 24 LTS)
-- Issues: https://github.com/gsknnft/bigint-buffer/issues
+![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:** `1.4.5` adds FixedPoint utilities, native bindings in `build/Release/` out of the box, and improved JS fallback for environments without native support. CI-verified for Node 20–24. All users should upgrade for best compatibility and new features.
+
+[![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
+```
+
+### 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

package/build/binding.sln

@@ -4,14 +4,14 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "bigint_buffer", "bigint_buf
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Release|x64 = Release|x64
 		Debug|x64 = Debug|x64
+		Release|x64 = Release|x64
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{24113E9C-F3B8-A9AC-DC29-9757A019F33F}.Release|x64.ActiveCfg = Release|x64
-		{24113E9C-F3B8-A9AC-DC29-9757A019F33F}.Release|x64.Build.0 = Release|x64
 		{24113E9C-F3B8-A9AC-DC29-9757A019F33F}.Debug|x64.ActiveCfg = Debug|x64
 		{24113E9C-F3B8-A9AC-DC29-9757A019F33F}.Debug|x64.Build.0 = Debug|x64
+		{24113E9C-F3B8-A9AC-DC29-9757A019F33F}.Release|x64.ActiveCfg = Release|x64
+		{24113E9C-F3B8-A9AC-DC29-9757A019F33F}.Release|x64.Build.0 = Release|x64
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

package/build/conversion/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./src/ts/index"), exports);
+//# sourceMappingURL=index.js.map

package/build/conversion/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/conversion/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,iDAA+B"}

package/build/conversion/src/ts/fixedPoint/index.d.ts

@@ -0,0 +1,12 @@
+export type FixedPoint = string;
+export declare const FIXED_POINT_DECIMALS = 9;
+export declare const FIXED_POINT_PATTERN: RegExp;
+export declare const ZERO_FIXED_POINT: FixedPoint;
+export declare const toBigIntValue: (value?: FixedPoint) => bigint;
+export declare function toFixedPoint(value: number, decimals?: number): FixedPoint;
+export declare function fromFixedPoint(value?: FixedPoint, decimals?: number): number;
+export declare function addFixedPoint(a: FixedPoint, b: FixedPoint): FixedPoint;
+export declare function subtractFixedPoint(a: FixedPoint, b: FixedPoint): FixedPoint;
+export declare function averageFixedPoint(values: FixedPoint[]): FixedPoint;
+export declare function compareFixedPoint(a: FixedPoint, b: FixedPoint): number;
+export declare function fixedPointToBigInt(value?: FixedPoint): bigint;

package/build/conversion/src/ts/fixedPoint/index.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toBigIntValue = exports.ZERO_FIXED_POINT = exports.FIXED_POINT_PATTERN = exports.FIXED_POINT_DECIMALS = void 0;
+exports.toFixedPoint = toFixedPoint;
+exports.fromFixedPoint = fromFixedPoint;
+exports.addFixedPoint = addFixedPoint;
+exports.subtractFixedPoint = subtractFixedPoint;
+exports.averageFixedPoint = averageFixedPoint;
+exports.compareFixedPoint = compareFixedPoint;
+exports.fixedPointToBigInt = fixedPointToBigInt;
+const _pkg_1 = require("#pkg");
+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 = (0, _pkg_1.bigintToHex)(absValue);
+    return `${isNegative ? '-' : ''}0x${hexValue}`;
+};
+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 = (0, _pkg_1.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 = Math.pow(10, decimals);
+    const scaled = BigInt(Math.round(value * scale));
+    return toHexString(scaled);
+}
+function fromFixedPoint(value, decimals = exports.FIXED_POINT_DECIMALS) {
+    const bigValue = (0, exports.toBigIntValue)(value);
+    if (bigValue === 0n) {
+        return 0;
+    }
+    const scale = Math.pow(10, decimals);
+    return Number(bigValue) / scale;
+}
+function addFixedPoint(a, b) {
+    return toHexString((0, exports.toBigIntValue)(a) + (0, exports.toBigIntValue)(b));
+}
+function subtractFixedPoint(a, b) {
+    return 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 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);
+}
+//# sourceMappingURL=index.js.map

package/build/conversion/src/ts/fixedPoint/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/conversion/src/ts/fixedPoint/index.ts"],"names":[],"mappings":"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"}

package/build/conversion/src/ts/index.d.ts

@@ -0,0 +1,169 @@
+import { Buffer } from 'buffer';
+export { toFixedPoint, fromFixedPoint, addFixedPoint, subtractFixedPoint, averageFixedPoint, compareFixedPoint, type FixedPoint, FIXED_POINT_DECIMALS, ZERO_FIXED_POINT, fixedPointToBigInt, toBigIntValue, } from './fixedPoint';
+export declare let isNative: boolean;
+/**
+ * Convert a little-endian buffer into a BigInt.
+ * @param buf The little-endian buffer to convert
+ * @returns A BigInt with the little-endian representation of buf.
+ */
+export declare function toBigIntLE(buf: Buffer): bigint;
+export declare function validateBigIntBuffer(): boolean;
+/**
+ * Convert a big-endian buffer into a BigInt
+ * @param buf The big-endian buffer to convert.
+ * @returns A BigInt with the big-endian representation of buf.
+ */
+export declare function toBigIntBE(buf: Buffer): bigint;
+/**
+ * Convert a BigInt to a little-endian buffer.
+ * @param num   The BigInt to convert.
+ * @param width The number of bytes that the resulting buffer should be.
+ * @returns A little-endian buffer representation of num.
+ */
+export declare function toBufferLE(num: bigint, width: number): Buffer;
+/**
+ * Convert a BigInt to a big-endian buffer.
+ * @param num   The BigInt to convert.
+ * @param width The number of bytes that the resulting buffer should be.
+ * @returns A big-endian buffer representation of num.
+ */
+export declare function toBufferBE(num: bigint, width: number): Buffer;
+export type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
+/**
+ * Parses a hexadecimal string for correctness and returns it with or without
+ * '0x' prefix, and/or with the specified byte length
+ * @param a - the string with an hexadecimal number to be parsed
+ * @param prefix0x - set to true to prefix the output with '0x'
+ * @param byteLength - pad the output to have the desired byte length. Notice
+ * that the hex length is double the byte length.
+ *
+ * @returns
+ *
+ * @throws {@link RangeError} if input string does not hold an hexadecimal number
+ * @throws {@link RangeError} if requested byte length is less than the input byte length
+ */
+export declare function parseHex(a: string, prefix0x?: boolean, byteLength?: number): string;
+/**
+ * Converts an arbitrary-size non-negative bigint to an ArrayBuffer or a Buffer
+ * (default for Node.js)
+ *
+ * @param a
+ * @param returnArrayBuffer - In Node.js, it forces the output to be an
+ * ArrayBuffer instead of a Buffer.
+ *
+ * @returns an ArrayBuffer or a Buffer with a binary representation of the input
+ * bigint
+ *
+ * @throws {@link RangeError} if a < 0.
+ */
+export declare function bigintToBuf(a: bigint, returnArrayBuffer?: boolean): ArrayBuffer | Buffer;
+/**
+ * Converts an ArrayBuffer, TypedArray or Buffer (node.js) to a bigint
+ * @param buf
+ * @returns a bigint
+ */
+export declare function bufToBigint(buf: ArrayBuffer | TypedArray | Buffer): bigint;
+/**
+ * Converts a non-negative bigint to a hexadecimal string
+ * @param a - a non negative bigint
+ * @param prefix0x - set to true to prefix the output with '0x'
+ * @param byteLength - pad the output to have the desired byte length. Notice
+ * that the hex length is double the byte length.
+ *
+ * @returns hexadecimal representation of the input bigint
+ *
+ * @throws {@link RangeError} if a < 0
+ */
+export declare function bigintToHex(a: bigint, prefix0x?: boolean, byteLength?: number): string;
+/**
+ * Converts a hexadecimal string to a bigint
+ *
+ * @param hexStr
+ *
+ * @returns a bigint
+ *
+ * @throws {@link RangeError} if input string does not hold an hexadecimal number
+ */
+export declare function hexToBigint(hexStr: string): bigint;
+/**
+ * Converts a non-negative bigint representing a binary array of utf-8 encoded
+ * text to a string of utf-8 text
+ *
+ * @param a - A non-negative bigint representing a binary array of utf-8 encoded
+ * text.
+ *
+ * @returns a string text with utf-8 encoding
+ *
+ * @throws {@link RangeError} if a < 0.
+ */
+export declare function bigintToText(a: bigint): string;
+/**
+ * Converts a utf-8 string to a bigint (from its binary representaion)
+ *
+ * @param text - A string text with utf-8 encoding
+ *
+ * @returns a bigint representing a binary array of the input utf-8 encoded text
+ */
+export declare function textToBigint(text: string): bigint;
+/**
+ * Converts an ArrayBuffer, TypedArray or Buffer (in Node.js) containing utf-8
+ * encoded text to a string of utf-8 text
+ *
+ * @param buf - A buffer containing utf-8 encoded text
+ *
+ * @returns a string text with utf-8 encoding
+ */
+export declare function bufToText(buf: ArrayBuffer | TypedArray | Buffer): string;
+/**
+ * Converts a string of utf-8 encoded text to an ArrayBuffer or a Buffer
+ * (default in Node.js)
+ *
+ * @param str - A string of text (with utf-8 encoding)
+ * @param returnArrayBuffer - When invoked in Node.js, it can force the output
+ * to be an ArrayBuffer instead of a Buffer.
+ *
+ * @returns an ArrayBuffer or a Buffer containing the utf-8 encoded text
+ */
+export declare function textToBuf(str: string, returnArrayBuffer?: boolean): ArrayBuffer | Buffer;
+/**
+ * Returns the hexadecimal representation of a buffer.
+ *
+ * @param buf
+ * @param prefix0x - set to true to prefix the output with '0x'
+ * @param byteLength - pad the output to have the desired byte length. Notice
+ * that the hex length is double the byte length.
+ *
+ * @returns a string with a hexadecimal representation of the input buffer
+ */
+export declare function bufToHex(buf: ArrayBuffer | TypedArray | Buffer, prefix0x?: boolean, byteLength?: number): string;
+/**
+ * Converts a hexadecimal string to a buffer
+ *
+ * @param hexStr - A string representing a number with hexadecimal notation
+ * @param returnArrayBuffer - In Node.js, it forces the output to be an
+ * ArrayBuffer instead of a Buffer.
+ *
+ * @returns An ArrayBuffer or a Buffer
+ *
+ * @throws {@link RangeError} if input string does not hold an hexadecimal number
+ */
+export declare function hexToBuf(hexStr: string, returnArrayBuffer?: boolean): ArrayBuffer | Buffer;
+/**
+ * Converts an arbitrary-size non-negative bigint to a base64 string
+ * @param a - a non negative bigint
+ * @param urlsafe - if true Base64 URL encoding is used ('+' and '/' are
+ * replaced by '-', '_')
+ * @param padding - if false, padding (trailing '=') is removed
+ * @returns a base64 representation of the input bigint
+ *
+ * @throws {RangeError}
+ * Thrown if a < 0
+ */
+export declare function bigintToBase64(a: bigint, urlsafe?: boolean, padding?: boolean): string;
+/**
+ * Converts a base64 string to bigint.
+ * @param a base64 string. It accepts standard and URL-safe base64 with and
+ * without padding
+ * @returns a bigint
+ */
+export declare function base64ToBigint(a: string): bigint;