@gsknnft/bigint-buffer 1.3.2 → 1.4.1

package/.travis.yml

@@ -1,7 +1,7 @@
 language: node_js
 node_js:
 - node
-- '10'
+- '24'
 sudo : false
 env:
   global:
@@ -16,19 +16,19 @@ services:
   - xvfb
 cache:
   directories:
-   - $HOME/.npm
+   - $HOME/.pnpm
 matrix:
   fast_finish: true
   include:
   - os: linux
-    node_js: '10'
+    node_js: '24'
     env: TEST_SUITE=test:browser
   - os: windows
-    node_js: '10'
+    node_js: '24'
     env: TEST_SUITE=test:node
-script: npm run $TEST_SUITE
+script: pnpm run $TEST_SUITE
 before_deploy:
-- npm pack
+- pnpm pack
 deploy:
 - provider: releases
   api_key: "$GITHUB_TOKEN"
@@ -36,16 +36,16 @@ deploy:
   file: bigint-buffer-*.tgz
   skip_cleanup: true
   on:
-    branch: master
+    branch: main
     node: '10'
     condition: "$TEST_SUITE = test:node"
     tags: true
 - provider: npm
   api_key: "$NPM_TOKEN"
   skip_cleanup: true
-  email: mwei@cs.ucsd.edu
+  email: gsknnft@gmail.com
   on:
-    branch: master
-    node: '10'
+    branch: main
+    node: '24'
     condition: "$TEST_SUITE = test:node"
     tags: true

package/README.md

@@ -2,15 +2,22 @@
 
 [![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)
-[![Maintained Fork](https://img.shields.io/badge/fork-maintained-blue?style=flat-square)](https://github.com/gsknnft/bigintbuffer)
+[![Maintained Fork](https://img.shields.io/badge/fork-maintained-blue?style=flat-square)](https://github.com/gsknnft/bigint-buffer)
+Modern, secure BigInt ↔ Buffer conversion with native bindings, browser fallbacks, and the full `bigint-conversion` API built in.
 
 ---
 
 ## 🔐 Security Notice: This Module Has Been Reclaimed
+This fork (`@gsknnft/bigint-buffer`) is actively maintained, secure, and recommended for all users. Native now builds clean. All conversion helpers are live and set.
+**removed useless deps - back to ZERO dependancies unless chosen native bindings**
+---
+
+Modern, secure BigInt ↔ Buffer conversion with native bindings, browser fallbacks, and the full `bigint-conversion` API built in.
 
 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.
+As the original `bigint-buffer` package is deprecated. This repo (`@gsknnft/bigint-buffer`) is the official, actively maintained successor. All users should migrate for security, performance, and modern features.
 
-This fork — `@gsknnft/bigint-buffer@1.3.2` — is a **sovereign override**:
+This repo — `@gsknnft/bigint-buffer@1.4.0` — 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,187 +29,177 @@ If you're using `bigint-buffer` in a secure or reproducible system, **migrate to
 ```json
 "pnpm": {
   "overrides": {
-    "bigint-buffer": "@gsknnft/bigint-buffer@1.3.2"
+    "bigint-buffer": "@gsknnft/bigint-buffer@1.4.0"
   }
 }
 ```
-## 🔍 Differences from Upstream
-
-- Rebuilt native bindings with modern Node compatibility
-- Scoped under `@gsknnft` for audit clarity
-- Uses `cpy-cli` instead of deprecated `cpx`
-- Rollup-based bundling for ESM/CJS duality
-- Peer dependency alignment and reproducibility guarantees
 
----
 
 **This fork is maintained by CoreFlame/GSKNNFT as part of the SigilNet ecosystem.**
-It is the only currently known secure, reproducible implementation of BigInt ↔ Buffer conversion with native fallback.
 
 ---
 
-### 🚀 Conversion Utilities (Built-In)
-
-`@gsknnft/bigint-buffer` includes direct conversion tools — no need to install `bigint-conversion` separately.
+## Why BigInts?
 
->You no longer need `bigint-conversion` as a separate dependency.
+BigInts are primitive arbitrary precision integers, overcoming the limitations of JS numbers (max 53 bits). They enable safe manipulation of 64, 128, 256+ bit values (e.g., database IDs, hashes) with much better performance than Buffer or BN.js.
 
-#### Importing
+**Performance highlights:**
 
-```ts
-import {
-  bigintToBuf,
-  bufToBigint,
-  bigintToHex,
-  hexToBigint,
-  bigintToText,
-  textToBigint,
-  bigintToBase64,
-  base64ToBigint
-} from '@gsknnft/bigint-buffer';
 ```
-
-#### Examples
-
-```ts
-const hex = bigintToHex(123456789n); // → "075bcd15"
-const buf = bigintToBuf(123456789n); // → <Buffer 07 5b cd 15>
-const text = bigintToText(123456789n); // → "123456789"
-const base64 = bigintToBase64(123456789n); // → "B1vNFQ=="
+Buffer equality: 12M ops/s
+BigInt equality: 798M ops/s
+BN.js equality: 73M ops/s
+BN.js multiply: 4.7M ops/s
+BigInt multiply: 15M ops/s
 ```
 
-> All conversions are endian-safe, round-trip validated, and available in both Node and browser environments.
-
 ---
 
-### 🧠 Why This Matters
+## Why This Package?
 
-- ✅ No audit vulnerabilities  
-- ✅ Native bindings preserved  
-- ✅ Conversion logic fused directly into the core  
-- ✅ Unified types and exports  
-- ✅ No need for `bigint-conversion` or external wrappers
+It is the only currently known secure, reproducible implementation of BigInt ↔ Buffer conversion with native fallback.
 
----
+- Efficient, secure conversion between BigInt and Buffer (native N-API bindings in Node, pure JS fallback in browser)
+- All conversion helpers built-in (no need for `bigint-conversion`)
+- Endian-safe, round-trip validated
+- Unified types and exports
+- No audit vulnerabilities
+- Patched and rebuilt native bindings (Node 18+)
+- First-class ESM/CJS exports plus browser bundle
+- Conversion helpers in-core (no separate `bigint-conversion`)
+- Actively maintained by GSKNNFT/CoreFlame
 
-The original  introduced utilities for converting TC39 BigInts to and from buffers. This fork builds on that foundation with modern tooling, patched bindings, and reproducible builds.
+## 🔍 Differences from Upstream
 
-This utility is necessary because BigInts, as proposed, do not support direct conversion between Buffers (or UInt8Arrays), but rather require conversion from buffers to hexadecimal strings then to BigInts, which is suboptimal. This utility includes N-API bindings, so under node, conversion is performed without generating a hexadecimal string. In the browser, normal string conversion is used.
+- Rebuilt native bindings with modern Node compatibility
+- Scoped under `@gsknnft` for audit clarity
+- Uses `cpy-cli` instead of deprecated `cpx`
+- Rollup-based bundling for ESM/CJS duality
+- Peer dependency alignment and reproducibility guarantees
 
 ---
 
-# Why use BigInts?
-
-BigInts are currently a stage 3 proposal, supported in Node 10 and V8 v6.7. BigInts are primitive arbitrary precision integers, overcoming the limitations of the number type in javascript, which only supports up to 53 bits of precision. 
+## Install
+```bash
+pnpm add @gsknnft/bigint-buffer
+# or npm/yarn
+```
 
-In many applications, manipulating 64, 128 or even 256 bit numbers is quite common. For example, database identifiers are often 128 bits, and hashes are often 256 bits (If you're looking for hashing support, try out [bigint-hash](https://github.com/no2chem/bigint-hash)). Before BigInts, manipulating these numbers safely required either allocating a Buffer or UInt8Arrays, which is quite expensive compared to a number, since Buffers are allocated on the heap. 
+---
 
-BigInts solve this problem by introducing a primitive that can hold
-arbitrary precision integers, reducing memory pressure and allowing
-the runtime to better optimize arithmetic operations. This results in significant performance improvements - 10x-100x for simple equality comparisons (using `===` vs `Buffer.compare()`):
+## Quick Start
+```ts
+import {
+  toBigIntBE, toBigIntLE, toBufferBE, toBufferLE,
+  bigintToBuf, bufToBigint, bigintToHex, hexToBigint,
+  bigintToText, textToBigint, bigintToBase64, base64ToBigint
+} from '@gsknnft/bigint-buffer';
 
-```
-Buffer equality comparison: 11916844±4.23% ops/s 83.91±17.293 ns/op (91 runs)
-bigint equality comparison: 798024851±0.29% ops/s 1.25±0.017 ns/op (91 runs)
+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=="
 ```
 
-Before BigInts, you probably used a library such as the widely used [bn.js](https://www.npmjs.com/package/bn.js).
-bn.js fares a little better than a plain Buffer, but is still 5-10x slower than the bigint:
-```
-BN equality comparison: 73255774±0.67% ops/s 13.65±0.442 ns/op (89 runs)
-```
+---
 
-bigints are also much better with arithmetic, here are the results compared to BN for multiplying two
-128-bit integers, yielding a 4x improvement:
-```
-BN multiply: 4763236±0.49% ops/s 209.94±5.111 ns/op (93 runs)
-bigint multiply: 15268666±0.92% ops/s 65.49±2.938 ns/op (92 runs)
-```
+### 🚀 Advanced Conversion Utilities (Built-In)
 
-# So what's the problem?
+Need only the conversion helpers?
+## Usage
 
-BigInts, unfortunately lack an efficient way to be converted back and forth between buffers. When dealing with serialized data or legacy node code, you'll often want to generate a BigInt from a buffer, or convert a BigInt to a Buffer in order to send a BigInt over the wire.
+### Classic Buffer/BigInt API
 
-Currently, the only method to generate a new BigInt is with the BigInt constructor. Unfortunately, it doesn't support Buffers, though it may in the future:
+```js
+import { toBigIntLE, toBigIntBE, toBufferLE, toBufferBE } from '@gsknnft/bigint-buffer';
 
-```
-> BigInt(Buffer.from([1]))
-SyntaxError: Cannot convert  to a BigInt
+const bigInt = toBigIntBE(Buffer.from('deadbeef', 'hex'));
+const buf = toBufferLE(123456789n, 8);
 ```
 
-Instead, you need to convert the Buffer to a hexadecimal string of the correct format. For example:
+```ts
+import { conversionUtils } from '@gsknnft/bigint-buffer';
 
-```
-> BigInt(`0x${buf.toString('hex')}`);
-1n
+// TypedArray, ArrayBuffer, hex/text/base64 helpers
+const arrBuf = conversionUtils.bigintToBuf(123456789n, true); // ArrayBuffer
+const hex = conversionUtils.bigintToHex(123456789n, true);    // '0x...' format
+const text = conversionUtils.bigintToText(123456789n);
 ```
 
-These conversions are not only quite expensive, but obviate a lot of the performance gains we get from BigInts. For example, on a large buffer, this conversion can take over 100x the time to do a comparison:
-```
-bigint from hex string from buffer (huge): 1230607±1.02% ops/s 812.61±40.013 ns/op (89 runs)
-```
+> All conversions are endian-safe, round-trip validated, and available in both Node and browser environments.
+
+---
+
+### 🧠 Why This Matters
 
-# And... bigint-buffer helps how?
+- ✅ No audit vulnerabilities  
+- ✅ Native bindings preserved  
+- ✅ Conversion logic fused directly into the core  
+- ✅ Unified types and exports  
+- ✅ No need for `bigint-conversion` or external wrappers
 
-bigint-buffer introduces four functions for conversion between buffers and bigints. A small example follows:
-```typescript
-import {toBigIntBE, toBigIntLE, toBufferBE, toBufferLE} from '@gsknnft/bigint-buffer';
 
-// Get a big endian buffer of the given width
-toBufferBE(0xdeadbeefn, 8);
-// ↪ <Buffer 00 00 00 00 de ad be ef>
+---
 
-// Get a little endian buffer of the given width
-toBufferLE(0xdeadbeefn, 8);
-// ↪ <Buffer ef be ad de 00 00 00 00>
+## Runtime: Native vs JS
+- Native binding lives at `build/Release/bigint_buffer.node` and loads automatically.
+- Check the path in use:
+  ```ts
+  import { isNative } from '@gsknnft/bigint-buffer';
+  console.log(isNative); // true when native is loaded
+  ```
+- Pure JS fallback stays available for browsers and non-native installs.
 
-// Get a BigInt from a buffer in big endian format
-toBigIntBE(Buffer.from('deadbeef', 'hex'));
-// ↪ 3735928559n (0xdeadbeefn)
+---
 
-// Get a BigInt from a buffer in little endian format
-toBigIntLE(Buffer.from('deadbeef', 'hex'));
-// ↪ 4022250974n (0xefbeadd0en)
-```
+## Docs & Types
+- Core usage: this README
+- Full conversion docs: `src/conversion/docs/` (generated from `bigint-conversion`)
+- API: [gsknnft.github.io/bigint-buffer/](https://gsknnft.github.io/bigint-buffer/)
+- Types: ship in `dist/*.d.ts`
 
-bigint-buffer uses N-API native bindings to perform the conversion efficiently without generating the
-immediate hex strings necessary in pure javascript. This results in a significant performance increase,
-about 2x for small buffer to bigint conversions, and 8x better than BN:
+---
 
-```
-BN to buffer (small): 981703±68.30% ops/s 1018.64±3194.648 ns/op (81 runs)
-bigint from hex string from buffer (small): 2804915±5.00% ops/s 356.52±85.371 ns/op (88 runs)
-LE bigint-buffer ToBigInt (small): 5932704±1.62% ops/s 168.56±12.971 ns/op (87 runs)
-```
+## Commands
 
-And about 3.3x for bigint to buffer conversions, and 17x better than BN:
-```
-BN to buffer (large): 339437±2.85% ops/s 2946.06±385.504 ns/op (81 runs)
-BE bigint to hex string to buffer (large): 1714292±1.35% ops/s 583.33±37.995 ns/op (90 runs)
-BE bigint-buffer to buffer (large, truncated): 5977218±4.68% ops/s 167.30±37.284 ns/op (87 runs)
+```bash
+pnpm run build           # compile + bundle
+pnpm run test            # vitest (node + conversion tests)
+pnpm run coverage        # conversion coverage
+pnpm run rebuild:native  # rebuild the N-API binding
 ```
 
-# Typescript Support
+## Benchmarks
 
-bigint-buffer supplies typescript bindings, but BigInts are still not supported in typescript, though
-a pull request has been opened, so support should be coming soon. If you are using typescript,
-@calebsander has put up a pull request and the instructions in [this post](https://github.com/Microsoft/TypeScript/issues/15096#issuecomment-419654748).
+Run benchmarks with:
+```bash
+pnpm run benchmark       # performance benchmarks
+```
 
-# Install
+---
 
-Add bigint-buffer to your project with:
+## Modern Testing
 
-> `pnpm add @gsknnft/bigint-buffer`
+Uses [Vitest](https://vitest.dev) for fast, type-safe tests and coverage:
 
-or
+```bash
+pnpm run test      # run all tests
+pnpm run coverage  # see coverage report
+```
 
-> `npm install @gsknnft/bigint-buffer`
+---
 
-# Documentation
+## API Surface
+- Native: `toBigIntBE/LE`, `toBufferBE/LE`, `validateBigIntBuffer`, `isNative`
+- Conversion: `bigintToBuf`, `bufToBigint`, `bigintToHex`, `hexToBigint`, `bigintToText`, `textToBigint`, `bigintToBase64`, `base64ToBigint`, `bufToHex`, `hexToBuf`, `textToBuf`, `bufToText`, `parseHex`, `TypedArray`
 
-Basic API documentation can be found [here](https://gsknnft.github.io/bigint-buffer/). Note that v1.0.0 changes
-the name of the original functions to meet style guidelines.
+All helpers are endian-safe and validated across Node and browser builds.
 
-# Benchmarks
+---
 
-Benchmarks can be run by executing `pnpm run benchmark` from the package directory.
+## Support & Project Status
+- Version: 1.4.0
+- Maintainer: GSKNNFT/CoreFlame
+- Node: ≥18 (native), browser bundle included
+- Issues: https://github.com/gsknnft/bigint-buffer/issues

package/WHY_BIGINT.md

@@ -0,0 +1,127 @@
+# @gsknnft/bigint-buffer
+
+## Secure Buffer Utilities for TC39 BigInt Proposal
+
+---
+
+The original  introduced utilities for converting TC39 BigInts to and from buffers. This fork builds on that foundation with modern tooling, patched bindings, and reproducible builds.
+
+This utility is necessary because BigInts, as proposed, do not support direct conversion between Buffers (or UInt8Arrays), but rather require conversion from buffers to hexadecimal strings then to BigInts, which is suboptimal. This utility includes N-API bindings, so under node, conversion is performed without generating a hexadecimal string. In the browser, normal string conversion is used.
+
+---
+
+# Why use BigInts?
+
+BigInts are currently a stage 3 proposal, supported in Node 10 and V8 v6.7. BigInts are primitive arbitrary precision integers, overcoming the limitations of the number type in javascript, which only supports up to 53 bits of precision. 
+
+In many applications, manipulating 64, 128 or even 256 bit numbers is quite common. For example, database identifiers are often 128 bits, and hashes are often 256 bits (If you're looking for hashing support, try out [bigint-hash](https://github.com/no2chem/bigint-hash)). Before BigInts, manipulating these numbers safely required either allocating a Buffer or UInt8Arrays, which is quite expensive compared to a number, since Buffers are allocated on the heap. 
+
+BigInts solve this problem by introducing a primitive that can hold
+arbitrary precision integers, reducing memory pressure and allowing
+the runtime to better optimize arithmetic operations. This results in significant performance improvements - 10x-100x for simple equality comparisons (using `===` vs `Buffer.compare()`):
+
+```
+Buffer equality comparison: 11916844±4.23% ops/s 83.91±17.293 ns/op (91 runs)
+bigint equality comparison: 798024851±0.29% ops/s 1.25±0.017 ns/op (91 runs)
+```
+
+Before BigInts, you probably used a library such as the widely used [bn.js](https://www.npmjs.com/package/bn.js).
+bn.js fares a little better than a plain Buffer, but is still 5-10x slower than the bigint:
+```
+BN equality comparison: 73255774±0.67% ops/s 13.65±0.442 ns/op (89 runs)
+```
+
+bigints are also much better with arithmetic, here are the results compared to BN for multiplying two
+128-bit integers, yielding a 4x improvement:
+```
+BN multiply: 4763236±0.49% ops/s 209.94±5.111 ns/op (93 runs)
+bigint multiply: 15268666±0.92% ops/s 65.49±2.938 ns/op (92 runs)
+```
+
+# So what's the problem?
+
+BigInts, unfortunately lack an efficient way to be converted back and forth between buffers. When dealing with serialized data or legacy node code, you'll often want to generate a BigInt from a buffer, or convert a BigInt to a Buffer in order to send a BigInt over the wire.
+
+Currently, the only method to generate a new BigInt is with the BigInt constructor. Unfortunately, it doesn't support Buffers, though it may in the future:
+
+```
+> BigInt(Buffer.from([1]))
+SyntaxError: Cannot convert  to a BigInt
+```
+
+Instead, you need to convert the Buffer to a hexadecimal string of the correct format. For example:
+
+```
+> BigInt(`0x${buf.toString('hex')}`);
+1n
+```
+
+These conversions are not only quite expensive, but obviate a lot of the performance gains we get from BigInts. For example, on a large buffer, this conversion can take over 100x the time to do a comparison:
+```
+bigint from hex string from buffer (huge): 1230607±1.02% ops/s 812.61±40.013 ns/op (89 runs)
+```
+
+# And... bigint-buffer helps how?
+
+bigint-buffer introduces four functions for conversion between buffers and bigints. A small example follows:
+```typescript
+import {toBigIntBE, toBigIntLE, toBufferBE, toBufferLE} from '@gsknnft/bigint-buffer';
+
+// Get a big endian buffer of the given width
+toBufferBE(0xdeadbeefn, 8);
+// ↪ <Buffer 00 00 00 00 de ad be ef>
+
+// Get a little endian buffer of the given width
+toBufferLE(0xdeadbeefn, 8);
+// ↪ <Buffer ef be ad de 00 00 00 00>
+
+// Get a BigInt from a buffer in big endian format
+toBigIntBE(Buffer.from('deadbeef', 'hex'));
+// ↪ 3735928559n (0xdeadbeefn)
+
+// Get a BigInt from a buffer in little endian format
+toBigIntLE(Buffer.from('deadbeef', 'hex'));
+// ↪ 4022250974n (0xefbeadd0en)
+```
+
+bigint-buffer uses N-API native bindings to perform the conversion efficiently without generating the
+immediate hex strings necessary in pure javascript. This results in a significant performance increase,
+about 2x for small buffer to bigint conversions, and 8x better than BN:
+
+```
+BN to buffer (small): 981703±68.30% ops/s 1018.64±3194.648 ns/op (81 runs)
+bigint from hex string from buffer (small): 2804915±5.00% ops/s 356.52±85.371 ns/op (88 runs)
+LE bigint-buffer ToBigInt (small): 5932704±1.62% ops/s 168.56±12.971 ns/op (87 runs)
+```
+
+And about 3.3x for bigint to buffer conversions, and 17x better than BN:
+```
+BN to buffer (large): 339437±2.85% ops/s 2946.06±385.504 ns/op (81 runs)
+BE bigint to hex string to buffer (large): 1714292±1.35% ops/s 583.33±37.995 ns/op (90 runs)
+BE bigint-buffer to buffer (large, truncated): 5977218±4.68% ops/s 167.30±37.284 ns/op (87 runs)
+```
+
+# Typescript Support
+
+bigint-buffer supplies typescript bindings, but BigInts are still not supported in typescript, though
+a pull request has been opened, so support should be coming soon. If you are using typescript,
+@calebsander has put up a pull request and the instructions in [this post](https://github.com/Microsoft/TypeScript/issues/15096#issuecomment-419654748).
+
+# Install
+
+Add bigint-buffer to your project with:
+
+> `pnpm add @gsknnft/bigint-buffer`
+
+or
+
+> `npm install @gsknnft/bigint-buffer`
+
+# Documentation
+
+Basic API documentation can be found [here](https://gsknnft.github.io/bigint-buffer/). Note that v1.0.0 changes
+the name of the original functions to meet style guidelines.
+
+# Benchmarks
+
+Benchmarks can be run by executing `pnpm run benchmark` from the package directory.

package/benchmark.md

@@ -0,0 +1,38 @@
+> @gsknnft/bigint-buffer@1.4.0 benchmark C:\Users\G\Desktop\Builds\bigint-buffer
+> node -r ts-node/register src/index.bench.ts
+
+no-op: 140382903±5.47% ops/s 7.12±1.674 ns/op (71 runs)
+bigint from hex string (small): 15586811±2.71% ops/s 64.16±8.076 ns/op (83 runs)
+bigint from hex string from buffer (small): 4936021±2.82% ops/s 202.59±25.869 ns/op (79 runs)
+BN from hex string from buffer (small): 4686836±2.41% ops/s 213.36±23.744 ns/op (82 runs)
+LE bigint-buffer ToBigInt (small): 10685450±3.19% ops/s 93.59±13.871 ns/op (83 runs)
+BE bigint-buffer ToBigInt (small): 8994196±2.88% ops/s 111.18±14.787 ns/op (82 runs)
+bigint from hex string (mid, aligned): 11155353±4.58% ops/s 89.64±18.736 ns/op (80 runs)
+bigint from hex string from buffer (mid, aligned): 2985658±2.65% ops/s 334.93±41.248 ns/op (83 runs)
+BN from hex string from buffer (mid, aligned): 4216666±2.90% ops/s 237.15±32.015 ns/op (83 runs)
+LE bigint-buffer ToBigInt (mid, aligned): 9561077±2.93% ops/s 104.59±13.984 ns/op (80 runs)
+BE bigint-buffer ToBigInt (mid, aligned): 9513798±2.82% ops/s 105.11±13.846 ns/op (84 runs)
+bigint from hex string (huge): 4330410±2.55% ops/s 230.93±27.561 ns/op (84 runs)
+bigint from hex string from buffer (huge): 1925677±3.48% ops/s 519.30±83.489 ns/op (82 runs)
+BN from hex string from buffer (huge): 1762721±2.97% ops/s 567.30±78.855 ns/op (84 runs)
+LE bigint-buffer ToBigInt (huge): 6599407±2.63% ops/s 151.53±18.491 ns/op (83 runs)
+BE bigint-buffer ToBigInt (huge): 6264231±3.18% ops/s 159.64±23.154 ns/op (80 runs)
+LE bigint to hex string to buffer (small): 2754040±3.04% ops/s 363.10±52.008 ns/op (85 runs)
+BE bigint to hex string to buffer (small): 2945555±2.41% ops/s 339.49±39.112 ns/op (88 runs)
+BN to buffer (small): 8719840±3.77% ops/s 114.68±19.967 ns/op (82 runs)
+LE bigint-buffer to buffer (small): 7767544±2.11% ops/s 128.74±12.561 ns/op (82 runs)
+BE bigint-buffer to buffer (small): 7741353±2.44% ops/s 129.18±14.810 ns/op (85 runs)
+LE bigint to hex string to buffer (large): 3431814±1.96% ops/s 291.39±27.043 ns/op (86 runs)
+BE bigint to hex string to buffer (large): 3599237±2.56% ops/s 277.84±33.636 ns/op (86 runs)
+BN to buffer (large): 0.00±0.00% ops/s 0.00±0.000 ns/op (0 run)
+LE bigint-buffer to buffer (large): 7295219±2.67% ops/s 137.08±17.019 ns/op (83 runs)
+BE bigint-buffer to buffer (large): 7219012±2.63% ops/s 138.52±16.929 ns/op (83 runs)
+LE bigint to hex string to buffer (large): 3659717±2.25% ops/s 273.25±28.524 ns/op (83 runs)
+BE bigint to hex string to buffer (large): 3911365±2.31% ops/s 255.67±27.772 ns/op (85 runs)
+LE bigint-buffer to buffer (large, truncated): 7847676±2.46% ops/s 127.43±14.823 ns/op (86 runs)
+BE bigint-buffer to buffer (large, truncated): 7874737±2.54% ops/s 126.99±15.015 ns/op (83 runs)
+Buffer equality comparison: 21013935±3.30% ops/s 47.59±7.120 ns/op (79 runs)
+BN equality comparison: 53940357±3.45% ops/s 18.54±2.941 ns/op (81 runs)
+bigint equality comparison: 134130208±6.63% ops/s 7.46±2.094 ns/op (69 runs)
+BN multiply: 5698232±2.26% ops/s 175.49±18.643 ns/op (85 runs)
+bigint multiply: 111639669±7.88% ops/s 8.96±2.743 ns/op (58 runs)