@gsknnft/bigint-buffer 1.3.0 → 1.3.2

package/package.json

@@ -1,20 +1,11 @@
 {
   "name": "@gsknnft/bigint-buffer",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "description": "bigint to buffer conversion with native support",
   "main": "dist/index.js",
   "browser": {
     "./dist/node.js": "./dist/browser.js"
   },
-  "directories": {
-    "build": "./build",
-    "dist": "./dist",
-    "docs": "./docs",
-    "src": "./src",
-    "test": "./test",
-    "benchmark": "./benchmark",
-    "mocha-ts": "./.mocha-ts"
-  },
   "types": "dist/index.d.ts",
   "repository": {
     "type": "git",
@@ -32,36 +23,22 @@
   ],
   "license": "Apache-2.0",
   "dependencies": {
-    "@juanelas/base64": "^1.1.5",
     "bindings": "^1.5.0"
   },
   "devDependencies": {
-    "@rollup/plugin-commonjs": "^28.0.9",
-    "@rollup/plugin-inject": "^5.0.5",
-    "@rollup/plugin-json": "^6.1.0",
-    "@rollup/plugin-multi-entry": "^7.0.1",
-    "@rollup/plugin-node-resolve": "^16.0.3",
-    "@rollup/plugin-replace": "^6.0.2",
-    "@rollup/plugin-terser": "^0.4.4",
-    "@rollup/plugin-typescript": "^12.3.0",
     "@types/benchmark": "^2.1.5",
-    "@types/bindings": "^1.5.5",
     "@types/bn.js": "^5.2.0",
     "@types/chai": "^5.2.3",
     "@types/mocha": "^10.0.10",
     "@types/node": "^24.9.1",
     "benchmark": "^2.1.4",
     "bn.js": "^5.2.2",
-    "c8": "^10.1.3",
-    "chai": "^6.2.0",
+    "chai": "^4.1.2",
     "coveralls": "^3.1.1",
     "cpy-cli": "^6.0.0",
     "cross-env": "^6.0.3",
-    "glob": "^11.0.3",
     "gts": "^0.8.0",
     "istanbul": "^0.4.1",
-    "jsdom": "^27.0.1",
-    "json5": "^2.2.3",
     "karma": "^3.0.0",
     "karma-chrome-launcher": "^2.2.0",
     "karma-env-preprocessor": "^0.1.1",
@@ -69,39 +46,23 @@
     "karma-mocha-reporter": "^2.2.5",
     "karma-webpack": "^3.0.0",
     "microtime": "^3.0.0",
-    "minimatch": "^10.0.3",
     "mkdirp": "^0.5.1",
-    "mocha": "^11.7.4",
-    "npm-run-all": "^4.1.5",
-    "pirates": "^4.0.7",
+    "mocha": "^5.2.0",
     "pre-commit": "^1.2.2",
-    "puppeteer": "^24.26.1",
-    "rimraf": "^6.0.1",
     "rollup": "^4.52.5",
-    "rollup-plugin-dts": "^6.2.3",
-    "rollup-plugin-esbuild": "^6.2.1",
+    "@rollup/plugin-replace": "6.0.3",
     "ts-loader": "^9.5.4",
     "ts-node": "^10.9.2",
-    "ts-standard": "^12.0.2",
-    "tslib": "^2.8.1",
     "typedoc": "^0.28.14",
-    "typedoc-plugin-markdown": "^4.9.0",
     "typescript": "5.9.3",
-    "vite": "^7.1.12",
-    "vitest": "^4.0.3",
     "webpack": "5.102.1",
     "webpack-cli": "6.0.1"
   },
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
-      "require": "./dist/index.cjs"
-    },
-    "./conversion": {
-      "types": "./dist/conversion/index.d.ts",
-      "import": "./dist/conversion/index.js",
-      "require": "./dist/conversion/index.cjs"
+      "require": "./dist/index.cjs",
+      "types": "./dist/index.d.ts"
     }
   },
   "engines": {
@@ -115,47 +76,19 @@
     "Michael Wei <mwei@vmware.com> (https://github.com/no2chem)"
   ],
   "scripts": {
-    "_build:cleantypes": "rimraf .types",
-    "_build:cjsAndesmPkgJsons": "node ./build/bin/post-build.js",
-    "build": "run-s lint:src build:js lint:test docs",
-    "build:js": "rollup -c build/rollup.config.mjs",
-    "postbuild:js": "run-s _build:cleantypes _build:cjsAndesmPkgJsons",
-    "clean": "rimraf .mocha-ts coverage dist .types docs",
-    "coverage": "c8 --clean --check-coverage --exclude \"{src/ts/**/*.spec.ts,src/ts/**/*.test.ts,test,test-vectors,build}\" --exclude-after-remap --reporter=text --reporter=lcov node ./build/bin/mocha-ts.js --commonjs ",
-    "docs": "node build/build.docs.js",
-    "git:add": "git add -A",
-    "lint": "ts-standard --fix",
-    "lint:src": "ts-standard --fix \"src/**/!(*.spec|*.test).ts\"",
-    "lint:test": "ts-standard --fix \"{test/**/*.ts,src/**/*.spec.ts,src/**/*.test.ts}\"",
-    "mocha-ts": "node --experimental-modules --experimental-json-modules --es-module-specifier-resolution=node ./build/bin/mocha-ts.js ",
-    "mocha-ts:cjs": "node ./build/bin/mocha-ts.js --commonjs ",
-    "mocha-ts:watch": "npm run mocha-ts:cjs -- --watch --timeout 0",
-    "mocha-ts:browser": "node build/testing/browser/index.js ",
-    "mocha-ts:browser-headless": "node build/testing/browser/index.js headless ",
-    "preversion": "run-s clean lint:src build:js lint:test coverage test:browser-headless",
-    "version": "run-s docs git:add",
-    "postversion": "git push --follow-tags",
-    "test:conv": "run-s test:node test:browser-headless",
-    "test:browser:conv": "npm run mocha-ts:browser",
-    "test:browser-headless": "npm run mocha-ts:browser-headless",
-    "test:node:conv": "run-s test:node-cjs test:node-esm",
-    "test:node-cjs": "npm run mocha-ts:cjs ",
-    "test:node-esm": "npm run mocha-ts ",
-    "watch": "npm run mocha-ts:watch ",
     "test": "npm run test:node && npm run test:browser",
-    "coverage:istan": "istanbul cover ./test/index.js",
+    "coverage": "istanbul cover ./test/index.js",
     "coveralls": "npm run coverage && coveralls <coverage/lcov.info",
-    "lint:gts": "gts check",
+    "lint": "gts check",
     "install": "npm run rebuild || echo \"Couldn't build bindings. Non-native version used.\"",
     "test:browser": "karma start karma.conf.js",
-    "test:node": "mocha -r ts-node/register src/**/*.spec.ts --timeout 40000",
+    "test:node": "mocha build/src/**/*.spec.js --timeout 40000",
     "benchmark": "node -r ts-node/register src/index.bench.ts",
     "typedoc": "typedoc --out docs $(pwd)/src $(pwd)/helper --target es6 --mode file --tsconfig ./tsconfig.json --excludePrivate --excludeProtected --excludeNotExported --exclude '**/*+(spec|bench).ts'",
     "rebuild": "node-gyp rebuild",
     "check": "gts check",
-    "clean:gts": "gts clean",
-    "compile": "tsc -p . && rollup -c && cross-env BROWSER=true rollup -c && cpy \"build/src/*.d.ts\" dist || echo \"No .d.ts files to copy\"",
-    "compileOG": "mkdirp dist && tsc -p . && rollup -c > dist/node.js && cross-env BROWSER=true rollup -c > dist/browser.js && cpx \"build/src/*.d.ts\" dist",
+    "clean": "gts clean",
+    "compile": "tsc -p . && rollup -c rollup.cjs.config.js && rollup -c rollup.esm.config.js && cp build/src/index.d.ts dist/index.d.ts",
     "fix": "gts fix",
     "pretest": "npm run compile",
     "posttest": "npm run check"

package/rollup.cjs.config.js

@@ -0,0 +1,8 @@
+export default {
+  input: 'build/src/index.js',
+  output: {
+    file: 'dist/index.cjs',
+    format: 'cjs',
+  },
+  external: ['bindings'],
+};

package/rollup.esm.config.js

@@ -0,0 +1,15 @@
+import replace from '@rollup/plugin-replace';
+
+export default {
+    input: 'build/src/index.js',
+    output: {
+        file: 'dist/index.js',
+        format: 'esm'
+    },
+    external: ['bindings'],
+    plugins: [
+        replace({
+            'process.browser': 'false'
+        })
+    ]
+};

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();