split convert into array.js and hex.js

Author: ChALkeR

array.js

@@ -0,0 +1,17 @@
+import { assertTypedArray } from './assert.js'
+
+const { Buffer } = globalThis // Buffer is optional
+
+export function fromTypedArray(arr, format = 'uint8') {
+  assertTypedArray(arr)
+  switch (format) {
+    case 'uint8':
+      if (arr.constructor === Uint8Array) return arr // fast path
+      return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength)
+    case 'buffer':
+      if (arr.constructor === Buffer && Buffer.isBuffer(arr)) return arr
+      return Buffer.from(arr.buffer, arr.byteOffset, arr.byteLength)
+  }
+
+  throw new TypeError('Unexpected format')
+}

assert.js

@@ -8,6 +8,12 @@ export function assertEmptyRest(rest) {
 
 const makeMessage = (name, extra) => `Expected${name ? ` ${name} to be` : ''} an Uint8Array${extra}`
 
+const TypedArray = Object.getPrototypeOf(Uint8Array)
+
+export function assertTypedArray(arr) {
+  assert(arr instanceof TypedArray, 'Expected a TypedArray instance')
+}
+
 export function assertUint8(arr, { name, length, ...rest } = {}) {
   assertEmptyRest(rest)
   if (arr instanceof Uint8Array && (length === undefined || arr.length === length)) return

base64.js

@@ -1,5 +1,5 @@
 import { assert, assertUint8 } from './assert.js'
-import { fromTypedArray } from './convert.js'
+import { fromTypedArray } from './array.js'
 
 // See https://datatracker.ietf.org/doc/html/rfc4648
 

benchmarks/hex.bench.js

@@ -0,0 +1,36 @@
+import * as exodus from '@exodus/bytes/hex.js'
+import { hex as scureHex } from '@scure/base'
+import buffer from 'buffer/index.js'
+
+import { bufs } from './random.js'
+
+if (!globalThis.Buffer) globalThis.Buffer = buffer.Buffer
+Buffer.TYPED_ARRAY_SUPPORT = true
+const exodusPure = await import('../hex.js?pure')
+delete Buffer.TYPED_ARRAY_SUPPORT
+
+const val = exodus.toHex(bufs[0])
+if (scureHex.encode(bufs[0]) !== val) throw new Error('scure.hex')
+if (exodusPure.toHex(bufs[0]) !== val) throw new Error('exodus pure')
+
+for (let i = 0; i < 5; i++) {
+  console.time('@exodus/bytes/hex.js')
+  for (const buf of bufs) exodus.toHex(buf)
+  console.timeEnd('@exodus/bytes/hex.js')
+
+  console.time('@exodus/bytes/hex.js, pure')
+  for (const buf of bufs) exodusPure.toHex(buf)
+  console.timeEnd('@exodus/bytes/hex.js, pure')
+
+  console.time('@scure/base')
+  for (const buf of bufs) scureHex.encode(buf)
+  console.timeEnd('@scure/base')
+
+  console.time('Buffer.from')
+  for (const buf of bufs) Buffer.from(buf).toString('hex')
+  console.timeEnd('Buffer.from')
+
+  console.time('buffer/Buffer.from')
+  for (const buf of bufs) buffer.Buffer.from(buf).toString('hex')
+  console.timeEnd('buffer/Buffer.from')
+}

benchmarks/hex.from.bench.js

@@ -0,0 +1,38 @@
+import * as exodus from '@exodus/bytes/hex.js'
+import { hex as scureHex } from '@scure/base'
+import buffer from 'buffer/index.js'
+
+import { bufs } from './random.js'
+
+if (!globalThis.Buffer) globalThis.Buffer = buffer.Buffer
+Buffer.TYPED_ARRAY_SUPPORT = true
+const exodusPure = await import('../hex.js?pure')
+delete Buffer.TYPED_ARRAY_SUPPORT
+
+const strings = bufs.map(x => exodus.fromTypedArray(x, 'hex'))
+
+if (Buffer.compare(exodus.fromHex(strings[0]), bufs[0]) !== 0) throw new Error('exodus')
+if (Buffer.compare(exodusPure.fromHex(strings[0]), bufs[0]) !== 0) throw new Error('exodus pure')
+if (Buffer.compare(scureHex.decode(strings[0]), bufs[0]) !== 0) throw new Error('scure.hex')
+
+for (let i = 0; i < 5; i++) {
+  console.time('@exodus/bytes/hex.js')
+  for (const str of strings) exodus.fromHex(str)
+  console.timeEnd('@exodus/bytes/hex.js')
+
+  console.time('@exodus/bytes/hex.js, pure')
+  for (const str of strings) exodusPure.fromHex(str)
+  console.timeEnd('@exodus/bytes/hex.js, pure')
+
+  console.time('@scure/base')
+  for (const str of strings) scureHex.decode(str)
+  console.timeEnd('@scure/base')
+
+  console.time('Buffer.from')
+  for (const str of strings) Buffer.from(str, 'hex')
+  console.timeEnd('Buffer.from')
+
+  console.time('buffer/Buffer.from')
+  for (const str of strings) buffer.Buffer.from(str, 'hex')
+  console.timeEnd('buffer/Buffer.from')
+}

convert.js

@@ -0,0 +1,51 @@
+import { assertTypedArray, assert } from './assert.js'
+import { fromTypedArray } from './array.js'
+
+const { Buffer } = globalThis // Buffer is optional, only used when native
+const haveNativeBuffer = Buffer && !Buffer.TYPED_ARRAY_SUPPORT
+
+let hexArray
+let dehexArray
+
+export function toHex(arr) {
+  assertTypedArray(arr)
+  const u8 = arr instanceof Uint8Array ? arr : new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength)
+  if (Uint8Array.prototype.toHex && u8.toHex === Uint8Array.prototype.toHex) return u8.toHex()
+  if (haveNativeBuffer) {
+    if (arr.constructor === Buffer && Buffer.isBuffer(arr)) return arr.toString('hex')
+    return Buffer.from(arr.buffer, arr.byteOffset, arr.byteLength).toString('hex')
+  }
+  if (!hexArray) hexArray = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'))
+  let out = ''
+  for (let i = 0; i < arr.length; i++) out += hexArray[u8[i]]
+  return out
+}
+
+// Unlike Buffer.from(), throws on invalid input
+export function fromHex(arg, format = 'uint8') {
+  if (Uint8Array.fromHex) return fromTypedArray(Uint8Array.fromHex(arg), format)
+  if (typeof arg !== 'string') throw new TypeError('Input is not a string')
+  assert(arg.length % 2 === 0, 'Input is not a hex string')
+  if (haveNativeBuffer) {
+    assert(!/[^0-9a-f]/ui.test(arg), 'Input is not a hex string')
+    return fromTypedArray(Buffer.from(arg, 'hex'), format)
+  }
+
+  if (!dehexArray) {
+    dehexArray = new Array(103) // f is 102
+    for (let i = 0; i < 16; i++) {
+      const s = i.toString(16)
+      dehexArray[s.charCodeAt(0)] = dehexArray[s.toUpperCase().charCodeAt(0)] = i
+    }
+  }
+
+  const arr = new Uint8Array(arg.length / 2)
+  let j = 0
+  for (let i = 0; i < arr.length; i++) {
+    const a = dehexArray[arg.charCodeAt(j++)] * 16 + dehexArray[arg.charCodeAt(j++)]
+    if (!a && Number.isNaN(a)) throw new Error('Input is not a hex string')
+    arr[i] = a
+  }
+
+  return fromTypedArray(arr, format)
+}

hex.js

@@ -39,12 +39,14 @@
   "files": [
     "/assert.js",
     "/base64.js",
-    "/convert.js"
+    "/array.js",
+    "/hex.js"
   ],
   "exports": {
     "./assert.js": "./assert.js",
     "./base64.js": "./base64.js",
-    "./convert.js": "./convert.js"
+    "./array.js": "./array.js",
+    "./hex.js": "./hex.js"
   },
   "dependencies": {},
   "devDependencies": {

package.json

@@ -1,4 +1,4 @@
-import { fromTypedArray, fromHex } from '@exodus/bytes/convert.js'
+import { fromTypedArray } from '@exodus/bytes/array.js'
 import { describe, test } from 'node:test'
 
 const raw = [new Uint8Array(), new Uint8Array([0]), new Uint8Array([1]), new Uint8Array([255])]
@@ -16,7 +16,7 @@ describe('fromTypedArray', () => {
   test('invalid input', (t) => {
     for (const input of [null, undefined, [], [1,2], 'string']) {
       t.assert.throws(() => fromTypedArray(input))
-      for (const form of ['uint8', 'buffer', 'hex']) {
+      for (const form of ['uint8', 'buffer']) {
         t.assert.throws(() => fromTypedArray(input, form))
       }
     }
@@ -43,40 +43,4 @@ describe('fromTypedArray', () => {
       t.assert.strictEqual(a.buffer, uint8.buffer)
     }
   })
-
-  test('hex', (t) => {
-    for (const { uint8, buffer, hex} of pool) {
-      t.assert.strictEqual(fromTypedArray(uint8, 'hex'), hex)
-      t.assert.strictEqual(fromTypedArray(buffer, 'hex'), hex)
-    }
-  })
-})
-
-describe('fromHex', () => {
-  test('invalid input', (t) => {
-    for (const input of [null, undefined, [], [1,2], ['00'], new Uint8Array(), 'a', '0x00', 'ag']) {
-      if (Uint8Array.fromHex) t.assert.throws(() => Uint8Array.fromHex(input))
-      t.assert.throws(() => fromHex(input))
-      for (const form of ['uint8', 'buffer', 'hex']) {
-        t.assert.throws(() => fromHex(input, form))
-      }
-    }
-  })
-
-  test('uint8', (t) => {
-    for (const { hex, uint8 } of pool) {
-      t.assert.deepStrictEqual(fromHex(hex), uint8)
-      t.assert.deepStrictEqual(fromHex(hex, 'uint8'), uint8)
-    }
-  })
-
-  test('buffer', (t) => {
-    for (const { hex, buffer } of pool) {
-      t.assert.deepStrictEqual(fromHex(hex, 'buffer'), buffer)
-    }
-  })
-
-  test('hex', (t) => {
-    for (const { hex } of pool) t.assert.strictEqual(fromHex(hex, 'hex'), hex)
-  })
 })

tests/convert.test.js tests/array.test.jstests/convert.test.js renamed to tests/array.test.js

@@ -99,11 +99,4 @@ describe('fromBase64', () => {
       t.assert.deepStrictEqual(fromBase64url(base64url, 'buffer'), buffer)
     }
   })
-
-  test('hex', (t) => {
-    for (const { hex, base64, base64url } of pool) {
-      t.assert.strictEqual(fromBase64(base64, 'hex'), hex)
-      t.assert.strictEqual(fromBase64url(base64url, 'hex'), hex)
-    }
-  })
 })