@vandeurenglenn/base-x 1.1.2 → 1.2.0

package/LICENSE

@@ -0,0 +1,23 @@
+MIT License
+
+Copyright (c) 2018 base-x contributors
+Copyright (c) 2014-2018 The Bitcoin Core developers (base58.cpp)
+Copyright (c) 2026 Vandeuren Glenn
+
+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.

package/README.md

@@ -1,28 +1,75 @@
-# base-x
-> module compatible base-x
-
-## install
-```sh
-npm i -S @vandeurenglenn/base-x
-```
-
-## usage
-
-```js
-const base = require('@vandeurenglenn/base-x')
-// or
-import base from '@vandeurenglenn/base-x'
-
-const base32 = base('abcdefghijklmnopqrstuvwxyz234567') // base32 Alphabet
-
-// encode
-const uint8Array = new TextEncoder().encode('hi');
-const bs32 = base32.encode(uint8Array)
-console.log(bs32); // '2dj'
-
-// decode
-const hi = base32.decode(bs32)
-const string = new TextDecoder().decode(hi);
-console.log(string) // 'hi'
-
-```
+# @vandeurenglenn/base-x
+
+> Fast, optimized, and compatible `base-x` encoding/decoding library.
+
+This library is a high-performance drop-in replacement for the standard [base-x](https://github.com/cryptocoinjs/base-x) library. It includes transparent optimizations for power-of-2 bases (Base16, Base32, Base64), achieving **5x-7x faster** performance while maintaining full backward compatibility.
+
+It also introduces optional **RFC 4648** compliance for standard Hex, Base32, and Base64 implementations.
+
+## Install
+
+```sh
+npm i -S @vandeurenglenn/base-x
+```
+
+## Features
+
+- **High Performance**: Automatically switches to a customized bitwise algorithm for bases that are powers of 2 (16, 32, 64), offering significant speedups over generic integer arithmetic.
+- **Backwards Compatible**: By default, it mimics the behavior of the original `base-x` library (integer-based encoding, preserving leading zero characters), making it safe for use in cryptocurrency applications (e.g., Bitcoin Base58).
+- **RFC 4648 Support**: Optional mode to strictly follow RFC standards (padding, 8-bit block alignment) for standard web/network use cases.
+- **TypeScript**: First-class TypeScript support with included type definitions.
+
+## Usage
+
+### Standard Mode (Drop-in Replacement)
+Behaves exactly like `base-x`. Note: This mode follows the "Bitcoin-style" integer encoding (leading zero preservation, no padding).
+
+```js
+import base from '@vandeurenglenn/base-x'
+
+const BASE58 = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
+const bs58 = base(BASE58)
+
+const data = new Uint8Array([0, 255])
+const encoded = bs58.encode(data)
+console.log(encoded) // "1LU" (1 preserves the leading zero byte)
+
+const decoded = bs58.decode(encoded)
+console.log(decoded) // Uint8Array [0, 255]
+```
+
+### RFC 4648 Mode (Standard Base64/Hex/Base32)
+Enable this mode if you need standard padding (`=`) and strict behavior matching built-in browser/Node.js methods.
+
+```js
+import base from '@vandeurenglenn/base-x'
+
+const BASE64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
+// Enable RFC 4648 compliance
+const b64 = base(BASE64, { rfc4648: true })
+
+const data = new TextEncoder().encode('Hello World')
+
+// Encodes with padding
+const encoded = b64.encode(data)
+console.log(encoded) // "SGVsbG8gV29ybGQ="
+
+// Decodes standard Base64 string
+const decoded = b64.decode(encoded)
+console.log(new TextDecoder().decode(decoded)) // "Hello World"
+```
+
+## Performance
+
+Benchmarks run on Node.js v25:
+
+| Algorithm | @vandeurenglenn/base-x | standard base-x | Speedup |
+|-----------|------------------------|-----------------|---------|
+| **Base16**| ~3,400,000 ops/sec     | ~516,000 ops/sec| **~6.5x**|
+| **Base32**| ~4,100,000 ops/sec     | ~680,000 ops/sec| **~6.0x**|
+| **Base64**| ~4,900,000 ops/sec     | ~878,000 ops/sec| **~5.5x**|
+| **Base58**| ~600,000 ops/sec       | ~594,000 ops/sec| ~1.0x   |
+
+## License
+
+MIT © [base-x contributors](https://github.com/cryptocoinjs/base-x) & Vandeuren Glenn

package/package.json

@@ -1,27 +1,44 @@
 {
   "name": "@vandeurenglenn/base-x",
-  "version": "1.1.2",
-  "description": "",
+  "version": "1.2.0",
+  "description": "Fast, optimized, and compatible base-x encoding/decoding library.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/VandeurenGlenn/base-x.git"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts"
+  ],
   "exports": {
-    ".": "./index.js"
+    ".": {
+      "import": "./index.js",
+      "types": "./index.d.ts"
+    }
   },
   "type": "module",
-  "types": "./index.d.ts",
   "scripts": {
+    "bench": "node bench.js",
     "build": "rollup -c",
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "keywords": [
-    "base",
-    "x",
     "base-x",
-    "es"
+    "base58",
+    "base64",
+    "base32",
+    "base16",
+    "encoder",
+    "decoder",
+    "codec",
+    "crypto",
+    "base"
   ],
-  "author": "",
+  "author": "Vandeuren Glenn <vandeurenglenn@gmail.com>",
   "license": "MIT",
   "devDependencies": {
-    "@rollup/plugin-typescript": "^10.0.1",
-    "rollup": "^2.70.2",
-    "tslib": "^2.4.1"
+    "@rollup/plugin-typescript": "^12.3.0",
+    "rollup": "^4.57.1",
+    "tslib": "^2.8.1"
   }
 }

package/.gitattributes

@@ -1,2 +0,0 @@
-# Auto detect text files and perform LF normalization
-* text=auto

package/index.d.ts

@@ -1,11 +0,0 @@
-/**
- *  string containging only given ALPHABET letters/numbers
- */
-type baseString = string;
-type baseX = {
-    encode: (uint8Array: Uint8Array) => baseString;
-    decode: (string: baseString) => Uint8Array;
-    decodeUnsafe: (string: baseString) => Uint8Array;
-};
-declare const base: (ALPHABET: string) => baseX;
-export { base as default };

package/index.js

@@ -1,144 +0,0 @@
-// base-x encoding / decoding
-// Copyright (c) 2018 base-x contributors
-// Copyright (c) 2014-2018 The Bitcoin Core developers (base58.cpp)
-// Distributed under the MIT software license, see the accompanying
-// file LICENSE or http://www.opensource.org/licenses/mit-license.php.
-const base = (ALPHABET) => {
-    if (ALPHABET.length >= 255) {
-        throw new TypeError('Alphabet too long');
-    }
-    const BASE_MAP = new Uint8Array(256);
-    for (let j = 0; j < BASE_MAP.length; j++) {
-        BASE_MAP[j] = 255;
-    }
-    for (let i = 0; i < ALPHABET.length; i++) {
-        const x = ALPHABET.charAt(i);
-        const xc = x.charCodeAt(0);
-        if (BASE_MAP[xc] !== 255) {
-            throw new TypeError(x + ' is ambiguous');
-        }
-        BASE_MAP[xc] = i;
-    }
-    const BASE = ALPHABET.length;
-    const LEADER = ALPHABET.charAt(0);
-    const FACTOR = Math.log(BASE) / Math.log(256); // log(BASE) / log(256), rounded up
-    const iFACTOR = Math.log(256) / Math.log(BASE); // log(256) / log(BASE), rounded up
-    const encode = (source) => {
-        if (source instanceof Uint8Array) ;
-        else if (ArrayBuffer.isView(source)) {
-            source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
-        }
-        else if (Array.isArray(source)) {
-            source = Uint8Array.from(source);
-        }
-        if (!(source instanceof Uint8Array)) {
-            throw new TypeError('Expected Uint8Array');
-        }
-        if (source.length === 0) {
-            return '';
-        }
-        // Skip & count leading zeroes.
-        let zeroes = 0;
-        let length = 0;
-        let pbegin = 0;
-        const pend = source.length;
-        while (pbegin !== pend && source[pbegin] === 0) {
-            pbegin++;
-            zeroes++;
-        }
-        // Allocate enough space in big-endian base58 representation.
-        const size = ((pend - pbegin) * iFACTOR + 1) >>> 0;
-        const b58 = new Uint8Array(size);
-        // Process the bytes.
-        while (pbegin !== pend) {
-            let carry = source[pbegin];
-            // Apply "b58 = b58 * 256 + ch".
-            let i = 0;
-            for (let it1 = size - 1; (carry !== 0 || i < length) && (it1 !== -1); it1--, i++) {
-                carry += (256 * b58[it1]) >>> 0;
-                b58[it1] = (carry % BASE) >>> 0;
-                carry = (carry / BASE) >>> 0;
-            }
-            if (carry !== 0) {
-                throw new Error('Non-zero carry');
-            }
-            length = i;
-            pbegin++;
-        }
-        // Skip leading zeroes in base58 result.
-        let it2 = size - length;
-        while (it2 !== size && b58[it2] === 0) {
-            it2++;
-        }
-        // Translate the result into a string.
-        let str = LEADER.repeat(zeroes);
-        for (; it2 < size; ++it2) {
-            str += ALPHABET.charAt(b58[it2]);
-        }
-        return str;
-    };
-    const decodeUnsafe = (source) => {
-        if (typeof source !== 'string') {
-            throw new TypeError('Expected String');
-        }
-        if (source.length === 0) {
-            return new Uint8Array();
-        }
-        let psz = 0;
-        // Skip and count leading '1's.
-        let zeroes = 0;
-        let length = 0;
-        while (source[psz] === LEADER) {
-            zeroes++;
-            psz++;
-        }
-        // Allocate enough space in big-endian base256 representation.
-        const size = (((source.length - psz) * FACTOR) + 1) >>> 0; // log(58) / log(256), rounded up.
-        let b256 = new Uint8Array(size);
-        // Process the characters.
-        while (source[psz]) {
-            // Decode character
-            let carry = BASE_MAP[source.charCodeAt(psz)];
-            // Invalid character
-            if (carry === 255) {
-                return;
-            }
-            let i = 0;
-            for (let it3 = size - 1; (carry !== 0 || i < length) && (it3 !== -1); it3--, i++) {
-                carry += (BASE * b256[it3]) >>> 0;
-                b256[it3] = (carry % 256) >>> 0;
-                carry = (carry / 256) >>> 0;
-            }
-            if (carry !== 0) {
-                throw new Error('Non-zero carry');
-            }
-            length = i;
-            psz++;
-        }
-        // Skip leading zeroes in b256.
-        let it4 = size - length;
-        while (it4 !== size && b256[it4] === 0) {
-            it4++;
-        }
-        let vch = new Uint8Array(zeroes + (size - it4));
-        let j = zeroes;
-        while (it4 !== size) {
-            vch[j++] = b256[it4++];
-        }
-        return vch;
-    };
-    const decode = (string) => {
-        const buffer = decodeUnsafe(string);
-        if (buffer) {
-            return buffer;
-        }
-        throw new Error('Non-base' + BASE + ' character');
-    };
-    return {
-        encode,
-        decodeUnsafe,
-        decode
-    };
-};
-
-export { base as default };

package/src/index.ts

@@ -1,136 +0,0 @@
-/**
- *  string containing only given ALPHABET letters/numbers
- */
-type baseString = string
-
-type baseX = {
-  encode: (uint8Array: Uint8Array) => baseString,
-  decode: (string: baseString) => Uint8Array,
-  decodeUnsafe: (string: baseString) => Uint8Array,
-}
-
-// base-x encoding / decoding
-// Copyright (c) 2018 base-x contributors
-// Copyright (c) 2014-2018 The Bitcoin Core developers (base58.cpp)
-// Distributed under the MIT software license, see the accompanying
-// file LICENSE or http://www.opensource.org/licenses/mit-license.php.
-const base = (ALPHABET: string):baseX => {
-  if (ALPHABET.length >= 255) { throw new TypeError('Alphabet too long') }
-  const BASE_MAP = new Uint8Array(256)
-  for (let j = 0; j < BASE_MAP.length; j++) {
-    BASE_MAP[j] = 255
-  }
-  for (let i = 0; i < ALPHABET.length; i++) {
-    const x = ALPHABET.charAt(i)
-    const xc = x.charCodeAt(0)
-    if (BASE_MAP[xc] !== 255) { throw new TypeError(x + ' is ambiguous') }
-    BASE_MAP[xc] = i
-  }
-  const BASE = ALPHABET.length
-  const LEADER = ALPHABET.charAt(0)
-  const FACTOR = Math.log(BASE) / Math.log(256) // log(BASE) / log(256), rounded up
-  const iFACTOR = Math.log(256) / Math.log(BASE) // log(256) / log(BASE), rounded up
-
-  const encode = (source: Uint8Array | ArrayBuffer): string => {
-    if (source instanceof Uint8Array) {
-    } else if (ArrayBuffer.isView(source)) {
-      source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength)
-    } else if (Array.isArray(source)) {
-      source = Uint8Array.from(source)
-    }
-    if (!(source instanceof Uint8Array)) { throw new TypeError('Expected Uint8Array') }
-    if (source.length === 0) { return '' }
-    // Skip & count leading zeroes.
-    let zeroes = 0
-    let length = 0
-    let pbegin = 0
-    const pend = source.length
-    while (pbegin !== pend && source[pbegin] === 0) {
-      pbegin++
-      zeroes++
-    }
-    // Allocate enough space in big-endian base58 representation.
-    const size = ((pend - pbegin) * iFACTOR + 1) >>> 0
-    const b58 = new Uint8Array(size)
-        // Process the bytes.
-    while (pbegin !== pend) {
-      let carry = source[pbegin]
-            // Apply "b58 = b58 * 256 + ch".
-      let i = 0
-      for (let it1 = size - 1; (carry !== 0 || i < length) && (it1 !== -1); it1--, i++) {
-        carry += (256 * b58[it1]) >>> 0
-        b58[it1] = (carry % BASE) >>> 0
-        carry = (carry / BASE) >>> 0
-      }
-      if (carry !== 0) { throw new Error('Non-zero carry') }
-      length = i
-      pbegin++
-    }
-        // Skip leading zeroes in base58 result.
-    let it2 = size - length
-    while (it2 !== size && b58[it2] === 0) {
-      it2++
-    }
-        // Translate the result into a string.
-    let str = LEADER.repeat(zeroes)
-    for (; it2 < size; ++it2) { str += ALPHABET.charAt(b58[it2]) }
-    return str
-  }
-
-  const decodeUnsafe = (source: string):Uint8Array | undefined => {
-    if (typeof source !== 'string') { throw new TypeError('Expected String') }
-    if (source.length === 0) { return new Uint8Array() }
-    let psz = 0
-        // Skip and count leading '1's.
-    let zeroes = 0
-    let length = 0
-    while (source[psz] === LEADER) {
-      zeroes++
-      psz++
-    }
-    // Allocate enough space in big-endian base256 representation.
-    const size = (((source.length - psz) * FACTOR) + 1) >>> 0 // log(58) / log(256), rounded up.
-    let b256 = new Uint8Array(size)
-    // Process the characters.
-    while (source[psz]) {
-      // Decode character
-      let carry = BASE_MAP[source.charCodeAt(psz)]
-      // Invalid character
-      if (carry === 255) { return }
-      let i = 0
-      for (let it3 = size - 1; (carry !== 0 || i < length) && (it3 !== -1); it3--, i++) {
-        carry += (BASE * b256[it3]) >>> 0
-        b256[it3] = (carry % 256) >>> 0
-        carry = (carry / 256) >>> 0
-      }
-      if (carry !== 0) { throw new Error('Non-zero carry') }
-      length = i
-      psz++
-    }
-    // Skip leading zeroes in b256.
-    let it4 = size - length
-    while (it4 !== size && b256[it4] === 0) {
-      it4++
-    }
-    let vch = new Uint8Array(zeroes + (size - it4))
-    let j = zeroes
-    while (it4 !== size) {
-      vch[j++] = b256[it4++]
-    }
-    return vch
-  }
-
-  const decode = (string: string):Uint8Array => {
-    const buffer = decodeUnsafe(string)
-    if (buffer) { return buffer }
-    throw new Error('Non-base' + BASE + ' character')
-  }
-
-  return {
-    encode,
-    decodeUnsafe,
-    decode
-  }
-}
-
-export { base as default }

package/test.js

@@ -1,18 +0,0 @@
-import base from './index.js'
-const base32 = base('a1')
-
-// const uint8Array = new Uint8Array(2)
-// uint8Array[0] = Buffer.from('h').toString('hex')
-// uint8Array[1] = Buffer.from('i').toString('hex')
-const uint8Array = new TextEncoder().encode('hi hello, hi');
-const bs32 = base32.encode(uint8Array)
-console.log(bs32);
-const hi = base32.decode(bs32)
-const string = new TextDecoder().decode(hi);
-// let str = ''
-// hi.forEach((item, i) => {
-//   str+= Buffer.from(item.toString(), 'hex').toString()
-// });
-// console.log(hi);
-
-console.log(string === 'hi hello, hi');

package/tsconfig.json

@@ -1,13 +0,0 @@
-{
-  "compilerOptions": {
-    "moduleResolution":"NodeNext",
-    "outDir": "./",
-    "allowJs": true,
-    "target": "es2022",
-    "declaration": true
-  },
-  "include": [
-    "./src/**/*"
-  ],
-  "exclude": ["./tsconfig.json"]
-}