@gsknnft/bigint-buffer 1.2.0 → 1.3.0

package/src/conversion/tsconfig.rollup.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "declaration": false,
+    "outDir": "./.rollup-tmp",
+    "composite": false
+  },
+  "include": ["src/ts/**/*"]
+}

package/src/conversion/typedoc.json

@@ -0,0 +1,5 @@
+{
+  "readme": "none",
+  "excludePrivate": true,
+  "plugin": ["typedoc-plugin-markdown"]
+}

package/src/index.bench.ts

@@ -1,207 +1,204 @@
 
-import * as benchmark from 'benchmark';
+import * as benchmark from 'benchmark'
 
-import {toBigIntBE, toBigIntLE, toBufferBE, toBufferLE} from './index';
-
-const BN = require('bn.js');
+import { toBigIntBE, toBigIntLE, toBufferBE, toBufferLE } from './index.js'
 
+const BN = require('bn.js')
 
 // This file contains the benchmark test suite. It includes the benchmark and
 // some lightweight boilerplate code for running benchmark.js. To
 // run the benchmarks, execute `npm run benchmark` from the package directory.
-const suite = new benchmark.Suite();
+const suite = new benchmark.Suite()
 
 interface BenchmarkRun {
-  name: string;
-  hz: number;
-  stats: benchmark.Stats;
+  name: string
+  hz: number
+  stats: benchmark.Stats
 }
 
 // Tests the performance of a no-op.
-suite.add('no-op', () => {});
+suite.add('no-op', () => {})
 
 // Test small strings (unaligned)
-const smallHex = 'deadbeef';
-const smallString = `0x${smallHex}`;
-const smallBuf: Buffer = Buffer.from(smallHex, 'hex');
+const smallHex = 'deadbeef'
+const smallString = `0x${smallHex}`
+const smallBuf: Buffer = Buffer.from(smallHex, 'hex')
 suite.add('bigint from hex string (small)', () => {
-  return BigInt(smallString);
-});
+  return BigInt(smallString)
+})
 suite.add('bigint from hex string from buffer (small)', () => {
-  return BigInt(`0x${smallBuf.toString('hex')}`);
-});
+  return BigInt(`0x${smallBuf.toString('hex')}`)
+})
 suite.add('BN from hex string from buffer (small)', () => {
-  return new BN(smallBuf.toString('hex'), 16);
-});
+  return new BN(smallBuf.toString('hex'), 16)
+})
 suite.add('LE bigint-buffer ToBigInt (small)', () => {
-  return toBigIntLE(smallBuf);
-});
+  return toBigIntLE(smallBuf)
+})
 suite.add('BE bigint-buffer ToBigInt (small)', () => {
-  return toBigIntBE(smallBuf);
-});
+  return toBigIntBE(smallBuf)
+})
 
 // Test mid strings (aligned)
-const midHex = 'badc0ffee0ddf00d';
-const midString = `0x${midHex}`;
-const midBuf: Buffer = Buffer.from(midHex, 'hex');
+const midHex = 'badc0ffee0ddf00d'
+const midString = `0x${midHex}`
+const midBuf: Buffer = Buffer.from(midHex, 'hex')
 suite.add('bigint from hex string (mid, aligned)', () => {
-  return BigInt(midString);
-});
+  return BigInt(midString)
+})
 suite.add('bigint from hex string from buffer (mid, aligned)', () => {
-  return BigInt(`0x${midBuf.toString('hex')}`);
-});
+  return BigInt(`0x${midBuf.toString('hex')}`)
+})
 suite.add('BN from hex string from buffer (mid, aligned)', () => {
-  return new BN(midBuf.toString('hex'), 16);
-});
+  return new BN(midBuf.toString('hex'), 16)
+})
 suite.add('LE bigint-buffer ToBigInt (mid, aligned)', () => {
-  return toBigIntLE(midBuf);
-});
+  return toBigIntLE(midBuf)
+})
 suite.add('BE bigint-buffer ToBigInt (mid, aligned)', () => {
-  return toBigIntBE(midBuf);
-});
+  return toBigIntBE(midBuf)
+})
 
 // Test huge strings
 const hugeHex =
-    'badc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00d';
-const hugeString = `0x${hugeHex}`;
-const hugeBuf: Buffer = Buffer.from(hugeHex, 'hex');
+    'badc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00d'
+const hugeString = `0x${hugeHex}`
+const hugeBuf: Buffer = Buffer.from(hugeHex, 'hex')
 suite.add('bigint from hex string (huge)', () => {
-  return BigInt(hugeString);
-});
+  return BigInt(hugeString)
+})
 suite.add('bigint from hex string from buffer (huge)', () => {
-  return BigInt(`0x${hugeBuf.toString('hex')}`);
-});
+  return BigInt(`0x${hugeBuf.toString('hex')}`)
+})
 suite.add('BN from hex string from buffer (huge)', () => {
-  return new BN(hugeBuf.toString('hex'), 16);
-});
+  return new BN(hugeBuf.toString('hex'), 16)
+})
 suite.add('LE bigint-buffer ToBigInt (huge)', () => {
-  return toBigIntLE(hugeBuf);
-});
+  return toBigIntLE(hugeBuf)
+})
 suite.add('BE bigint-buffer ToBigInt (huge)', () => {
-  return toBigIntBE(hugeBuf);
-});
+  return toBigIntBE(hugeBuf)
+})
 
 const bigIntToBufferWithStringBE = (int: bigint, width: number): Buffer => {
-  const hex = int.toString(16);
-  return Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex');
-};
+  const hex = int.toString(16)
+  return Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex')
+}
 
 const bigIntToBufferWithStringLE = (int: bigint, width: number): Buffer => {
-  const hex = int.toString(16);
+  const hex = int.toString(16)
   const buffer =
-      Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex');
-  buffer.reverse();
-  return buffer;
-};
+      Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex')
+  buffer.reverse()
+  return buffer
+}
 
 // Test small toBuffer
-const smallValue = 12345678n;
+const smallValue = 12345678n
 suite.add('LE bigint to hex string to buffer (small)', () => {
-  return bigIntToBufferWithStringLE(smallValue, 8);
-});
+  return bigIntToBufferWithStringLE(smallValue, 8)
+})
 
 suite.add('BE bigint to hex string to buffer (small)', () => {
-  return bigIntToBufferWithStringBE(smallValue, 8);
-});
+  return bigIntToBufferWithStringBE(smallValue, 8)
+})
 
-const bnSmallValue = new BN('12345678', 10);
+const bnSmallValue = new BN('12345678', 10)
 suite.add('BN to buffer (small)', () => {
-  return bnSmallValue.toBuffer(8);
-});
+  return bnSmallValue.toBuffer(8)
+})
 
 suite.add('LE bigint-buffer to buffer (small)', () => {
-  return toBufferLE(smallValue, 8);
-});
+  return toBufferLE(smallValue, 8)
+})
 
 suite.add('BE bigint-buffer to buffer (small)', () => {
-  return toBufferBE(smallValue, 8);
-});
-
+  return toBufferBE(smallValue, 8)
+})
 
 // Test large toBuffer
 const largeValue =
-    0xbadc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00dn;
+    0xbadc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00dn
 suite.add('LE bigint to hex string to buffer (large)', () => {
-  return bigIntToBufferWithStringLE(largeValue, 24);
-});
+  return bigIntToBufferWithStringLE(largeValue, 24)
+})
 
 suite.add('BE bigint to hex string to buffer (large)', () => {
-  return bigIntToBufferWithStringBE(largeValue, 24);
-});
+  return bigIntToBufferWithStringBE(largeValue, 24)
+})
 
 const bnLargeValue = new BN(
-    'badc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00d',
-    16);
+  'badc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00d',
+  16)
 suite.add('BN to buffer (large)', () => {
-  return bnLargeValue.toBuffer(24);
-});
+  return bnLargeValue.toBuffer(24)
+})
 
 suite.add('LE bigint-buffer to buffer (large)', () => {
-  return toBufferLE(largeValue, 24);
-});
+  return toBufferLE(largeValue, 24)
+})
 
 suite.add('BE bigint-buffer to buffer (large)', () => {
-  return toBufferBE(largeValue, 24);
-});
+  return toBufferBE(largeValue, 24)
+})
 
 suite.add('LE bigint to hex string to buffer (large)', () => {
-  return bigIntToBufferWithStringLE(largeValue, 8);
-});
+  return bigIntToBufferWithStringLE(largeValue, 8)
+})
 
 suite.add('BE bigint to hex string to buffer (large)', () => {
-  return bigIntToBufferWithStringBE(largeValue, 8);
-});
+  return bigIntToBufferWithStringBE(largeValue, 8)
+})
 
 suite.add('LE bigint-buffer to buffer (large, truncated)', () => {
-  return toBufferLE(largeValue, 8);
-});
+  return toBufferLE(largeValue, 8)
+})
 
 suite.add('BE bigint-buffer to buffer (large, truncated)', () => {
-  return toBufferBE(largeValue, 8);
-});
-
-const b1 = Buffer.from('0123456789ABCDEF0123456789ABCDEF', 'hex');
-const b2 = Buffer.from('0123456789ABCDEF0123456789ABCDEF', 'hex');
-const bn1 = new BN('0123456789ABCDEF0123456789ABCDEF', 'hex');
-const bn2 = new BN('0123456789ABCDEF0123456789ABCDEF', 'hex');
-const n1 = 0x0123456789ABCDEF0123456789ABCDEFn;
-const n2 = 0x0123456789ABCDEF0123456789ABCDEFn;
+  return toBufferBE(largeValue, 8)
+})
+
+const b1 = Buffer.from('0123456789ABCDEF0123456789ABCDEF', 'hex')
+const b2 = Buffer.from('0123456789ABCDEF0123456789ABCDEF', 'hex')
+const bn1 = new BN('0123456789ABCDEF0123456789ABCDEF', 'hex')
+const bn2 = new BN('0123456789ABCDEF0123456789ABCDEF', 'hex')
+const n1 = 0x0123456789ABCDEF0123456789ABCDEFn
+const n2 = 0x0123456789ABCDEF0123456789ABCDEFn
 suite.add('Buffer equality comparison', () => {
-  return b1.compare(b2) === 0;
-});
+  return b1.compare(b2) === 0
+})
 
 suite.add('BN equality comparison', () => {
-  return bn1.eq(bn2);
-});
+  return bn1.eq(bn2)
+})
 
 suite.add('bigint equality comparison', () => {
-  return n1 === n2;
-});
+  return n1 === n2
+})
 
 suite.add('BN multiply', () => {
-  return bn1.mul(bn2);
-});
+  return bn1.mul(bn2)
+})
 
 suite.add('bigint multiply', () => {
-  return n1 * n2;
-});
-
-//#endregion
+  return n1 * n2
+})
 
+// #endregion
 
 // Reporter for each benchmark
 suite.on('cycle', (event: benchmark.Event) => {
-  const benchmarkRun: BenchmarkRun = event.target as BenchmarkRun;
-  const stats = benchmarkRun.stats as benchmark.Stats;
-  const meanInNanos = (stats.mean * 1000000000).toFixed(2);
-  const stdDevInNanos = (stats.deviation * 1000000000).toFixed(3);
-  const runs = stats.sample.length;
-  const ops = benchmarkRun.hz.toFixed(benchmarkRun.hz < 100 ? 2 : 0);
-  const err = stats.rme.toFixed(2);
+  const benchmarkRun: BenchmarkRun = event.target as BenchmarkRun
+  const stats = benchmarkRun.stats
+  const meanInNanos = (stats.mean * 1000000000).toFixed(2)
+  const stdDevInNanos = (stats.deviation * 1000000000).toFixed(3)
+  const runs = stats.sample.length
+  const ops = benchmarkRun.hz.toFixed(benchmarkRun.hz < 100 ? 2 : 0)
+  const err = stats.rme.toFixed(2)
 
   console.log(`${benchmarkRun.name}: ${ops}±${err}% ops/s ${meanInNanos}±${
-      stdDevInNanos} ns/op (${runs} run${runs === 0 ? '' : 's'})`);
-});
+      stdDevInNanos} ns/op (${runs} run${runs === 0 ? '' : 's'})`)
+})
 
 // Runs the test suite
-suite.run();
+suite.run()

package/src/index.spec.ts

@@ -1,11 +1,13 @@
 import 'mocha';
 declare var process: {browser: boolean;};
-
+import { expect } from 'chai';
+import path from 'path'
 import * as chai from 'chai';
-import * as path from 'path';
+// import lib from '../dist/index.js';
+const lib = require(process.browser
+  ? path.resolve(__dirname, '../dist/index.js')
+  : path.resolve(__dirname, '../dist/node.js'));
 
-const lib = process.browser ? require('../../dist/browser') :
-                              require(path.join(__dirname, '../dist/node'));
 const toBigIntBE = lib.toBigIntBE;
 const toBigIntLE = lib.toBigIntLE;
 const toBufferBE = lib.toBufferBE;
@@ -170,118 +172,82 @@ describe('Try buffer conversion (big endian)', () => {
 
 describe('Try bigint conversion (little endian)', () => {
   it('0 should equal 0n', () => {
-    toBufferLE(BigInt(`0`), 8).should.deep.equal(Buffer.from([
-      0, 0, 0, 0, 0, 0, 0, 0
-    ]));
+    expect(toBufferLE(BigInt('0'), 8)).to.deep.equal(Buffer.from([0, 0, 0, 0, 0, 0, 0, 0]));
   });
 
   it('1 should equal 1n', async () => {
-    toBufferLE(BigInt(`1`), 8).should.deep.equal(Buffer.from([
-      1, 0, 0, 0, 0, 0, 0, 0
-    ]));
+    expect(toBufferLE(BigInt('1'), 8)).to.deep.equal(Buffer.from([1, 0, 0, 0, 0, 0, 0, 0]));
   });
 
-
   it('1 should equal 1n (32 byte)', async () => {
-    toBufferLE(BigInt(`1`), 32)
-        .should.deep.equal(Buffer.from(
-            '0100000000000000000000000000000000000000000000000000000000000000',
-            'hex'));
+    expect(toBufferLE(BigInt('1'), 32)).to.deep.equal(Buffer.from(
+      '0100000000000000000000000000000000000000000000000000000000000000', 'hex'));
   });
 
   it('0xdead should equal 0xdeadn (6 byte)', async () => {
-    toBufferLE(BigInt(`0xdead`), 6).should.deep.equal(Buffer.from([
-      0xad, 0xde, 0, 0, 0, 0
-    ]));
+    expect(toBufferLE(BigInt('0xdead'), 6)).to.deep.equal(Buffer.from([0xad, 0xde, 0, 0, 0, 0]));
   });
 
   it('0xdeadbeef should equal 0xdeadbeef0000000000n (9 byte)', async () => {
-    toBufferLE(BigInt(`0xdeadbeef`), 9).should.deep.equal(Buffer.from([
-      0xef, 0xbe, 0xad, 0xde, 0, 0, 0, 0, 0
-    ]));
+    expect(toBufferLE(BigInt('0xdeadbeef'), 9)).to.deep.equal(Buffer.from([0xef, 0xbe, 0xad, 0xde, 0, 0, 0, 0, 0]));
   });
 
-  it('0xbadc0ffee0ddf00d should equal 0xbadc0ffee0ddf00dn (8 byte)',
-     async () => {
-       toBufferLE(BigInt(`0xbadc0ffee0ddf00d`), 8)
-           .should.deep.equal(
-               Buffer.from([0x0d, 0xf0, 0xdd, 0xe0, 0xfe, 0x0f, 0xdc, 0xba]));
-     });
+  it('0xbadc0ffee0ddf00d should equal 0xbadc0ffee0ddf00dn (8 byte)', async () => {
+    expect(toBufferLE(BigInt('0xbadc0ffee0ddf00d'), 8)).to.deep.equal(Buffer.from([0x0d, 0xf0, 0xdd, 0xe0, 0xfe, 0x0f, 0xdc, 0xba]));
+  });
 
-  it('0xbadc0ffee0ddf00ddeadbeef should equal 0xbadc0ffee0ddf00ddeadbeefn',
-     async () => {
-       toBufferLE(BigInt(`0xbadc0ffee0ddf00ddeadbeef`), 12)
-           .should.deep.equal(Buffer.from([
-             0xef, 0xbe, 0xad, 0xde, 0x0d, 0xf0, 0xdd, 0xe0, 0xfe, 0x0f, 0xdc,
-             0xba
-           ]));
-     });
+  it('0xbadc0ffee0ddf00ddeadbeef should equal 0xbadc0ffee0ddf00ddeadbeefn', async () => {
+    expect(toBufferLE(BigInt('0xbadc0ffee0ddf00ddeadbeef'), 12)).to.deep.equal(Buffer.from([
+      0xef, 0xbe, 0xad, 0xde, 0x0d, 0xf0, 0xdd, 0xe0, 0xfe, 0x0f, 0xdc, 0xba
+    ]));
+  });
 
   it('long value should equal long val', async () => {
-    toBufferLE(BigInt(`0xbadc0ffee0ddf00ddeadbeefbadc0ffee0ddf00ddeadbeef`), 24)
-        .should.deep.equal(Buffer.from([
-          0xef, 0xbe, 0xad, 0xde, 0x0d, 0xf0, 0xdd, 0xe0,
-          0xfe, 0x0f, 0xdc, 0xba, 0xef, 0xbe, 0xad, 0xde,
-          0x0d, 0xf0, 0xdd, 0xe0, 0xfe, 0x0f, 0xdc, 0xba
-        ]));
+    expect(toBufferLE(BigInt('0xbadc0ffee0ddf00ddeadbeefbadc0ffee0ddf00ddeadbeef'), 24)).to.deep.equal(Buffer.from([
+      0xef, 0xbe, 0xad, 0xde, 0x0d, 0xf0, 0xdd, 0xe0,
+      0xfe, 0x0f, 0xdc, 0xba, 0xef, 0xbe, 0xad, 0xde,
+      0x0d, 0xf0, 0xdd, 0xe0, 0xfe, 0x0f, 0xdc, 0xba
+    ]));
   });
 });
 
-
 describe('Try bigint conversion (big endian)', () => {
   it('0 should equal 0n', () => {
-    toBufferBE(BigInt(`0`), 8).should.deep.equal(Buffer.from([
-      0, 0, 0, 0, 0, 0, 0, 0
-    ]));
+    expect(toBufferBE(BigInt('0'), 8)).to.deep.equal(Buffer.from([0, 0, 0, 0, 0, 0, 0, 0]));
   });
 
   it('1 should equal 1n', async () => {
-    toBufferBE(BigInt(`1`), 8).should.deep.equal(Buffer.from([
-      0, 0, 0, 0, 0, 0, 0, 1
-    ]));
+    expect(toBufferBE(BigInt('1'), 8)).to.deep.equal(Buffer.from([0, 0, 0, 0, 0, 0, 0, 1]));
   });
 
   it('1 should equal 1n (32 byte)', async () => {
-    toBufferBE(BigInt(`1`), 32)
-        .should.deep.equal(Buffer.from(
-            '0000000000000000000000000000000000000000000000000000000000000001',
-            'hex'));
+    expect(toBufferBE(BigInt('1'), 32)).to.deep.equal(Buffer.from(
+      '0000000000000000000000000000000000000000000000000000000000000001', 'hex'));
   });
 
   it('0xdead should equal 0xdeadn (6 byte)', async () => {
-    toBufferBE(BigInt(`0xdead`), 6).should.deep.equal(Buffer.from([
-      0, 0, 0, 0, 0xde, 0xad
-    ]));
+    expect(toBufferBE(BigInt('0xdead'), 6)).to.deep.equal(Buffer.from([0, 0, 0, 0, 0xde, 0xad]));
   });
 
   it('0xdeadbeef should equal 0xdeadbeef0000000000n (9 byte)', async () => {
-    toBufferBE(BigInt(`0xdeadbeef`), 9).should.deep.equal(Buffer.from([
-      0, 0, 0, 0, 0, 0xde, 0xad, 0xbe, 0xef
-    ]));
+    expect(toBufferBE(BigInt('0xdeadbeef'), 9)).to.deep.equal(Buffer.from([0, 0, 0, 0, 0, 0xde, 0xad, 0xbe, 0xef]));
   });
 
-  it('0xbadc0ffee0ddf00d should equal 0xbadc0ffee0ddf00dn (8 byte)',
-     async () => {
-       toBufferBE(BigInt(`0xbadc0ffee0ddf00d`), 8)
-           .should.deep.equal(
-               Buffer.from([0xba, 0xdc, 0x0f, 0xfe, 0xe0, 0xdd, 0xf0, 0x0d]));
-     });
+  it('0xbadc0ffee0ddf00d should equal 0xbadc0ffee0ddf00dn (8 byte)', async () => {
+    expect(toBufferBE(BigInt('0xbadc0ffee0ddf00d'), 8)).to.deep.equal(Buffer.from([0xba, 0xdc, 0x0f, 0xfe, 0xe0, 0xdd, 0xf0, 0x0d]));
+  });
 
-  it('0xbadc0ffee0ddf00ddeadbeef should equal 0xbadc0ffee0ddf00ddeadbeefn',
-     async () => {
-       toBufferBE(BigInt(`0xbadc0ffee0ddf00ddeadbeef`), 12)
-           .should.deep.equal(Buffer.from([
-             0xba, 0xdc, 0x0f, 0xfe, 0xe0, 0xdd, 0xf0, 0x0d, 0xde, 0xad, 0xbe,
-             0xef
-           ]));
-     });
+  it('0xbadc0ffee0ddf00ddeadbeef should equal 0xbadc0ffee0ddf00ddeadbeefn', async () => {
+    expect(toBufferBE(BigInt('0xbadc0ffee0ddf00ddeadbeef'), 12)).to.deep.equal(Buffer.from([
+      0xba, 0xdc, 0x0f, 0xfe, 0xe0, 0xdd, 0xf0, 0x0d, 0xde, 0xad, 0xbe, 0xef
+    ]));
+  });
 
   it('long value should equal long val', async () => {
-    toBufferBE(BigInt(`0xbadc0ffee0ddf00ddeadbeefbadc0ffee0ddf00ddeadbeef`), 24)
-        .should.deep.equal(Buffer.from([
-          0xba, 0xdc, 0x0f, 0xfe, 0xe0, 0xdd, 0xf0, 0x0d,
-          0xde, 0xad, 0xbe, 0xef, 0xba, 0xdc, 0x0f, 0xfe,
-          0xe0, 0xdd, 0xf0, 0x0d, 0xde, 0xad, 0xbe, 0xef
-        ]));
+    expect(toBufferBE(BigInt('0xbadc0ffee0ddf00ddeadbeefbadc0ffee0ddf00ddeadbeef'), 24)).to.deep.equal(Buffer.from([
+      0xba, 0xdc, 0x0f, 0xfe, 0xe0, 0xdd, 0xf0, 0x0d,
+      0xde, 0xad, 0xbe, 0xef, 0xba, 0xdc, 0x0f, 0xfe,
+      0xe0, 0xdd, 0xf0, 0x0d, 0xde, 0xad, 0xbe, 0xef
+    ]));
   });
 });

package/src/index.ts

@@ -1,21 +1,26 @@
 
+// etc.
+import bindings from 'bindings'
+const native = bindings('bigint_buffer')
+
 interface ConverterInterface {
-  toBigInt(buf: Buffer, bigEndian?: boolean): bigint;
-  fromBigInt(num: BigInt, buf: Buffer, bigEndian?: boolean): Buffer;
+  toBigInt: (buf: Buffer, bigEndian?: boolean) => bigint
+  fromBigInt: (num: bigint, buf: Buffer, bigEndian?: boolean) => Buffer
 }
 
-declare var process: {browser: boolean;};
+declare let process: { browser: boolean }
+
+let converter: ConverterInterface
 
-let converter: ConverterInterface;
-export let isNative = false;
+export let isNative = false
 
 if (!process.browser) {
   try {
-    converter = require('bindings')('bigint_buffer');
-    isNative = !process.browser && converter !== undefined;
+    converter = require('bindings')('bigint_buffer')
+    isNative = !process.browser && converter !== undefined
   } catch (e) {
     console.warn(
-        'bigint: Failed to load bindings, pure JS will be used (try npm run rebuild?)');
+      'bigint: Failed to load bindings, pure JS will be used (try npm run rebuild?)')
   }
 }
 
@@ -24,25 +29,25 @@ if (!process.browser) {
  * @param buf The little-endian buffer to convert
  * @returns A BigInt with the little-endian representation of buf.
  */
-export function toBigIntLE(buf: Buffer): bigint {
+export function toBigIntLE (buf: Buffer): bigint {
   if (process.browser || converter === undefined) {
-    const reversed = Buffer.from(buf);
-    reversed.reverse();
-    const hex = reversed.toString('hex');
+    const reversed = Buffer.from(buf)
+    reversed.reverse()
+    const hex = reversed.toString('hex')
     if (hex.length === 0) {
-      return BigInt(0);
+      return BigInt(0)
     }
-    return BigInt(`0x${hex}`);
+    return BigInt(`0x${hex}`)
   }
-  return converter.toBigInt(buf, false);
+  return converter.toBigInt(buf, false)
 }
 
-export function validateBigIntBuffer(): boolean {
+export function validateBigIntBuffer (): boolean {
   try {
-    const test = toBigIntLE(Buffer.from([0x01, 0x00]));
-    return test === BigInt(1);
+    const test = toBigIntLE(Buffer.from([0x01, 0x00]))
+    return test === BigInt(1)
   } catch {
-    return false;
+    return false
   }
 }
 
@@ -51,15 +56,15 @@ export function validateBigIntBuffer(): boolean {
  * @param buf The big-endian buffer to convert.
  * @returns A BigInt with the big-endian representation of buf.
  */
-export function toBigIntBE(buf: Buffer): bigint {
+export function toBigIntBE (buf: Buffer): bigint {
   if (process.browser || converter === undefined) {
-    const hex = buf.toString('hex');
+    const hex = buf.toString('hex')
     if (hex.length === 0) {
-      return BigInt(0);
+      return BigInt(0)
     }
-    return BigInt(`0x${hex}`);
+    return BigInt(`0x${hex}`)
   }
-  return converter.toBigInt(buf, true);
+  return converter.toBigInt(buf, true)
 }
 
 /**
@@ -68,16 +73,16 @@ export function toBigIntBE(buf: Buffer): bigint {
  * @param width The number of bytes that the resulting buffer should be.
  * @returns A little-endian buffer representation of num.
  */
-export function toBufferLE(num: bigint, width: number): Buffer {
+export function toBufferLE (num: bigint, width: number): Buffer {
   if (process.browser || converter === undefined) {
-    const hex = num.toString(16);
+    const hex = num.toString(16)
     const buffer =
-        Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex');
-    buffer.reverse();
-    return 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);
+  return converter.fromBigInt(num, Buffer.allocUnsafe(width), false)
 }
 
 /**
@@ -86,10 +91,10 @@ export function toBufferLE(num: bigint, width: number): Buffer {
  * @param width The number of bytes that the resulting buffer should be.
  * @returns A big-endian buffer representation of num.
  */
-export function toBufferBE(num: bigint, width: number): Buffer {
+export function toBufferBE (num: bigint, width: number): Buffer {
   if (process.browser || converter === undefined) {
-    const hex = num.toString(16);
-    return Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex');
+    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);
-}
+  return converter.fromBigInt(num, Buffer.allocUnsafe(width), true)
+}

package/src/types/bindings.d.t.s

@@ -0,0 +1,4 @@
+declare module 'bindings' {
+  function bindings(name: string): any;
+  export = bindings;
+}