@gsknnft/bigint-buffer 1.3.0 → 1.3.1

package/src/index.bench.ts

@@ -1,204 +1,207 @@
 
-import * as benchmark from 'benchmark'
+import * as benchmark from 'benchmark';
 
-import { toBigIntBE, toBigIntLE, toBufferBE, toBufferLE } from './index.js'
+import {toBigIntBE, toBigIntLE, toBufferBE, toBufferLE} from './index';
+
+const BN = require('bn.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
-})
+  return n1 * n2;
+});
+
+//#endregion
 
-// #endregion
 
 // Reporter for each benchmark
 suite.on('cycle', (event: benchmark.Event) => {
-  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)
+  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);
 
   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,13 +1,11 @@
 import 'mocha';
 declare var process: {browser: boolean;};
-import { expect } from 'chai';
-import path from 'path'
+
 import * as chai from 'chai';
-// import lib from '../dist/index.js';
-const lib = require(process.browser
-  ? path.resolve(__dirname, '../dist/index.js')
-  : path.resolve(__dirname, '../dist/node.js'));
+import * as path from 'path';
 
+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;
@@ -172,82 +170,118 @@ describe('Try buffer conversion (big endian)', () => {
 
 describe('Try bigint conversion (little endian)', () => {
   it('0 should equal 0n', () => {
-    expect(toBufferLE(BigInt('0'), 8)).to.deep.equal(Buffer.from([0, 0, 0, 0, 0, 0, 0, 0]));
+    toBufferLE(BigInt(`0`), 8).should.deep.equal(Buffer.from([
+      0, 0, 0, 0, 0, 0, 0, 0
+    ]));
   });
 
   it('1 should equal 1n', async () => {
-    expect(toBufferLE(BigInt('1'), 8)).to.deep.equal(Buffer.from([1, 0, 0, 0, 0, 0, 0, 0]));
+    toBufferLE(BigInt(`1`), 8).should.deep.equal(Buffer.from([
+      1, 0, 0, 0, 0, 0, 0, 0
+    ]));
   });
 
+
   it('1 should equal 1n (32 byte)', async () => {
-    expect(toBufferLE(BigInt('1'), 32)).to.deep.equal(Buffer.from(
-      '0100000000000000000000000000000000000000000000000000000000000000', 'hex'));
+    toBufferLE(BigInt(`1`), 32)
+        .should.deep.equal(Buffer.from(
+            '0100000000000000000000000000000000000000000000000000000000000000',
+            'hex'));
   });
 
   it('0xdead should equal 0xdeadn (6 byte)', async () => {
-    expect(toBufferLE(BigInt('0xdead'), 6)).to.deep.equal(Buffer.from([0xad, 0xde, 0, 0, 0, 0]));
+    toBufferLE(BigInt(`0xdead`), 6).should.deep.equal(Buffer.from([
+      0xad, 0xde, 0, 0, 0, 0
+    ]));
   });
 
   it('0xdeadbeef should equal 0xdeadbeef0000000000n (9 byte)', async () => {
-    expect(toBufferLE(BigInt('0xdeadbeef'), 9)).to.deep.equal(Buffer.from([0xef, 0xbe, 0xad, 0xde, 0, 0, 0, 0, 0]));
+    toBufferLE(BigInt(`0xdeadbeef`), 9).should.deep.equal(Buffer.from([
+      0xef, 0xbe, 0xad, 0xde, 0, 0, 0, 0, 0
+    ]));
   });
 
-  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('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('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('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('long value should equal long val', async () => {
-    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
-    ]));
+    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
+        ]));
   });
 });
 
+
 describe('Try bigint conversion (big endian)', () => {
   it('0 should equal 0n', () => {
-    expect(toBufferBE(BigInt('0'), 8)).to.deep.equal(Buffer.from([0, 0, 0, 0, 0, 0, 0, 0]));
+    toBufferBE(BigInt(`0`), 8).should.deep.equal(Buffer.from([
+      0, 0, 0, 0, 0, 0, 0, 0
+    ]));
   });
 
   it('1 should equal 1n', async () => {
-    expect(toBufferBE(BigInt('1'), 8)).to.deep.equal(Buffer.from([0, 0, 0, 0, 0, 0, 0, 1]));
+    toBufferBE(BigInt(`1`), 8).should.deep.equal(Buffer.from([
+      0, 0, 0, 0, 0, 0, 0, 1
+    ]));
   });
 
   it('1 should equal 1n (32 byte)', async () => {
-    expect(toBufferBE(BigInt('1'), 32)).to.deep.equal(Buffer.from(
-      '0000000000000000000000000000000000000000000000000000000000000001', 'hex'));
+    toBufferBE(BigInt(`1`), 32)
+        .should.deep.equal(Buffer.from(
+            '0000000000000000000000000000000000000000000000000000000000000001',
+            'hex'));
   });
 
   it('0xdead should equal 0xdeadn (6 byte)', async () => {
-    expect(toBufferBE(BigInt('0xdead'), 6)).to.deep.equal(Buffer.from([0, 0, 0, 0, 0xde, 0xad]));
+    toBufferBE(BigInt(`0xdead`), 6).should.deep.equal(Buffer.from([
+      0, 0, 0, 0, 0xde, 0xad
+    ]));
   });
 
   it('0xdeadbeef should equal 0xdeadbeef0000000000n (9 byte)', async () => {
-    expect(toBufferBE(BigInt('0xdeadbeef'), 9)).to.deep.equal(Buffer.from([0, 0, 0, 0, 0, 0xde, 0xad, 0xbe, 0xef]));
+    toBufferBE(BigInt(`0xdeadbeef`), 9).should.deep.equal(Buffer.from([
+      0, 0, 0, 0, 0, 0xde, 0xad, 0xbe, 0xef
+    ]));
   });
 
-  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('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('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('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('long value should equal long val', async () => {
-    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
-    ]));
+    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
+        ]));
   });
 });

package/src/index.ts

@@ -1,26 +1,21 @@
 
-// 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 let process: { browser: boolean }
-
-let converter: ConverterInterface
+declare var process: {browser: boolean;};
 
-export let isNative = false
+let converter: ConverterInterface;
+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?)');
   }
 }
 
@@ -29,25 +24,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;
   }
 }
 
@@ -56,15 +51,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);
 }
 
 /**
@@ -73,16 +68,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);
 }
 
 /**
@@ -91,10 +86,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/tsconfig.json

@@ -2,18 +2,15 @@
   "extends": "./node_modules/gts/tsconfig-google.json",
   "compilerOptions": {
     "composite": true,
-    "moduleResolution": "nodenext",
-    "module": "NodeNext",
     "rootDir": ".",
     "outDir": "build",
     "target" : "esnext",
     "lib" : [ "esnext" ],
-    "sourceMap": true,
-    "rootDirs": ["src", "src/conversion"],
-    "tsBuildInfoFile": "build/main.tsbuildinfo"
+    "sourceMap": true
   },
   "include": [
     "src/*.ts",
+    "src/**/*.ts",
     "test/*.ts",
     "test/**/*.ts"
   ],

package/.eslintrc

@@ -1,5 +0,0 @@
-{
-  "parserOptions": {
-  "project": "./tsconfig.lint.json"
-}
-}