@meteora-ag/cp-amm-sdk 1.0.0 → 1.0.1-1.rc-0

package/node_modules/bigint-buffer/src/index.bench.ts

@@ -1,207 +0,0 @@
-
-import * as benchmark from 'benchmark';
-
-import {toBigIntBE, toBigIntLE, toBufferBE, toBufferLE} from './index';
-
-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();
-
-interface BenchmarkRun {
-  name: string;
-  hz: number;
-  stats: benchmark.Stats;
-}
-
-// Tests the performance of a no-op.
-suite.add('no-op', () => {});
-
-// Test small strings (unaligned)
-const smallHex = 'deadbeef';
-const smallString = `0x${smallHex}`;
-const smallBuf: Buffer = Buffer.from(smallHex, 'hex');
-suite.add('bigint from hex string (small)', () => {
-  return BigInt(smallString);
-});
-suite.add('bigint from hex string from buffer (small)', () => {
-  return BigInt(`0x${smallBuf.toString('hex')}`);
-});
-suite.add('BN from hex string from buffer (small)', () => {
-  return new BN(smallBuf.toString('hex'), 16);
-});
-suite.add('LE bigint-buffer ToBigInt (small)', () => {
-  return toBigIntLE(smallBuf);
-});
-suite.add('BE bigint-buffer ToBigInt (small)', () => {
-  return toBigIntBE(smallBuf);
-});
-
-// Test mid strings (aligned)
-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);
-});
-suite.add('bigint from hex string from buffer (mid, aligned)', () => {
-  return BigInt(`0x${midBuf.toString('hex')}`);
-});
-suite.add('BN from hex string from buffer (mid, aligned)', () => {
-  return new BN(midBuf.toString('hex'), 16);
-});
-suite.add('LE bigint-buffer ToBigInt (mid, aligned)', () => {
-  return toBigIntLE(midBuf);
-});
-suite.add('BE bigint-buffer ToBigInt (mid, aligned)', () => {
-  return toBigIntBE(midBuf);
-});
-
-// Test huge strings
-const hugeHex =
-    'badc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00d';
-const hugeString = `0x${hugeHex}`;
-const hugeBuf: Buffer = Buffer.from(hugeHex, 'hex');
-suite.add('bigint from hex string (huge)', () => {
-  return BigInt(hugeString);
-});
-suite.add('bigint from hex string from buffer (huge)', () => {
-  return BigInt(`0x${hugeBuf.toString('hex')}`);
-});
-suite.add('BN from hex string from buffer (huge)', () => {
-  return new BN(hugeBuf.toString('hex'), 16);
-});
-suite.add('LE bigint-buffer ToBigInt (huge)', () => {
-  return toBigIntLE(hugeBuf);
-});
-suite.add('BE bigint-buffer ToBigInt (huge)', () => {
-  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 bigIntToBufferWithStringLE = (int: bigint, width: number): Buffer => {
-  const hex = int.toString(16);
-  const buffer =
-      Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex');
-  buffer.reverse();
-  return buffer;
-};
-
-// Test small toBuffer
-const smallValue = 12345678n;
-suite.add('LE bigint to hex string to buffer (small)', () => {
-  return bigIntToBufferWithStringLE(smallValue, 8);
-});
-
-suite.add('BE bigint to hex string to buffer (small)', () => {
-  return bigIntToBufferWithStringBE(smallValue, 8);
-});
-
-const bnSmallValue = new BN('12345678', 10);
-suite.add('BN to buffer (small)', () => {
-  return bnSmallValue.toBuffer(8);
-});
-
-suite.add('LE bigint-buffer to buffer (small)', () => {
-  return toBufferLE(smallValue, 8);
-});
-
-suite.add('BE bigint-buffer to buffer (small)', () => {
-  return toBufferBE(smallValue, 8);
-});
-
-
-// Test large toBuffer
-const largeValue =
-    0xbadc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00dn;
-suite.add('LE bigint to hex string to buffer (large)', () => {
-  return bigIntToBufferWithStringLE(largeValue, 24);
-});
-
-suite.add('BE bigint to hex string to buffer (large)', () => {
-  return bigIntToBufferWithStringBE(largeValue, 24);
-});
-
-const bnLargeValue = new BN(
-    'badc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00d',
-    16);
-suite.add('BN to buffer (large)', () => {
-  return bnLargeValue.toBuffer(24);
-});
-
-suite.add('LE bigint-buffer to buffer (large)', () => {
-  return toBufferLE(largeValue, 24);
-});
-
-suite.add('BE bigint-buffer to buffer (large)', () => {
-  return toBufferBE(largeValue, 24);
-});
-
-suite.add('LE bigint to hex string to buffer (large)', () => {
-  return bigIntToBufferWithStringLE(largeValue, 8);
-});
-
-suite.add('BE bigint to hex string to buffer (large)', () => {
-  return bigIntToBufferWithStringBE(largeValue, 8);
-});
-
-suite.add('LE bigint-buffer to buffer (large, truncated)', () => {
-  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;
-suite.add('Buffer equality comparison', () => {
-  return b1.compare(b2) === 0;
-});
-
-suite.add('BN equality comparison', () => {
-  return bn1.eq(bn2);
-});
-
-suite.add('bigint equality comparison', () => {
-  return n1 === n2;
-});
-
-suite.add('BN multiply', () => {
-  return bn1.mul(bn2);
-});
-
-suite.add('bigint multiply', () => {
-  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);
-
-  console.log(`${benchmarkRun.name}: ${ops}±${err}% ops/s ${meanInNanos}±${
-      stdDevInNanos} ns/op (${runs} run${runs === 0 ? '' : 's'})`);
-});
-
-// Runs the test suite
-suite.run();

package/node_modules/bigint-buffer/src/index.spec.ts

@@ -1,288 +0,0 @@
-import 'mocha';
-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 toBigIntBE = lib.toBigIntBE;
-const toBigIntLE = lib.toBigIntLE;
-const toBufferBE = lib.toBufferBE;
-const toBufferLE = lib.toBufferLE;
-
-// Needed for should.not.be.undefined.
-/* tslint:disable:no-unused-expression */
-
-chai.should();
-const should = chai.should();
-
-const assertEquals = (n0: BigInt, n1: BigInt) => {
-  n0.toString(16).should.equal(n1.toString(16));
-};
-
-describe('Try buffer conversion (little endian)', () => {
-  it('0 should equal 0n', () => {
-    assertEquals(toBigIntLE(Buffer.from([0])), BigInt('0'));
-  });
-
-  it('1 should equal 1n', async () => {
-    assertEquals(toBigIntLE(Buffer.from([1])), BigInt('1'));
-  });
-
-  it('0xdead should equal 0xdeadn', async () => {
-    assertEquals(toBigIntLE(Buffer.from([0xad, 0xde])), BigInt(`0xdead`));
-  });
-
-  it('0xdeadbeef should equal 0xdeadbeefn', async () => {
-    assertEquals(
-        toBigIntLE(Buffer.from([0xef, 0xbe, 0xad, 0xde])),
-        BigInt(`0xdeadbeef`));
-  });
-
-  it('0xbadc0ffee0 should equal 0xbadc0ffee0n', async () => {
-    assertEquals(
-        toBigIntLE(Buffer.from([0xe0, 0xfe, 0x0f, 0xdc, 0xba])),
-        BigInt(`0xbadc0ffee0`));
-  });
-
-  it('0xbadc0ffee0dd should equal 0xbadc0ffee0ddn', async () => {
-    assertEquals(
-        toBigIntLE(Buffer.from([0xdd, 0xe0, 0xfe, 0x0f, 0xdc, 0xba])),
-        BigInt(`0xbadc0ffee0dd`));
-  });
-
-  it('0xbadc0ffee0ddf0 should equal 0xbadc0ffee0ddf0n', async () => {
-    assertEquals(
-        toBigIntLE(Buffer.from([0xf0, 0xdd, 0xe0, 0xfe, 0x0f, 0xdc, 0xba])),
-        BigInt(`0xbadc0ffee0ddf0`));
-  });
-
-  it('0xbadc0ffee0ddf00d should equal 0xbadc0ffee0ddf00dn', async () => {
-    assertEquals(
-        toBigIntLE(
-            Buffer.from([0x0d, 0xf0, 0xdd, 0xe0, 0xfe, 0x0f, 0xdc, 0xba])),
-        BigInt(`0xbadc0ffee0ddf00d`));
-  });
-
-  it('0xbadc0ffee0ddf00ddeadbeef should equal 0xbadc0ffee0ddf00ddeadbeefn',
-     async () => {
-       assertEquals(
-           toBigIntLE(Buffer.from([
-             0xef, 0xbe, 0xad, 0xde, 0x0d, 0xf0, 0xdd, 0xe0, 0xfe, 0x0f, 0xdc,
-             0xba
-           ])),
-           BigInt(`0xbadc0ffee0ddf00ddeadbeef`));
-     });
-  it('0xbadc0ffee0ddf00ddeadbeefbadc0ffee0ddf00ddeadbeef should equal 0xbadc0ffee0ddf00ddeadbeefbadc0ffee0ddf00ddeadbeefn',
-     async () => {
-       assertEquals(
-           toBigIntLE(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
-           ])),
-           BigInt(`0xbadc0ffee0ddf00ddeadbeefbadc0ffee0ddf00ddeadbeef`));
-     });
-  it('0xbadc0ffee0ddf00ddeadbeefbadc0ffee0ddf00ddeadbeefbeef should equal 0xbadc0ffee0ddf00ddeadbeefbadc0ffee0ddf00ddeadbeefbeefn',
-     async () => {
-       assertEquals(
-           toBigIntLE(Buffer.from([
-             0xef, 0xbe, 0xef, 0xbe, 0xad, 0xde, 0x0d, 0xf0, 0xdd,
-             0xe0, 0xfe, 0x0f, 0xdc, 0xba, 0xef, 0xbe, 0xad, 0xde,
-             0x0d, 0xf0, 0xdd, 0xe0, 0xfe, 0x0f, 0xdc, 0xba
-           ])),
-           BigInt(`0xbadc0ffee0ddf00ddeadbeefbadc0ffee0ddf00ddeadbeefbeef`));
-     });
-});
-
-describe('Try buffer conversion (big endian)', () => {
-  it('0 should equal 0n', () => {
-    assertEquals(toBigIntBE(Buffer.from([0])), BigInt(`0`));
-  });
-
-  it('1 should equal 1n', async () => {
-    assertEquals(toBigIntBE(Buffer.from([1])), BigInt(`1`));
-  });
-
-  it('0xdead should equal 0xdeadn', async () => {
-    assertEquals(toBigIntBE(Buffer.from([0xde, 0xad])), BigInt(`0xdead`));
-  });
-
-  it('0xdeadbeef should equal 0xdeadbeefn', async () => {
-    assertEquals(
-        toBigIntBE(Buffer.from([0xde, 0xad, 0xbe, 0xef])),
-        BigInt(`0xdeadbeef`));
-  });
-
-  it('0xbadc0ffee0 should equal 0xbadc0ffee0n', async () => {
-    assertEquals(
-        toBigIntBE(Buffer.from([0xba, 0xdc, 0x0f, 0xfe, 0xe0])),
-        BigInt(`0xbadc0ffee0`));
-  });
-
-  it('0xbadc0ffee0dd should equal 0xbadc0ffee0ddn', async () => {
-    assertEquals(
-        toBigIntBE(Buffer.from([0xba, 0xdc, 0x0f, 0xfe, 0xe0, 0xdd])),
-        BigInt(`0xbadc0ffee0dd`));
-  });
-
-  it('0xbadc0ffee0ddf0 should equal 0xbadc0ffee0ddf0n', async () => {
-    assertEquals(
-        toBigIntBE(Buffer.from([0xba, 0xdc, 0x0f, 0xfe, 0xe0, 0xdd, 0xf0])),
-        BigInt(`0xbadc0ffee0ddf0`));
-  });
-
-  it('0xbadc0ffee0ddf00d should equal 0xbadc0ffee0ddf00dn', async () => {
-    assertEquals(
-        toBigIntBE(
-            Buffer.from([0xba, 0xdc, 0x0f, 0xfe, 0xe0, 0xdd, 0xf0, 0x0d])),
-        BigInt(`0xbadc0ffee0ddf00d`));
-  });
-
-  it('0xbadc0ffee0ddf00ddeadbeef should equal 0xbadc0ffee0ddf00ddeadbeefn',
-     async () => {
-       assertEquals(
-           toBigIntBE(Buffer.from([
-             0xba, 0xdc, 0x0f, 0xfe, 0xe0, 0xdd, 0xf0, 0x0d, 0xde, 0xad, 0xbe,
-             0xef
-           ])),
-           BigInt(`0xbadc0ffee0ddf00ddeadbeef`));
-     });
-
-  it('long value should equal long val', async () => {
-    assertEquals(
-        toBigIntBE(Buffer.from(
-            'badc0ffee0ddf00ddeadbeefbadc0ffee0ddf00ddeadbeefbadc0ffee0ddf00ddeadbeef',
-            'hex')),
-        BigInt(
-            `0xbadc0ffee0ddf00ddeadbeefbadc0ffee0ddf00ddeadbeefbadc0ffee0ddf00ddeadbeef`));
-  });
-
-  it('other long value should equal long val', async () => {
-    assertEquals(
-        toBigIntBE(Buffer.from(
-            'd7f8974fb5ac78d9ac099b9ad5018bedc2ce0a72dad1827a1709da30580f0544',
-            'hex')),
-        BigInt(
-            `0xd7f8974fb5ac78d9ac099b9ad5018bedc2ce0a72dad1827a1709da30580f0544`));
-  });
-});
-
-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
-    ]));
-  });
-
-  it('1 should equal 1n', async () => {
-    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 () => {
-    toBufferLE(BigInt(`1`), 32)
-        .should.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
-    ]));
-  });
-
-  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
-    ]));
-  });
-
-  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 () => {
-       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 () => {
-    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', () => {
-    toBufferBE(BigInt(`0`), 8).should.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
-    ]));
-  });
-
-  it('1 should equal 1n (32 byte)', async () => {
-    toBufferBE(BigInt(`1`), 32)
-        .should.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
-    ]));
-  });
-
-  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
-    ]));
-  });
-
-  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 () => {
-       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 () => {
-    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/node_modules/bigint-buffer/src/index.ts

@@ -1,84 +0,0 @@
-
-interface ConverterInterface {
-  toBigInt(buf: Buffer, bigEndian?: boolean): bigint;
-  fromBigInt(num: BigInt, buf: Buffer, bigEndian?: boolean): Buffer;
-}
-
-declare var process: {browser: boolean;};
-
-let converter: ConverterInterface;
-
-if (!process.browser) {
-  try {
-    converter = require('bindings')('bigint_buffer');
-  } 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.
- */
-export function toBigIntLE(buf: Buffer): bigint {
-  if (process.browser || 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);
-}
-
-/**
- * Convert a big-endian buffer into a BigInt
- * @param buf The big-endian buffer to convert.
- * @returns A BigInt with the big-endian representation of buf.
- */
-export function toBigIntBE(buf: Buffer): bigint {
-  if (process.browser || 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.
- */
-export function toBufferLE(num: bigint, width: number): Buffer {
-  if (process.browser || 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.
- */
-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');
-  }
-  return converter.fromBigInt(num, Buffer.allocUnsafe(width), true);
-}

package/node_modules/bigint-buffer/tsconfig.json

@@ -1,19 +0,0 @@
-{
-  "extends": "./node_modules/gts/tsconfig-google.json",
-  "compilerOptions": {
-    "rootDir": ".",
-    "outDir": "build",
-    "target" : "esnext",
-    "lib" : [ "esnext" ],
-    "sourceMap": true
-  },
-  "include": [
-    "src/*.ts",
-    "src/**/*.ts",
-    "test/*.ts",
-    "test/**/*.ts"
-  ],
-  "exclude": [
-    "node_modules"
-  ]
-}

package/node_modules/bindings/README.md

@@ -1,98 +0,0 @@
-node-bindings
-=============
-### Helper module for loading your native module's `.node` file
-
-This is a helper module for authors of Node.js native addon modules.
-It is basically the "swiss army knife" of `require()`ing your native module's
-`.node` file.
-
-Throughout the course of Node's native addon history, addons have ended up being
-compiled in a variety of different places, depending on which build tool and which
-version of node was used. To make matters worse, now the `gyp` build tool can
-produce either a __Release__ or __Debug__ build, each being built into different
-locations.
-
-This module checks _all_ the possible locations that a native addon would be built
-at, and returns the first one that loads successfully.
-
-
-Installation
-------------
-
-Install with `npm`:
-
-``` bash
-$ npm install --save bindings
-```
-
-Or add it to the `"dependencies"` section of your `package.json` file.
-
-
-Example
--------
-
-`require()`ing the proper bindings file for the current node version, platform
-and architecture is as simple as:
-
-``` js
-var bindings = require('bindings')('binding.node')
-
-// Use your bindings defined in your C files
-bindings.your_c_function()
-```
-
-
-Nice Error Output
------------------
-
-When the `.node` file could not be loaded, `node-bindings` throws an Error with
-a nice error message telling you exactly what was tried. You can also check the
-`err.tries` Array property.
-
-```
-Error: Could not load the bindings file. Tried:
- → /Users/nrajlich/ref/build/binding.node
- → /Users/nrajlich/ref/build/Debug/binding.node
- → /Users/nrajlich/ref/build/Release/binding.node
- → /Users/nrajlich/ref/out/Debug/binding.node
- → /Users/nrajlich/ref/Debug/binding.node
- → /Users/nrajlich/ref/out/Release/binding.node
- → /Users/nrajlich/ref/Release/binding.node
- → /Users/nrajlich/ref/build/default/binding.node
- → /Users/nrajlich/ref/compiled/0.8.2/darwin/x64/binding.node
-    at bindings (/Users/nrajlich/ref/node_modules/bindings/bindings.js:84:13)
-    at Object.<anonymous> (/Users/nrajlich/ref/lib/ref.js:5:47)
-    at Module._compile (module.js:449:26)
-    at Object.Module._extensions..js (module.js:467:10)
-    at Module.load (module.js:356:32)
-    at Function.Module._load (module.js:312:12)
-    ...
-```
-
-The searching for the `.node` file will originate from the first directory in which has a `package.json` file is found.
-
-License
--------
-
-(The MIT License)
-
-Copyright (c) 2012 Nathan Rajlich &lt;nathan@tootallnate.net&gt;
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-'Software'), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.