@vandeurenglenn/base16 1.0.1 → 1.1.0

package/README.md

@@ -1,21 +1,21 @@
-# bs32
-
-module compatible base16
-
-## Usage
-
-``` js
-import base16 from '@vandeurenglenn/base16'
-
-const uint8Array = new TextEncoder().encode('hi')
-
-const base16Encoded = base16.encode(uint8Array)
-
-console.log(base16Encoded) // 2dj
-
-const base16Decoded = base16.decode(base16Encoded)
-
-const string = new TextDecoder().decode(base16Decoded)
-
-console.log(string) // hi
-```
+# bs32
+
+module compatible base16
+
+## Usage
+
+``` js
+import base16 from '@vandeurenglenn/base16'
+
+const uint8Array = new TextEncoder().encode('hi')
+
+const base16Encoded = base16.encode(uint8Array)
+
+console.log(base16Encoded) // 2dj
+
+const base16Decoded = base16.decode(base16Encoded)
+
+const string = new TextDecoder().decode(base16Decoded)
+
+console.log(string) // hi
+```

package/index.d.ts

@@ -1,13 +1,12 @@
-/**
- * A base16String only contains [0-9][A-F]
- */
-type base16String = string;
-export declare const decode: (source: string) => Uint8Array;
-export declare const encode: (source: Uint8Array | ArrayBuffer) => string;
-export declare const isBase16: (string: base16String) => boolean;
-declare const _default: {
-    encode: (source: Uint8Array | ArrayBuffer) => string;
-    decode: (source: string) => Uint8Array;
-    isBase16: (string: string) => boolean;
-};
-export default _default;
+declare const encodeJS: (buffer: Uint8Array) => string;
+declare const decodeJS: (string: string) => Uint8Array;
+declare const isBase16JS: (string: string) => boolean;
+export declare const encode: typeof encodeJS;
+export declare const decode: typeof decodeJS;
+export declare const isBase16: typeof isBase16JS;
+declare const index: {
+    encode: typeof encodeJS;
+    decode: typeof decodeJS;
+    isBase16: typeof isBase16JS;
+};
+export default index;

package/index.js

@@ -1,22 +1,87 @@
-import baseX from '@vandeurenglenn/base-x';
-
-const ALPHABET = '0123456789ABCDEF';
-const base16 = baseX(ALPHABET);
-const decode = base16.decode;
-const encode = base16.encode;
-const isBase16 = (string) => {
-    try {
-        decode(string);
-        return true;
-    }
-    catch (e) {
-        return false;
-    }
-};
-var index = {
-    encode,
-    decode,
-    isBase16
+const ALPHABET = "0123456789ABCDEF";
+const INVALID_BASE16 = /[^0-9a-f]/i;
+const BYTE_TO_HEX = Array.from({ length: 256 }, (_, byte) => ALPHABET[byte >> 4] + ALPHABET[byte & 0xf]);
+const PAIR_LOOKUP_THRESHOLD = 512 * 1024;
+const PAIR_LOOKUP_MIN_LENGTH = 1024;
+const LOOKUP = new Uint8Array(256).fill(255);
+let BYTE_PAIR_TO_HEX;
+for (let i = 0; i < 16; i++) {
+    const code = ALPHABET.charCodeAt(i);
+    LOOKUP[code] = i;
+    // Initialize lowercase if it's a letter (A=65, a=97, diff=32)
+    if (i > 9)
+        LOOKUP[code + 32] = i;
+}
+const encodePairsJS = (buffer, lookup) => {
+    let str = "";
+    for (let start = 0; start < buffer.length; start += 8192) {
+        let chunk = "";
+        const end = Math.min(start + 8192, buffer.length);
+        let i = start;
+        for (; i + 1 < end; i += 2) {
+            chunk += lookup[(buffer[i] << 8) | buffer[i + 1]];
+        }
+        if (i < end)
+            chunk += BYTE_TO_HEX[buffer[i]];
+        str += chunk;
+    }
+    return str;
 };
-
-export { decode, index as default, encode, isBase16 };
+const encodeJS = (buffer) => {
+    if (!BYTE_PAIR_TO_HEX && buffer.length >= PAIR_LOOKUP_THRESHOLD) {
+        BYTE_PAIR_TO_HEX = Array.from({ length: 65536 }, (_, pair) => BYTE_TO_HEX[pair >> 8] + BYTE_TO_HEX[pair & 0xff]);
+    }
+    if (BYTE_PAIR_TO_HEX && buffer.length >= PAIR_LOOKUP_MIN_LENGTH) {
+        return encodePairsJS(buffer, BYTE_PAIR_TO_HEX);
+    }
+    let str = "";
+    for (let start = 0; start < buffer.length; start += 4096) {
+        let chunk = "";
+        const end = Math.min(start + 4096, buffer.length);
+        for (let i = start; i < end; i++) {
+            chunk += BYTE_TO_HEX[buffer[i]];
+        }
+        str += chunk;
+    }
+    return str;
+};
+const decodeJS = (string) => {
+    if (string.length % 2 !== 0)
+        throw new Error("Invalid base16 string length");
+    const buffer = new Uint8Array(string.length / 2);
+    for (let i = 0, output = 0; i < string.length; i += 2, output++) {
+        const a = LOOKUP[string.charCodeAt(i)];
+        const b = LOOKUP[string.charCodeAt(i + 1)];
+        if (a === undefined || b === undefined || a === 255 || b === 255)
+            throw new Error("Invalid base16 character");
+        buffer[output] = (a << 4) | b;
+    }
+    return buffer;
+};
+const isBase16JS = (string) => {
+    if (typeof string !== "string")
+        return false;
+    return string.length % 2 === 0 && !INVALID_BASE16.test(string);
+};
+const hasBuffer = typeof Buffer !== "undefined";
+export const encode = hasBuffer
+    ? (buffer) => Buffer.from(buffer.buffer, buffer.byteOffset, buffer.byteLength).toString("hex").toUpperCase()
+    : encodeJS;
+export const decode = hasBuffer
+    ? (string) => {
+        const buffer = Buffer.from(string, "hex");
+        if (buffer.length !== string.length / 2) {
+            if (string.length % 2 !== 0)
+                throw new Error("Invalid base16 string length");
+            throw new Error("Invalid base16 character");
+        }
+        return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    }
+    : decodeJS;
+export const isBase16 = isBase16JS;
+const index = {
+    encode,
+    decode,
+    isBase16,
+};
+export default index;

package/package.json

@@ -1,36 +1,35 @@
-{
-  "name": "@vandeurenglenn/base16",
-  "version": "1.0.1",
-  "description": "Base16",
-  "keywords": [
-    "base",
-    "32",
-    "base16",
-    "bs32"
-  ],
-  "types": "index.d.ts",
-  "license": "MIT",
-  "repository": "git://github.com/vandeurenglenn/base16.git",
-  "homepage": "https://github.com/vandeurenglenn/base16",
-  "bugs": {
-    "url": "https://github.com/vandeurenglenn/base16/issues"
-  },
-  "author": "Vanduren Glenn <vandeurenglenn@gmail.com>",
-  "exports": {
-    ".": "./index.js"
-  },
-  "type": "module",
-  "scripts": {
-    "build": "rollup -c",
-    "test": "node test.js"
-  },
-  "dependencies": {
-    "@vandeurenglenn/base-x": "^1.1.0"
-  },
-  "devDependencies": {
-    "@rollup/plugin-typescript": "^10.0.1",
-    "rollup": "^2.70.2",
-    "tape": "^5.6.1",
-    "tslib": "^2.4.1"
-  }
-}
+{
+  "name": "@vandeurenglenn/base16",
+  "version": "1.1.0",
+  "description": "Base16",
+  "keywords": [
+    "base",
+    "32",
+    "base16",
+    "bs32"
+  ],
+  "license": "MIT",
+  "repository": "git://github.com/vandeurenglenn/base16.git",
+  "homepage": "https://github.com/vandeurenglenn/base16",
+  "bugs": {
+    "url": "https://github.com/vandeurenglenn/base16/issues"
+  },
+  "author": "Vanduren Glenn <vandeurenglenn@gmail.com>",
+  "exports": {
+    ".": {
+      "import": "./index.js",
+      "types": "./index.d.ts"
+    }
+  },
+  "type": "module",
+  "scripts": {
+    "build": "npx typescript",
+    "test": "node test.js"
+  },
+  "dependencies": {
+    "typescript": "^7.0.2"
+  },
+  "devDependencies": {
+    "@types/node": "^26.6.6"
+  }
+}

package/src/index.ts

@@ -1,29 +1,112 @@
-import baseX from '@vandeurenglenn/base-x'
+const ALPHABET = "0123456789ABCDEF";
+const INVALID_BASE16 = /[^0-9a-f]/i;
+const BYTE_TO_HEX = Array.from(
+  { length: 256 },
+  (_, byte) => ALPHABET[byte >> 4] + ALPHABET[byte & 0xf],
+);
+const PAIR_LOOKUP_THRESHOLD = 512 * 1024;
+const PAIR_LOOKUP_MIN_LENGTH = 1024;
+const LOOKUP = new Uint8Array(256).fill(255);
+let BYTE_PAIR_TO_HEX: string[] | undefined;
+for (let i = 0; i < 16; i++) {
+  const code = ALPHABET.charCodeAt(i);
+  LOOKUP[code] = i;
+  // Initialize lowercase if it's a letter (A=65, a=97, diff=32)
+  if (i > 9) LOOKUP[code + 32] = i;
+}
 
-/**
- * A base16String only contains [0-9][A-F]
- */
-type base16String = string
+const encodePairsJS = (
+  buffer: Uint8Array,
+  lookup: string[],
+): string => {
+  let str = "";
+  for (let start = 0; start < buffer.length; start += 8192) {
+    let chunk = "";
+    const end = Math.min(start + 8192, buffer.length);
+    let i = start;
+    for (; i + 1 < end; i += 2) {
+      chunk += lookup[(buffer[i] << 8) | buffer[i + 1]];
+    }
+    if (i < end) chunk += BYTE_TO_HEX[buffer[i]];
+    str += chunk;
+  }
+  return str;
+};
 
-const ALPHABET = '0123456789ABCDEF'
+const encodeJS = (buffer: Uint8Array): string => {
+  if (!BYTE_PAIR_TO_HEX && buffer.length >= PAIR_LOOKUP_THRESHOLD) {
+    BYTE_PAIR_TO_HEX = Array.from(
+      { length: 65536 },
+      (_, pair) => BYTE_TO_HEX[pair >> 8] + BYTE_TO_HEX[pair & 0xff],
+    );
+  }
+  if (BYTE_PAIR_TO_HEX && buffer.length >= PAIR_LOOKUP_MIN_LENGTH) {
+    return encodePairsJS(buffer, BYTE_PAIR_TO_HEX);
+  }
 
-const base16 = baseX(ALPHABET)
+  let str = "";
+  for (let start = 0; start < buffer.length; start += 4096) {
+    let chunk = "";
+    const end = Math.min(start + 4096, buffer.length);
+    for (let i = start; i < end; i++) {
+      chunk += BYTE_TO_HEX[buffer[i]];
+    }
+    str += chunk;
+  }
+  return str;
+};
 
-export const decode = base16.decode
+const decodeJS = (string: string): Uint8Array => {
+  if (string.length % 2 !== 0) throw new Error("Invalid base16 string length");
+  const buffer = new Uint8Array(string.length / 2);
+  for (let i = 0, output = 0; i < string.length; i += 2, output++) {
+    const a = LOOKUP[string.charCodeAt(i)];
+    const b = LOOKUP[string.charCodeAt(i + 1)];
+    if (a === undefined || b === undefined || a === 255 || b === 255)
+      throw new Error("Invalid base16 character");
+    buffer[output] = (a << 4) | b;
+  }
+  return buffer;
+};
 
-export const encode = base16.encode
+const isBase16JS = (string: string): boolean => {
+  if (typeof string !== "string") return false;
+  return string.length % 2 === 0 && !INVALID_BASE16.test(string);
+};
 
-export const isBase16 = (string: base16String): boolean => {
-  try {
-    decode(string)
-    return true;
-  } catch (e) {
-    return false;
-  }
-}
+const hasBuffer = typeof Buffer !== "undefined";
+
+export const encode = hasBuffer
+  ? (buffer: Uint8Array): string =>
+      Buffer.from(
+        buffer.buffer,
+        buffer.byteOffset,
+        buffer.byteLength,
+      ).toString("hex").toUpperCase()
+  : encodeJS;
+
+export const decode = hasBuffer
+  ? (string: string): Uint8Array => {
+      const buffer = Buffer.from(string, "hex");
+      if (buffer.length !== string.length / 2) {
+        if (string.length % 2 !== 0)
+          throw new Error("Invalid base16 string length");
+        throw new Error("Invalid base16 character");
+      }
+      return new Uint8Array(
+        buffer.buffer,
+        buffer.byteOffset,
+        buffer.byteLength,
+      );
+    }
+  : decodeJS;
 
-export default {
+export const isBase16 = isBase16JS;
+
+const index = {
   encode,
   decode,
-  isBase16
-}
+  isBase16,
+};
+
+export default index;

package/tsconfig.json

@@ -1,13 +1,17 @@
-{
-  "compilerOptions": {
-    "moduleResolution":"NodeNext",
-    "outDir": "./",
-    "allowJs": true,
-    "target": "es2022",
-    "declaration": true
-  },
-  "include": [
-    "./src/**/*"
-  ],
-  "exclude": ["./tsconfig.json"]
+{
+  "compilerOptions": {
+    "target": "esnext",
+    "moduleResolution":"NodeNext",
+    "module": "nodenext",
+    "outDir": "./",
+    "rootDir": "./src",
+    "allowJs": true,
+    "declaration": true,
+    "types": ["node"]
+  },
+  
+  "include": [
+    "./src/**/*"
+  ],
+  "exclude": ["./tsconfig.json"]
 }

package/rollup.config.js

@@ -1,20 +0,0 @@
-import typescript from '@rollup/plugin-typescript';
-
-export default [{
-  input: ['./src/index.ts'],
-  output: [{
-    dir: './',
-    format: 'es'
-  }],
-  external: [
-    '@vandeurenglenn/base-x'
-  ],
-  plugins: [
-    typescript({
-      "outDir": "./",
-      "allowJs": true,
-      "target": "es2022",
-      "declaration": true
-    })
-  ]
-}]