@vandeurenglenn/base-x 1.1.0 → 1.1.2

package/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ *  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/{dist/base-x.js → index.js}

@@ -3,27 +3,27 @@
 // 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.
-var base = function (ALPHABET) {
+const base = (ALPHABET) => {
     if (ALPHABET.length >= 255) {
         throw new TypeError('Alphabet too long');
     }
-    var BASE_MAP = new Uint8Array(256);
-    for (var j = 0; j < BASE_MAP.length; j++) {
+    const BASE_MAP = new Uint8Array(256);
+    for (let j = 0; j < BASE_MAP.length; j++) {
         BASE_MAP[j] = 255;
     }
-    for (var i = 0; i < ALPHABET.length; i++) {
-        var x = ALPHABET.charAt(i);
-        var xc = x.charCodeAt(0);
+    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;
     }
-    var BASE = ALPHABET.length;
-    var LEADER = ALPHABET.charAt(0);
-    var FACTOR = Math.log(BASE) / Math.log(256); // log(BASE) / log(256), rounded up
-    var iFACTOR = Math.log(256) / Math.log(BASE); // log(256) / log(BASE), rounded up
-    var encode = function (source) {
+    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);
@@ -38,23 +38,23 @@ var base = function (ALPHABET) {
             return '';
         }
         // Skip & count leading zeroes.
-        var zeroes = 0;
-        var length = 0;
-        var pbegin = 0;
-        var pend = source.length;
+        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.
-        var size = ((pend - pbegin) * iFACTOR + 1) >>> 0;
-        var b58 = new Uint8Array(size);
+        const size = ((pend - pbegin) * iFACTOR + 1) >>> 0;
+        const b58 = new Uint8Array(size);
         // Process the bytes.
         while (pbegin !== pend) {
-            var carry = source[pbegin];
+            let carry = source[pbegin];
             // Apply "b58 = b58 * 256 + ch".
-            var i = 0;
-            for (var it1 = size - 1; (carry !== 0 || i < length) && (it1 !== -1); it1--, i++) {
+            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;
@@ -66,45 +66,45 @@ var base = function (ALPHABET) {
             pbegin++;
         }
         // Skip leading zeroes in base58 result.
-        var it2 = size - length;
+        let it2 = size - length;
         while (it2 !== size && b58[it2] === 0) {
             it2++;
         }
         // Translate the result into a string.
-        var str = LEADER.repeat(zeroes);
+        let str = LEADER.repeat(zeroes);
         for (; it2 < size; ++it2) {
             str += ALPHABET.charAt(b58[it2]);
         }
         return str;
     };
-    var decodeUnsafe = function (source) {
+    const decodeUnsafe = (source) => {
         if (typeof source !== 'string') {
             throw new TypeError('Expected String');
         }
         if (source.length === 0) {
             return new Uint8Array();
         }
-        var psz = 0;
+        let psz = 0;
         // Skip and count leading '1's.
-        var zeroes = 0;
-        var length = 0;
+        let zeroes = 0;
+        let length = 0;
         while (source[psz] === LEADER) {
             zeroes++;
             psz++;
         }
         // Allocate enough space in big-endian base256 representation.
-        var size = (((source.length - psz) * FACTOR) + 1) >>> 0; // log(58) / log(256), rounded up.
-        var b256 = new Uint8Array(size);
+        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
-            var carry = BASE_MAP[source.charCodeAt(psz)];
+            let carry = BASE_MAP[source.charCodeAt(psz)];
             // Invalid character
             if (carry === 255) {
                 return;
             }
-            var i = 0;
-            for (var it3 = size - 1; (carry !== 0 || i < length) && (it3 !== -1); it3--, i++) {
+            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;
@@ -116,28 +116,28 @@ var base = function (ALPHABET) {
             psz++;
         }
         // Skip leading zeroes in b256.
-        var it4 = size - length;
+        let it4 = size - length;
         while (it4 !== size && b256[it4] === 0) {
             it4++;
         }
-        var vch = new Uint8Array(zeroes + (size - it4));
-        var j = zeroes;
+        let vch = new Uint8Array(zeroes + (size - it4));
+        let j = zeroes;
         while (it4 !== size) {
             vch[j++] = b256[it4++];
         }
         return vch;
     };
-    var decode = function (string) {
-        var buffer = decodeUnsafe(string);
+    const decode = (string) => {
+        const buffer = decodeUnsafe(string);
         if (buffer) {
             return buffer;
         }
         throw new Error('Non-base' + BASE + ' character');
     };
     return {
-        encode: encode,
-        decodeUnsafe: decodeUnsafe,
-        decode: decode
+        encode,
+        decodeUnsafe,
+        decode
     };
 };
 

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "@vandeurenglenn/base-x",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "",
-  "main": "dist/base-x.js",
+  "exports": {
+    ".": "./index.js"
+  },
   "type": "module",
+  "types": "./index.d.ts",
   "scripts": {
     "build": "rollup -c",
     "test": "echo \"Error: no test specified\" && exit 1"

package/src/{base-x.ts → index.ts}

@@ -1,9 +1,20 @@
+/**
+ *  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 => {
+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++) {
@@ -66,7 +77,7 @@ const base = (ALPHABET: string): baseX => {
     return str
   }
 
-  const decodeUnsafe = (source: string): Uint8Array | undefined => {
+  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
@@ -109,7 +120,7 @@ const base = (ALPHABET: string): baseX => {
     return vch
   }
 
-  const decode = (string: string): Uint8Array => {
+  const decode = (string: string):Uint8Array => {
     const buffer = decodeUnsafe(string)
     if (buffer) { return buffer }
     throw new Error('Non-base' + BASE + ' character')

package/test.js

@@ -1,10 +1,10 @@
-import base from './dist/base-x.js'
-const base32 = base('abcdefghijklmnopqrstuvwxyz234567')
+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');
+const uint8Array = new TextEncoder().encode('hi hello, hi');
 const bs32 = base32.encode(uint8Array)
 console.log(bs32);
 const hi = base32.decode(bs32)
@@ -15,4 +15,4 @@ const string = new TextDecoder().decode(hi);
 // });
 // console.log(hi);
 
-console.log(string === 'hi');
+console.log(string === 'hi hello, hi');

package/tsconfig.json

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

package/src/baseX.ts

@@ -1,5 +0,0 @@
-interface baseX {
-  encode: (source: Uint8Array | ArrayBuffer) => string;
-  decode: (source: string) => Uint8Array;
-  decodeUnsafe: (source: string) => Uint8Array | undefined;
-}