feat(base-n): add en/decodeBytes(), add BASE16_XX

packages/base-n/package.json

@@ -48,6 +48,9 @@
         "typedoc": "^0.20.4",
         "typescript": "^4.1.3"
     },
+    "dependencies": {
+        "@thi.ng/hex": "^0.1.3"
+    },
     "files": [
         "*.js",
         "*.d.ts",

packages/base-n/src/16.ts

@@ -0,0 +1,11 @@
+import { defBase } from "./base";
+
+/**
+ * Digits: 0-9 A-F
+ */
+export const BASE16_UC = defBase("0123456789ABCDEF");
+
+/**
+ * Digits: 0-9 a-f
+ */
+export const BASE16_LC = defBase("0123456789abcdef");

packages/base-n/src/api.ts

@@ -1,4 +1,7 @@
 export interface IBase {
+    readonly N: number;
+    readonly base: string;
+
     /**
      * Encodes `x` into a baseN encoded string. `x` MUST be < 2^53. Use
      * `encodeBigInt()` for arbitrary values.
@@ -12,6 +15,14 @@ export interface IBase {
      * @param x
      */
     encodeBigInt(x: bigint): string;
+
+    /**
+     * Encodes given byte array into a bigint and then baseN encodes it.
+     *
+     * @param buf
+     */
+    encodeBytes(buf: Uint8Array): string;
+
     /**
      * Decodes baseN encoded string `x` into a numeric value. Assumes the
      * resulting `x` will be < 2^53. Use `decodeBigInt()` for arbitrary values.
@@ -25,4 +36,13 @@ export interface IBase {
      * @param x
      */
     decodeBigInt(x: string): bigint;
+    /**
+     * Decodes given string in a byte array. The byte values will be big endian
+     * order, with the LSB aligned to end of the given array. If `buf` is
+     * shorter than the space required by the encoded source string, the most
+     * significant bytes will be ignored.
+     *
+     * @param buf
+     */
+    decodeBytes(x: string, buf: Uint8Array): Uint8Array;
 }

packages/base-n/src/base.ts

@@ -1,3 +1,4 @@
+import { U8 } from "@thi.ng/hex";
 import type { IBase } from "./api";
 
 export const defBase = (chars: string) => new BaseN(chars);
@@ -38,6 +39,12 @@ export class BaseN implements IBase {
         return res;
     }
 
+    encodeBytes(buf: Uint8Array) {
+        let hex = "";
+        for (let i = 0, n = buf.length; i < n; i++) hex += U8(buf[i]);
+        return this.encodeBigInt(BigInt(`0x${hex}`));
+    }
+
     decode(x: string) {
         const { index, N } = this;
         let res = 0;
@@ -57,7 +64,22 @@ export class BaseN implements IBase {
         return res;
     }
 
+    decodeBytes(x: string, buf: Uint8Array): Uint8Array {
+        let y = this.decodeBigInt(x);
+        const M = BigInt(255);
+        const SHIFT = BigInt(8);
+        for (let i = buf.length; --i >= 0; ) {
+            buf[i] = Number(y & M);
+            y >>= SHIFT;
+        }
+        return buf;
+    }
+
     validate(x: string) {
         return new RegExp(`^[${this.base}]+$`).test(x);
     }
+
+    size(x: number) {
+        return Math.ceil(Math.log(x) / Math.log(this.N));
+    }
 }

packages/base-n/src/index.ts

@@ -1,6 +1,7 @@
 export * from "./api";
 export * from "./base";
 
+export * from "./16";
 export * from "./32";
 export * from "./36";
 export * from "./58";

packages/base-n/test/index.ts

@@ -4,34 +4,31 @@ import {
     BASE32_RFC4648,
     BASE36,
     BASE58,
+    BASE62,
     BASE64,
     BASE85,
+    IBase,
 } from "../src";
 
 describe("base-n", () => {
     it("roundtrip", () => {
         const X = BigInt(2) ** BigInt(128) - BigInt(1);
 
-        // prettier-ignore
-        assert.strictEqual(BASE32_RFC4648.encodeBigInt(X), "H7777777777777777777777777");
-        // prettier-ignore
-        assert.strictEqual(BASE32_RFC4648.decodeBigInt("H7777777777777777777777777"), X);
+        const check = (
+            base: IBase,
+            expected: string,
+            id: string | number = base.N
+        ) => {
+            assert.strictEqual(base.encodeBigInt(X), expected, `encode: ${id}`);
+            assert.strictEqual(base.decodeBigInt(expected), X, `decode: ${id}`);
+        };
 
-        // prettier-ignore
-        assert.strictEqual(BASE32_HEX.encodeBigInt(X), "7VVVVVVVVVVVVVVVVVVVVVVVVV");
-        // prettier-ignore
-        assert.strictEqual(BASE32_HEX.decodeBigInt("7VVVVVVVVVVVVVVVVVVVVVVVVV"), X);
-
-        assert.strictEqual(BASE36.encodeBigInt(X), "F5LXX1ZZ5PNORYNQGLHZMSP33");
-        assert.strictEqual(BASE36.decodeBigInt("F5LXX1ZZ5PNORYNQGLHZMSP33"), X);
-
-        assert.strictEqual(BASE58.encodeBigInt(X), "YcVfxkQb6JRzqk5kF2tNLv");
-        assert.strictEqual(BASE58.decodeBigInt("YcVfxkQb6JRzqk5kF2tNLv"), X);
-
-        assert.strictEqual(BASE64.encodeBigInt(X), "3/////////////////////");
-        assert.strictEqual(BASE64.decodeBigInt("3/////////////////////"), X);
-
-        assert.strictEqual(BASE85.encodeBigInt(X), "=r54lj&NUUO~Hi%c2ym0");
-        assert.strictEqual(BASE85.decodeBigInt("=r54lj&NUUO~Hi%c2ym0"), X);
+        check(BASE32_RFC4648, "H7777777777777777777777777", "32rfc");
+        check(BASE32_HEX, "7VVVVVVVVVVVVVVVVVVVVVVVVV", "32hex");
+        check(BASE36, "F5LXX1ZZ5PNORYNQGLHZMSP33");
+        check(BASE58, "YcVfxkQb6JRzqk5kF2tNLv");
+        check(BASE62, "7n42DGM5Tflk9n8mt7Fhc7");
+        check(BASE64, "3/////////////////////");
+        check(BASE85, "=r54lj&NUUO~Hi%c2ym0");
     });
 });