@gsknnft/bigint-buffer 1.3.1 → 1.3.2

package/README.md

@@ -10,7 +10,7 @@
 
 As of October 2025, `bigint-buffer@1.1.5` is **compromised and flagged by multiple audit tools** due to unresolved vulnerabilities in its native bindings and transitive dependencies. No upstream patch has been published.
 
-This fork — `@gsknnft/bigint-buffer@1.2.0` — is a **sovereign override**:
+This fork — `@gsknnft/bigint-buffer@1.3.2` — is a **sovereign override**:
 - ✅ Rebuilt with modern TypeScript and Rollup
 - ✅ Native bindings patched and rebuilt via `node-gyp`
 - ✅ Browser fallback formalized via `"browser"` field
@@ -22,7 +22,7 @@ If you're using `bigint-buffer` in a secure or reproducible system, **migrate to
 ```json
 "pnpm": {
   "overrides": {
-    "bigint-buffer": "@gsknnft/bigint-buffer@1.2.0"
+    "bigint-buffer": "@gsknnft/bigint-buffer@1.3.2"
   }
 }
 ```

package/dist/index.cjs

@@ -7,6 +7,14 @@ exports.validateBigIntBuffer = validateBigIntBuffer;
 exports.toBigIntBE = toBigIntBE;
 exports.toBufferLE = toBufferLE;
 exports.toBufferBE = toBufferBE;
+exports.bigintToBuf = bigintToBuf;
+exports.bufToBigint = bufToBigint;
+exports.bigintToHex = bigintToHex;
+exports.hexToBigint = hexToBigint;
+exports.bigintToText = bigintToText;
+exports.textToBigint = textToBigint;
+exports.bigintToBase64 = bigintToBase64;
+exports.base64ToBigint = base64ToBigint;
 let converter;
 exports.isNative = false;
 if (!process.browser) {
@@ -88,3 +96,110 @@ function toBufferBE(num, width) {
     }
     return converter.fromBigInt(num, Buffer.allocUnsafe(width), true);
 }
+// ========== Conversion Utilities ==========
+/**
+ * Convert a bigint to a Buffer with automatic sizing.
+ * Uses big-endian encoding and calculates the minimum buffer size needed.
+ * @param num The bigint to convert
+ * @returns A big-endian Buffer representation
+ */
+function bigintToBuf(num) {
+    if (num < BigInt(0)) {
+        throw new Error('bigintToBuf: negative bigint values are not supported');
+    }
+    if (num === BigInt(0)) {
+        return Buffer.from([0]);
+    }
+    // Calculate the number of bytes needed
+    const hex = num.toString(16);
+    const width = Math.ceil(hex.length / 2);
+    return toBufferBE(num, width);
+}
+/**
+ * Convert a Buffer to a bigint.
+ * Assumes big-endian encoding.
+ * @param buf The buffer to convert
+ * @returns A bigint representation of the buffer
+ */
+function bufToBigint(buf) {
+    return toBigIntBE(buf);
+}
+/**
+ * Convert a bigint to a hexadecimal string.
+ * @param num The bigint to convert
+ * @returns A hexadecimal string (without '0x' prefix)
+ */
+function bigintToHex(num) {
+    if (num < BigInt(0)) {
+        throw new Error('bigintToHex: negative bigint values are not supported');
+    }
+    const hex = num.toString(16);
+    // Ensure even length for proper byte representation
+    return hex.length % 2 === 0 ? hex : '0' + hex;
+}
+/**
+ * Convert a hexadecimal string to a bigint.
+ * @param hex The hexadecimal string (with or without '0x' prefix)
+ * @returns A bigint representation
+ */
+function hexToBigint(hex) {
+    // Remove '0x' prefix if present
+    const cleanHex = hex.startsWith('0x') ? hex.slice(2) : hex;
+    if (cleanHex.length === 0) {
+        return BigInt(0);
+    }
+    return BigInt(`0x${cleanHex}`);
+}
+/**
+ * Convert a bigint to a decimal text string.
+ * @param num The bigint to convert
+ * @returns A decimal string representation
+ */
+function bigintToText(num) {
+    return num.toString(10);
+}
+/**
+ * Convert a decimal text string to a bigint.
+ * @param text The decimal string to convert
+ * @returns A bigint representation
+ */
+function textToBigint(text) {
+    if (!text?.trim()) {
+        throw new Error('textToBigint: input string cannot be empty');
+    }
+    try {
+        return BigInt(text);
+    }
+    catch (e) {
+        throw new Error(`textToBigint: invalid decimal string "${text}"`);
+    }
+}
+/**
+ * Convert a bigint to a base64 string.
+ * @param num The bigint to convert
+ * @returns A base64 string representation
+ */
+function bigintToBase64(num) {
+    if (num < BigInt(0)) {
+        throw new Error('bigintToBase64: negative bigint values are not supported');
+    }
+    const buf = bigintToBuf(num);
+    return buf.toString('base64');
+}
+/**
+ * Convert a base64 string to a bigint.
+ * @param base64 The base64 string to convert
+ * @returns A bigint representation
+ */
+function base64ToBigint(base64) {
+    if (!base64?.trim()) {
+        throw new Error('base64ToBigint: input string cannot be empty');
+    }
+    // Trim whitespace and validate base64 format (allows padding)
+    const cleaned = base64.trim();
+    if (!/^[A-Za-z0-9+/]+=*$/.test(cleaned)) {
+        throw new Error('base64ToBigint: invalid base64 string format');
+    }
+    const buf = Buffer.from(cleaned, 'base64');
+    return bufToBigint(buf);
+}

package/dist/index.d.ts

@@ -26,3 +26,53 @@ export declare function toBufferLE(num: bigint, width: number): Buffer;
  * @returns A big-endian buffer representation of num.
  */
 export declare function toBufferBE(num: bigint, width: number): Buffer;
+/**
+ * Convert a bigint to a Buffer with automatic sizing.
+ * Uses big-endian encoding and calculates the minimum buffer size needed.
+ * @param num The bigint to convert
+ * @returns A big-endian Buffer representation
+ */
+export declare function bigintToBuf(num: bigint): Buffer;
+/**
+ * Convert a Buffer to a bigint.
+ * Assumes big-endian encoding.
+ * @param buf The buffer to convert
+ * @returns A bigint representation of the buffer
+ */
+export declare function bufToBigint(buf: Buffer): bigint;
+/**
+ * Convert a bigint to a hexadecimal string.
+ * @param num The bigint to convert
+ * @returns A hexadecimal string (without '0x' prefix)
+ */
+export declare function bigintToHex(num: bigint): string;
+/**
+ * Convert a hexadecimal string to a bigint.
+ * @param hex The hexadecimal string (with or without '0x' prefix)
+ * @returns A bigint representation
+ */
+export declare function hexToBigint(hex: string): bigint;
+/**
+ * Convert a bigint to a decimal text string.
+ * @param num The bigint to convert
+ * @returns A decimal string representation
+ */
+export declare function bigintToText(num: bigint): string;
+/**
+ * Convert a decimal text string to a bigint.
+ * @param text The decimal string to convert
+ * @returns A bigint representation
+ */
+export declare function textToBigint(text: string): bigint;
+/**
+ * Convert a bigint to a base64 string.
+ * @param num The bigint to convert
+ * @returns A base64 string representation
+ */
+export declare function bigintToBase64(num: bigint): string;
+/**
+ * Convert a base64 string to a bigint.
+ * @param base64 The base64 string to convert
+ * @returns A bigint representation
+ */
+export declare function base64ToBigint(base64: string): bigint;

package/dist/index.js

@@ -0,0 +1,203 @@
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNative = void 0;
+exports.toBigIntLE = toBigIntLE;
+exports.validateBigIntBuffer = validateBigIntBuffer;
+exports.toBigIntBE = toBigIntBE;
+exports.toBufferLE = toBufferLE;
+exports.toBufferBE = toBufferBE;
+exports.bigintToBuf = bigintToBuf;
+exports.bufToBigint = bufToBigint;
+exports.bigintToHex = bigintToHex;
+exports.hexToBigint = hexToBigint;
+exports.bigintToText = bigintToText;
+exports.textToBigint = textToBigint;
+exports.bigintToBase64 = bigintToBase64;
+exports.base64ToBigint = base64ToBigint;
+let converter;
+exports.isNative = false;
+{
+    try {
+        converter = require('bindings')('bigint_buffer');
+        exports.isNative = !false && converter !== undefined;
+    }
+    catch (e) {
+        console.warn('bigint: Failed to load bindings, pure JS will be used (try npm run rebuild?)');
+    }
+}
+/**
+ * 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.
+ */
+function toBigIntLE(buf) {
+    if (converter === undefined) {
+        const reversed = Buffer.from(buf);
+        reversed.reverse();
+        const hex = reversed.toString('hex');
+        if (hex.length === 0) {
+            return BigInt(0);
+        }
+        return BigInt(`0x${hex}`);
+    }
+    return converter.toBigInt(buf, false);
+}
+function validateBigIntBuffer() {
+    try {
+        const test = toBigIntLE(Buffer.from([0x01, 0x00]));
+        return test === BigInt(1);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * 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.
+ */
+function toBigIntBE(buf) {
+    if (converter === undefined) {
+        const hex = buf.toString('hex');
+        if (hex.length === 0) {
+            return BigInt(0);
+        }
+        return BigInt(`0x${hex}`);
+    }
+    return converter.toBigInt(buf, true);
+}
+/**
+ * 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.
+ */
+function toBufferLE(num, width) {
+    if (converter === undefined) {
+        const hex = num.toString(16);
+        const buffer = Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex');
+        buffer.reverse();
+        return buffer;
+    }
+    // Allocation is done here, since it is slower using napi in C
+    return converter.fromBigInt(num, Buffer.allocUnsafe(width), false);
+}
+/**
+ * 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.
+ */
+function toBufferBE(num, width) {
+    if (converter === undefined) {
+        const hex = num.toString(16);
+        return Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex');
+    }
+    return converter.fromBigInt(num, Buffer.allocUnsafe(width), true);
+}
+// ========== Conversion Utilities ==========
+/**
+ * Convert a bigint to a Buffer with automatic sizing.
+ * Uses big-endian encoding and calculates the minimum buffer size needed.
+ * @param num The bigint to convert
+ * @returns A big-endian Buffer representation
+ */
+function bigintToBuf(num) {
+    if (num < BigInt(0)) {
+        throw new Error('bigintToBuf: negative bigint values are not supported');
+    }
+    if (num === BigInt(0)) {
+        return Buffer.from([0]);
+    }
+    // Calculate the number of bytes needed
+    const hex = num.toString(16);
+    const width = Math.ceil(hex.length / 2);
+    return toBufferBE(num, width);
+}
+/**
+ * Convert a Buffer to a bigint.
+ * Assumes big-endian encoding.
+ * @param buf The buffer to convert
+ * @returns A bigint representation of the buffer
+ */
+function bufToBigint(buf) {
+    return toBigIntBE(buf);
+}
+/**
+ * Convert a bigint to a hexadecimal string.
+ * @param num The bigint to convert
+ * @returns A hexadecimal string (without '0x' prefix)
+ */
+function bigintToHex(num) {
+    if (num < BigInt(0)) {
+        throw new Error('bigintToHex: negative bigint values are not supported');
+    }
+    const hex = num.toString(16);
+    // Ensure even length for proper byte representation
+    return hex.length % 2 === 0 ? hex : '0' + hex;
+}
+/**
+ * Convert a hexadecimal string to a bigint.
+ * @param hex The hexadecimal string (with or without '0x' prefix)
+ * @returns A bigint representation
+ */
+function hexToBigint(hex) {
+    // Remove '0x' prefix if present
+    const cleanHex = hex.startsWith('0x') ? hex.slice(2) : hex;
+    if (cleanHex.length === 0) {
+        return BigInt(0);
+    }
+    return BigInt(`0x${cleanHex}`);
+}
+/**
+ * Convert a bigint to a decimal text string.
+ * @param num The bigint to convert
+ * @returns A decimal string representation
+ */
+function bigintToText(num) {
+    return num.toString(10);
+}
+/**
+ * Convert a decimal text string to a bigint.
+ * @param text The decimal string to convert
+ * @returns A bigint representation
+ */
+function textToBigint(text) {
+    if (!text?.trim()) {
+        throw new Error('textToBigint: input string cannot be empty');
+    }
+    try {
+        return BigInt(text);
+    }
+    catch (e) {
+        throw new Error(`textToBigint: invalid decimal string "${text}"`);
+    }
+}
+/**
+ * Convert a bigint to a base64 string.
+ * @param num The bigint to convert
+ * @returns A base64 string representation
+ */
+function bigintToBase64(num) {
+    if (num < BigInt(0)) {
+        throw new Error('bigintToBase64: negative bigint values are not supported');
+    }
+    const buf = bigintToBuf(num);
+    return buf.toString('base64');
+}
+/**
+ * Convert a base64 string to a bigint.
+ * @param base64 The base64 string to convert
+ * @returns A bigint representation
+ */
+function base64ToBigint(base64) {
+    if (!base64?.trim()) {
+        throw new Error('base64ToBigint: input string cannot be empty');
+    }
+    // Trim whitespace and validate base64 format (allows padding)
+    const cleaned = base64.trim();
+    if (!/^[A-Za-z0-9+/]+=*$/.test(cleaned)) {
+        throw new Error('base64ToBigint: invalid base64 string format');
+    }
+    const buf = Buffer.from(cleaned, 'base64');
+    return bufToBigint(buf);
+}

package/dist/node.js

@@ -1,5 +1,6 @@
-'use strict';
-
+var __importDefault = (undefined && undefined.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isNative = void 0;
 exports.toBigIntLE = toBigIntLE;
@@ -7,6 +8,9 @@ exports.validateBigIntBuffer = validateBigIntBuffer;
 exports.toBigIntBE = toBigIntBE;
 exports.toBufferLE = toBufferLE;
 exports.toBufferBE = toBufferBE;
+// etc.
+const bindings_1 = __importDefault(require("bindings"));
+(0, bindings_1.default)('bigint_buffer');
 let converter;
 exports.isNative = false;
 {

package/package.json

@@ -1,100 +1,96 @@
-{
-  "name": "@gsknnft/bigint-buffer",
-  "version": "1.3.1",
-  "description": "bigint to buffer conversion with native support",
-  "main": "dist/index.js",
-  "type": "module",
-  "browser": {
-    "./dist/node.js": "./dist/browser.js"
-  },
-  "types": "dist/index.d.ts",
-  "scripts": {
-    "test": "npm run test:node && npm run test:browser",
-    "coverage": "istanbul cover ./test/index.js",
-    "coveralls": "npm run coverage && coveralls <coverage/lcov.info",
-    "lint": "gts check",
-    "install": "npm run rebuild || echo \"Couldn't build bindings. Non-native version used.\"",
-    "prepare": "npm run compile",
-    "prepublishOnly": "rm -rf build/Release; rm build/Makefile; rm build/gyp-*; rm build/*.mk; rm build/*.Makefile; rm *.tgz",
-    "test:browser": "karma start karma.conf.js",
-    "test:node": "mocha -r ts-node/register src/**/*.spec.ts --timeout 40000",
-    "benchmark": "node -r ts-node/register src/index.bench.ts",
-    "typedoc": "typedoc --out docs $(pwd)/src $(pwd)/helper --target es6 --mode file --tsconfig ./tsconfig.json --excludePrivate --excludeProtected --excludeNotExported --exclude '**/*+(spec|bench).ts'",
-    "rebuild": "node-gyp rebuild",
-    "check": "gts check",
-    "clean": "gts clean",
-    "compile": "tsc -p . && rollup -c rollup.cjs.config.js && rollup -c rollup.esm.config.js && cpy build/src/*.d.ts dist",
-    "compileOG": "mkdirp dist && tsc -p . && rollup -c > dist/node.js && cross-env BROWSER=true rollup -c > dist/browser.js && cpx \"build/src/*.d.ts\" dist",
-    "fix": "gts fix",
-    "pretest": "npm run compile",
-    "posttest": "npm run check"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/gsknnft/bigint-buffer.git"
-  },
-  "bugs": {
-    "url": "https://github.com/gsknnft/bigint-buffer/issues"
-  },
-  "homepage": "https://github.com/gsknnft/bigintbuffer",
-  "keywords": [
-    "bigint",
-    "bignum",
-    "tc39-bigint",
-    "napi"
-  ],
-  "license": "Apache-2.0",
-  "dependencies": {
-    "bindings": "^1.5.0"
-  },
-  "devDependencies": {
-    "@types/benchmark": "^2.1.5",
-    "@types/bn.js": "^5.2.0",
-    "@types/chai": "^5.2.3",
-    "@types/mocha": "^10.0.10",
-    "@types/node": "^24.9.1",
-    "benchmark": "^2.1.4",
-    "bn.js": "^5.2.2",
-    "chai": "^4.1.2",
-    "coveralls": "^3.1.1",
-    "cpy-cli": "^6.0.0",
-    "cross-env": "^6.0.3",
-    "gts": "^0.8.0",
-    "istanbul": "^0.4.1",
-    "karma": "^3.0.0",
-    "karma-chrome-launcher": "^2.2.0",
-    "karma-env-preprocessor": "^0.1.1",
-    "karma-mocha": "^1.3.0",
-    "karma-mocha-reporter": "^2.2.5",
-    "karma-webpack": "^3.0.0",
-    "microtime": "^3.0.0",
-    "mkdirp": "^0.5.1",
-    "mocha": "^5.2.0",
-    "pre-commit": "^1.2.2",
-    "rollup": "^4.52.5",
-    "rollup-plugin-replace": "^2.2.0",
-    "ts-loader": "^9.5.4",
-    "ts-node": "^10.9.2",
-    "typedoc": "^0.28.14",
-    "typescript": "5.9.3",
-    "webpack": "5.102.1",
-    "webpack-cli": "6.0.1"
-  },
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs",
-      "types": "./dist/index.d.ts"
-    }
-  },
-  "engines": {
-    "node": ">=24.0.0"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "contributors": [
-    "Gordon Skinner <gsknnft@gmail.com> (https://github.com/gsknnft)",
-    "Michael Wei <mwei@vmware.com> (https://github.com/no2chem)"
-  ]
-}
+{
+  "name": "@gsknnft/bigint-buffer",
+  "version": "1.3.2",
+  "description": "bigint to buffer conversion with native support",
+  "main": "dist/index.js",
+  "browser": {
+    "./dist/node.js": "./dist/browser.js"
+  },
+  "types": "dist/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/gsknnft/bigint-buffer.git"
+  },
+  "bugs": {
+    "url": "https://github.com/gsknnft/bigint-buffer/issues"
+  },
+  "homepage": "https://github.com/gsknnft/bigintbuffer",
+  "keywords": [
+    "bigint",
+    "bignum",
+    "tc39-bigint",
+    "napi"
+  ],
+  "license": "Apache-2.0",
+  "dependencies": {
+    "bindings": "^1.5.0"
+  },
+  "devDependencies": {
+    "@types/benchmark": "^2.1.5",
+    "@types/bn.js": "^5.2.0",
+    "@types/chai": "^5.2.3",
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^24.9.1",
+    "benchmark": "^2.1.4",
+    "bn.js": "^5.2.2",
+    "chai": "^4.1.2",
+    "coveralls": "^3.1.1",
+    "cpy-cli": "^6.0.0",
+    "cross-env": "^6.0.3",
+    "gts": "^0.8.0",
+    "istanbul": "^0.4.1",
+    "karma": "^3.0.0",
+    "karma-chrome-launcher": "^2.2.0",
+    "karma-env-preprocessor": "^0.1.1",
+    "karma-mocha": "^1.3.0",
+    "karma-mocha-reporter": "^2.2.5",
+    "karma-webpack": "^3.0.0",
+    "microtime": "^3.0.0",
+    "mkdirp": "^0.5.1",
+    "mocha": "^5.2.0",
+    "pre-commit": "^1.2.2",
+    "rollup": "^4.52.5",
+    "@rollup/plugin-replace": "6.0.3",
+    "ts-loader": "^9.5.4",
+    "ts-node": "^10.9.2",
+    "typedoc": "^0.28.14",
+    "typescript": "5.9.3",
+    "webpack": "5.102.1",
+    "webpack-cli": "6.0.1"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "contributors": [
+    "Gordon Skinner <gsknnft@gmail.com> (https://github.com/gsknnft)",
+    "Michael Wei <mwei@vmware.com> (https://github.com/no2chem)"
+  ],
+  "scripts": {
+    "test": "npm run test:node && npm run test:browser",
+    "coverage": "istanbul cover ./test/index.js",
+    "coveralls": "npm run coverage && coveralls <coverage/lcov.info",
+    "lint": "gts check",
+    "install": "npm run rebuild || echo \"Couldn't build bindings. Non-native version used.\"",
+    "test:browser": "karma start karma.conf.js",
+    "test:node": "mocha build/src/**/*.spec.js --timeout 40000",
+    "benchmark": "node -r ts-node/register src/index.bench.ts",
+    "typedoc": "typedoc --out docs $(pwd)/src $(pwd)/helper --target es6 --mode file --tsconfig ./tsconfig.json --excludePrivate --excludeProtected --excludeNotExported --exclude '**/*+(spec|bench).ts'",
+    "rebuild": "node-gyp rebuild",
+    "check": "gts check",
+    "clean": "gts clean",
+    "compile": "tsc -p . && rollup -c rollup.cjs.config.js && rollup -c rollup.esm.config.js && cp build/src/index.d.ts dist/index.d.ts",
+    "fix": "gts fix",
+    "pretest": "npm run compile",
+    "posttest": "npm run check"
+  }
+}

package/rollup.esm.config.js

@@ -1,13 +1,15 @@
-import replace from 'rollup-plugin-replace';
+import replace from '@rollup/plugin-replace';
 
 export default {
     input: 'build/src/index.js',
     output: {
-        format: 'cjs'
+        file: 'dist/index.js',
+        format: 'esm'
     },
+    external: ['bindings'],
     plugins: [
         replace({
-            'process.browser': process.env.BROWSER === "true"
+            'process.browser': 'false'
         })
     ]
 };

package/src/index.spec.ts

@@ -4,8 +4,9 @@ declare var process: {browser: boolean;};
 import * as chai from 'chai';
 import * as path from 'path';
 
-const lib = process.browser ? require('../../dist/browser') :
-                              require(path.join(__dirname, '../dist/node'));
+const lib = process.browser ?
+    require('../../dist/index.js') :
+    require(path.join(__dirname, '../../dist/index.cjs'));
 const toBigIntBE = lib.toBigIntBE;
 const toBigIntLE = lib.toBigIntLE;
 const toBufferBE = lib.toBufferBE;
@@ -284,4 +285,160 @@ describe('Try bigint conversion (big endian)', () => {
           0xe0, 0xdd, 0xf0, 0x0d, 0xde, 0xad, 0xbe, 0xef
         ]));
   });
+});
+
+describe('Conversion Utilities - bigintToBuf and bufToBigint', () => {
+  const bigintToBuf = lib.bigintToBuf;
+  const bufToBigint = lib.bufToBigint;
+
+  it('should convert 0 to buffer', () => {
+    const buf = bigintToBuf(BigInt(0));
+    buf.should.deep.equal(Buffer.from([0]));
+  });
+
+  it('should convert small number to buffer', () => {
+    const buf = bigintToBuf(BigInt(123456789));
+    assertEquals(bufToBigint(buf), BigInt(123456789));
+  });
+
+  it('should round-trip convert medium numbers', () => {
+    const original = BigInt('0xdeadbeef');
+    const buf = bigintToBuf(original);
+    const result = bufToBigint(buf);
+    assertEquals(result, original);
+  });
+
+  it('should round-trip convert large numbers', () => {
+    const original = BigInt('0xbadc0ffee0ddf00ddeadbeef');
+    const buf = bigintToBuf(original);
+    const result = bufToBigint(buf);
+    assertEquals(result, original);
+  });
+
+  it('should throw error for negative bigint', () => {
+    chai.expect(() => bigintToBuf(BigInt(-1))).to.throw('negative bigint');
+  });
+});
+
+describe('Conversion Utilities - bigintToHex and hexToBigint', () => {
+  const bigintToHex = lib.bigintToHex;
+  const hexToBigint = lib.hexToBigint;
+
+  it('should convert 0 to hex', () => {
+    bigintToHex(BigInt(0)).should.equal('00');
+  });
+
+  it('should convert small number to hex', () => {
+    bigintToHex(BigInt(255)).should.equal('ff');
+  });
+
+  it('should convert number to even-length hex', () => {
+    bigintToHex(BigInt(15)).should.equal('0f');
+  });
+
+  it('should convert hex string to bigint', () => {
+    assertEquals(hexToBigint('deadbeef'), BigInt('0xdeadbeef'));
+  });
+
+  it('should handle hex string with 0x prefix', () => {
+    assertEquals(hexToBigint('0xdeadbeef'), BigInt('0xdeadbeef'));
+  });
+
+  it('should round-trip convert', () => {
+    const original = BigInt('0xbadc0ffee0ddf00ddeadbeef');
+    const hex = bigintToHex(original);
+    const result = hexToBigint(hex);
+    assertEquals(result, original);
+  });
+
+  it('should handle empty string', () => {
+    assertEquals(hexToBigint(''), BigInt(0));
+  });
+
+  it('should throw error for negative bigint', () => {
+    chai.expect(() => bigintToHex(BigInt(-1))).to.throw('negative bigint');
+  });
+});
+
+describe('Conversion Utilities - bigintToText and textToBigint', () => {
+  const bigintToText = lib.bigintToText;
+  const textToBigint = lib.textToBigint;
+
+  it('should convert 0 to text', () => {
+    bigintToText(BigInt(0)).should.equal('0');
+  });
+
+  it('should convert positive number to text', () => {
+    bigintToText(BigInt(123456789)).should.equal('123456789');
+  });
+
+  it('should convert large number to text', () => {
+    bigintToText(BigInt('0xdeadbeef')).should.equal('3735928559');
+  });
+
+  it('should convert text to bigint', () => {
+    assertEquals(textToBigint('123456789'), BigInt(123456789));
+  });
+
+  it('should round-trip convert', () => {
+    const original = BigInt('9876543210123456789');
+    const text = bigintToText(original);
+    const result = textToBigint(text);
+    assertEquals(result, original);
+  });
+
+  it('should throw error for empty string', () => {
+    chai.expect(() => textToBigint('')).to.throw('cannot be empty');
+  });
+
+  it('should throw error for invalid decimal string', () => {
+    chai.expect(() => textToBigint('abc')).to.throw('invalid decimal');
+  });
+});
+
+describe('Conversion Utilities - bigintToBase64 and base64ToBigint', () => {
+  const bigintToBase64 = lib.bigintToBase64;
+  const base64ToBigint = lib.base64ToBigint;
+
+  it('should convert 0 to base64', () => {
+    const b64 = bigintToBase64(BigInt(0));
+    b64.should.be.a('string');
+    assertEquals(base64ToBigint(b64), BigInt(0));
+  });
+
+  it('should convert small number to base64', () => {
+    const original = BigInt(123456789);
+    const b64 = bigintToBase64(original);
+    b64.should.equal('B1vNFQ==');
+  });
+
+  it('should convert base64 to bigint', () => {
+    assertEquals(base64ToBigint('B1vNFQ=='), BigInt(123456789));
+  });
+
+  it('should round-trip convert medium numbers', () => {
+    const original = BigInt('0xdeadbeef');
+    const b64 = bigintToBase64(original);
+    const result = base64ToBigint(b64);
+    assertEquals(result, original);
+  });
+
+  it('should round-trip convert large numbers', () => {
+    const original = BigInt('0xbadc0ffee0ddf00ddeadbeef');
+    const b64 = bigintToBase64(original);
+    const result = base64ToBigint(b64);
+    assertEquals(result, original);
+  });
+
+  it('should throw error for negative bigint', () => {
+    chai.expect(() => bigintToBase64(BigInt(-1))).to.throw('negative bigint');
+  });
+
+  it('should throw error for empty base64 string', () => {
+    chai.expect(() => base64ToBigint('')).to.throw('cannot be empty');
+  });
+
+  it('should throw error for invalid base64 string', () => {
+    chai.expect(() => base64ToBigint('invalid!@#')).to.throw('invalid base64');
+  });
 });

package/src/index.ts

@@ -92,4 +92,119 @@ export function toBufferBE(num: bigint, width: number): Buffer {
     return Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex');
   }
   return converter.fromBigInt(num, Buffer.allocUnsafe(width), true);
+}
+
+// ========== Conversion Utilities ==========
+
+/**
+ * Convert a bigint to a Buffer with automatic sizing.
+ * Uses big-endian encoding and calculates the minimum buffer size needed.
+ * @param num The bigint to convert
+ * @returns A big-endian Buffer representation
+ */
+export function bigintToBuf(num: bigint): Buffer {
+  if (num < BigInt(0)) {
+    throw new Error('bigintToBuf: negative bigint values are not supported');
+  }
+  if (num === BigInt(0)) {
+    return Buffer.from([0]);
+  }
+  // Calculate the number of bytes needed
+  const hex = num.toString(16);
+  const width = Math.ceil(hex.length / 2);
+  return toBufferBE(num, width);
+}
+
+/**
+ * Convert a Buffer to a bigint.
+ * Assumes big-endian encoding.
+ * @param buf The buffer to convert
+ * @returns A bigint representation of the buffer
+ */
+export function bufToBigint(buf: Buffer): bigint {
+  return toBigIntBE(buf);
+}
+
+/**
+ * Convert a bigint to a hexadecimal string.
+ * @param num The bigint to convert
+ * @returns A hexadecimal string (without '0x' prefix)
+ */
+export function bigintToHex(num: bigint): string {
+  if (num < BigInt(0)) {
+    throw new Error('bigintToHex: negative bigint values are not supported');
+  }
+  const hex = num.toString(16);
+  // Ensure even length for proper byte representation
+  return hex.length % 2 === 0 ? hex : '0' + hex;
+}
+
+/**
+ * Convert a hexadecimal string to a bigint.
+ * @param hex The hexadecimal string (with or without '0x' prefix)
+ * @returns A bigint representation
+ */
+export function hexToBigint(hex: string): bigint {
+  // Remove '0x' prefix if present
+  const cleanHex = hex.startsWith('0x') ? hex.slice(2) : hex;
+  if (cleanHex.length === 0) {
+    return BigInt(0);
+  }
+  return BigInt(`0x${cleanHex}`);
+}
+
+/**
+ * Convert a bigint to a decimal text string.
+ * @param num The bigint to convert
+ * @returns A decimal string representation
+ */
+export function bigintToText(num: bigint): string {
+  return num.toString(10);
+}
+
+/**
+ * Convert a decimal text string to a bigint.
+ * @param text The decimal string to convert
+ * @returns A bigint representation
+ */
+export function textToBigint(text: string): bigint {
+  if (!text?.trim()) {
+    throw new Error('textToBigint: input string cannot be empty');
+  }
+  try {
+    return BigInt(text);
+  } catch (e) {
+    throw new Error(`textToBigint: invalid decimal string "${text}"`);
+  }
+}
+
+/**
+ * Convert a bigint to a base64 string.
+ * @param num The bigint to convert
+ * @returns A base64 string representation
+ */
+export function bigintToBase64(num: bigint): string {
+  if (num < BigInt(0)) {
+    throw new Error('bigintToBase64: negative bigint values are not supported');
+  }
+  const buf = bigintToBuf(num);
+  return buf.toString('base64');
+}
+
+/**
+ * Convert a base64 string to a bigint.
+ * @param base64 The base64 string to convert
+ * @returns A bigint representation
+ */
+export function base64ToBigint(base64: string): bigint {
+  if (!base64?.trim()) {
+    throw new Error('base64ToBigint: input string cannot be empty');
+  }
+  // Trim whitespace and validate base64 format (allows padding)
+  const cleaned = base64.trim();
+  if (!/^[A-Za-z0-9+/]+=*$/.test(cleaned)) {
+    throw new Error('base64ToBigint: invalid base64 string format');
+  }
+  const buf = Buffer.from(cleaned, 'base64');
+  return bufToBigint(buf);
 }

package/dist/browser.js

@@ -1,75 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isNative = void 0;
-exports.toBigIntLE = toBigIntLE;
-exports.validateBigIntBuffer = validateBigIntBuffer;
-exports.toBigIntBE = toBigIntBE;
-exports.toBufferLE = toBufferLE;
-exports.toBufferBE = toBufferBE;
-exports.isNative = false;
-/**
- * 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.
- */
-function toBigIntLE(buf) {
-    {
-        const reversed = Buffer.from(buf);
-        reversed.reverse();
-        const hex = reversed.toString('hex');
-        if (hex.length === 0) {
-            return BigInt(0);
-        }
-        return BigInt(`0x${hex}`);
-    }
-}
-function validateBigIntBuffer() {
-    try {
-        const test = toBigIntLE(Buffer.from([0x01, 0x00]));
-        return test === BigInt(1);
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * 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.
- */
-function toBigIntBE(buf) {
-    {
-        const hex = buf.toString('hex');
-        if (hex.length === 0) {
-            return BigInt(0);
-        }
-        return BigInt(`0x${hex}`);
-    }
-}
-/**
- * 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.
- */
-function toBufferLE(num, width) {
-    {
-        const hex = num.toString(16);
-        const buffer = Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex');
-        buffer.reverse();
-        return 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.
- */
-function toBufferBE(num, width) {
-    {
-        const hex = num.toString(16);
-        return Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex');
-    }
-}

package/dist/index.bench.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/index.spec.d.ts

@@ -1 +0,0 @@
-import 'mocha';