@gsknnft/bigint-buffer 1.3.0 → 1.3.2

package/src/index.spec.ts

@@ -1,13 +1,12 @@
 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/index.js') :
+    require(path.join(__dirname, '../../dist/index.cjs'));
 const toBigIntBE = lib.toBigIntBE;
 const toBigIntLE = lib.toBigIntLE;
 const toBufferBE = lib.toBufferBE;
@@ -172,82 +171,274 @@ 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 () => {
+       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
+        ]));
+  });
+});
+
+describe('Conversion Utilities - bigintToBuf and bufToBigint', () => {
+  const bigintToBuf = lib.bigintToBuf;
+  const bufToBigint = lib.bufToBigint;
+
+  it('should convert 0 to buffer', () => {
+    const buf = bigintToBuf(BigInt(0));
+    buf.should.deep.equal(Buffer.from([0]));
   });
 
-  it('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('should convert small number to buffer', () => {
+    const buf = bigintToBuf(BigInt(123456789));
+    assertEquals(bufToBigint(buf), BigInt(123456789));
   });
 
-  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('should round-trip convert medium numbers', () => {
+    const original = BigInt('0xdeadbeef');
+    const buf = bigintToBuf(original);
+    const result = bufToBigint(buf);
+    assertEquals(result, original);
   });
 
-  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
-    ]));
+  it('should round-trip convert large numbers', () => {
+    const original = BigInt('0xbadc0ffee0ddf00ddeadbeef');
+    const buf = bigintToBuf(original);
+    const result = bufToBigint(buf);
+    assertEquals(result, original);
+  });
+
+  it('should throw error for negative bigint', () => {
+    chai.expect(() => bigintToBuf(BigInt(-1))).to.throw('negative bigint');
+  });
+});
+
+describe('Conversion Utilities - bigintToHex and hexToBigint', () => {
+  const bigintToHex = lib.bigintToHex;
+  const hexToBigint = lib.hexToBigint;
+
+  it('should convert 0 to hex', () => {
+    bigintToHex(BigInt(0)).should.equal('00');
+  });
+
+  it('should convert small number to hex', () => {
+    bigintToHex(BigInt(255)).should.equal('ff');
+  });
+
+  it('should convert number to even-length hex', () => {
+    bigintToHex(BigInt(15)).should.equal('0f');
+  });
+
+  it('should convert hex string to bigint', () => {
+    assertEquals(hexToBigint('deadbeef'), BigInt('0xdeadbeef'));
+  });
+
+  it('should handle hex string with 0x prefix', () => {
+    assertEquals(hexToBigint('0xdeadbeef'), BigInt('0xdeadbeef'));
+  });
+
+  it('should round-trip convert', () => {
+    const original = BigInt('0xbadc0ffee0ddf00ddeadbeef');
+    const hex = bigintToHex(original);
+    const result = hexToBigint(hex);
+    assertEquals(result, original);
+  });
+
+  it('should handle empty string', () => {
+    assertEquals(hexToBigint(''), BigInt(0));
+  });
+
+  it('should throw error for negative bigint', () => {
+    chai.expect(() => bigintToHex(BigInt(-1))).to.throw('negative bigint');
+  });
+});
+
+describe('Conversion Utilities - bigintToText and textToBigint', () => {
+  const bigintToText = lib.bigintToText;
+  const textToBigint = lib.textToBigint;
+
+  it('should convert 0 to text', () => {
+    bigintToText(BigInt(0)).should.equal('0');
+  });
+
+  it('should convert positive number to text', () => {
+    bigintToText(BigInt(123456789)).should.equal('123456789');
+  });
+
+  it('should convert large number to text', () => {
+    bigintToText(BigInt('0xdeadbeef')).should.equal('3735928559');
+  });
+
+  it('should convert text to bigint', () => {
+    assertEquals(textToBigint('123456789'), BigInt(123456789));
+  });
+
+  it('should round-trip convert', () => {
+    const original = BigInt('9876543210123456789');
+    const text = bigintToText(original);
+    const result = textToBigint(text);
+    assertEquals(result, original);
+  });
+
+  it('should throw error for empty string', () => {
+    chai.expect(() => textToBigint('')).to.throw('cannot be empty');
+  });
+
+  it('should throw error for invalid decimal string', () => {
+    chai.expect(() => textToBigint('abc')).to.throw('invalid decimal');
+  });
+});
+
+describe('Conversion Utilities - bigintToBase64 and base64ToBigint', () => {
+  const bigintToBase64 = lib.bigintToBase64;
+  const base64ToBigint = lib.base64ToBigint;
+
+  it('should convert 0 to base64', () => {
+    const b64 = bigintToBase64(BigInt(0));
+    b64.should.be.a('string');
+    assertEquals(base64ToBigint(b64), BigInt(0));
+  });
+
+  it('should convert small number to base64', () => {
+    const original = BigInt(123456789);
+    const b64 = bigintToBase64(original);
+    b64.should.equal('B1vNFQ==');
+  });
+
+  it('should convert base64 to bigint', () => {
+    assertEquals(base64ToBigint('B1vNFQ=='), BigInt(123456789));
+  });
+
+  it('should round-trip convert medium numbers', () => {
+    const original = BigInt('0xdeadbeef');
+    const b64 = bigintToBase64(original);
+    const result = base64ToBigint(b64);
+    assertEquals(result, original);
+  });
+
+  it('should round-trip convert large numbers', () => {
+    const original = BigInt('0xbadc0ffee0ddf00ddeadbeef');
+    const b64 = bigintToBase64(original);
+    const result = base64ToBigint(b64);
+    assertEquals(result, original);
+  });
+
+  it('should throw error for negative bigint', () => {
+    chai.expect(() => bigintToBase64(BigInt(-1))).to.throw('negative bigint');
+  });
+
+  it('should throw error for empty base64 string', () => {
+    chai.expect(() => base64ToBigint('')).to.throw('cannot be empty');
+  });
+
+  it('should throw error for invalid base64 string', () => {
+    chai.expect(() => base64ToBigint('invalid!@#')).to.throw('invalid base64');
   });
 });

package/src/index.ts

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

package/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"
-}
-}

package/dist/index.bench.d.ts

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

package/dist/index.spec.d.ts

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