@exodus/bytes 1.0.0-rc.2 → 1.0.0-rc.3

package/array.js

@@ -2,7 +2,7 @@ import { assertTypedArray } from './assert.js'
 
 const { Buffer } = globalThis // Buffer is optional
 
-export function fromTypedArray(arr, format) {
+export function typedView(arr, format) {
   assertTypedArray(arr)
   switch (format) {
     case 'uint8':

package/assert.js

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

package/base64.js

@@ -1,5 +1,6 @@
 import { assert, assertUint8 } from './assert.js'
-import { fromTypedArray } from './array.js'
+import { typedView } from './array.js'
+import * as js from './fallback/base64.js'
 
 // See https://datatracker.ietf.org/doc/html/rfc4648
 
@@ -13,7 +14,7 @@ const { toBase64: web64 } = Uint8Array.prototype // Modern engines have this
 export function toBase64(x) {
   assertUint8(x)
   if (web64 && x.toBase64 === web64) return x.toBase64() // Modern
-  if (!haveNativeBuffer) return toBase64js(x, BASE64, true) // Fallback
+  if (!haveNativeBuffer) return js.toBase64(x, false, true) // Fallback
   if (x.constructor === Buffer && Buffer.isBuffer(x)) return x.toString('base64') // Older Node.js
   return Buffer.from(x.buffer, x.byteOffset, x.byteLength).toString('base64') // Older Node.js
 }
@@ -22,7 +23,7 @@ export function toBase64(x) {
 export function toBase64url(x) {
   assertUint8(x)
   if (web64 && x.toBase64 === web64) return x.toBase64({ alphabet: 'base64url', omitPadding: true }) // Modern
-  if (!haveNativeBuffer) return toBase64js(x, BASE64URL, false) // Fallback
+  if (!haveNativeBuffer) return js.toBase64(x, true, false) // Fallback
   if (x.constructor === Buffer && Buffer.isBuffer(x)) return x.toString('base64url') // Older Node.js
   return Buffer.from(x.buffer, x.byteOffset, x.byteLength).toString('base64url') // Older Node.js
 }
@@ -42,7 +43,7 @@ export function fromBase64(str, format = 'uint8') {
     assert(str[str.length - 3] !== '=', 'Excessive padding') // no more than two = at the end
   }
 
-  return fromTypedArray(fromBase64common(str, false), format)
+  return typedView(fromBase64common(str, false), format)
 }
 
 // Accepts both only non-padded strict base64url
@@ -53,7 +54,7 @@ export function fromBase64url(str, format = 'uint8') {
   assert(str.length % 4 !== 1, 'Invalid base64 length') // JSC misses this in fromBase64
   assert(!str.endsWith('='), 'Did not expect padding in base64url input') // inclusion is checked separately
 
-  return fromTypedArray(fromBase64common(str, true), format)
+  return typedView(fromBase64common(str, true), format)
 }
 
 let fromBase64common
@@ -87,7 +88,7 @@ if (Uint8Array.fromBase64) {
         if (at >= 0) assert(!/[^=]/iu.test(str.slice(at)), 'Invalid padding')
       }
 
-      arr = haveNativeBuffer ? Buffer.from(str, 'base64') : fromBase64js(str)
+      arr = haveNativeBuffer ? Buffer.from(str, 'base64') : js.fromBase64(str)
     }
 
     if (arr.length % 3 !== 0) {
@@ -101,105 +102,3 @@ if (Uint8Array.fromBase64) {
     return arr
   }
 }
-
-const BASE64 = [...'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/']
-const BASE64URL = [...'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_']
-
-const BASE64_PAIRS = []
-const BASE64URL_PAIRS = []
-
-// We construct output by concatenating chars, this seems to be fine enough on modern JS engines
-function toBase64js(arr, alphabet, padding) {
-  assertUint8(arr)
-  const fullChunks = Math.floor(arr.length / 3)
-  const fullChunksBytes = fullChunks * 3
-  let o = ''
-  let i = 0
-
-  const pairs = alphabet === BASE64URL ? BASE64URL_PAIRS : BASE64_PAIRS
-  if (pairs.length === 0) {
-    for (let i = 0; i < 64; i++) {
-      for (let j = 0; j < 64; j++) pairs.push(`${alphabet[i]}${alphabet[j]}`)
-    }
-  }
-
-  // Fast path for complete blocks
-  // This whole loop can be commented out, the algorithm won't change, it's just an optimization of the next loop
-  for (; i < fullChunksBytes; i += 3) {
-    const a = arr[i]
-    const b = arr[i + 1]
-    const c = arr[i + 2]
-    o += pairs[(a << 4) | (b >> 4)] + pairs[((b & 0x0f) << 8) | c]
-  }
-
-  // If we have something left, process it with a full algo
-  let carry = 0
-  let shift = 2 // First byte needs to be shifted by 2 to get 6 bits
-  const length = arr.length
-  for (; i < length; i++) {
-    const x = arr[i]
-    o += alphabet[carry | (x >> shift)] // shift >= 2, so this fits
-    if (shift === 6) {
-      shift = 0
-      o += alphabet[x & 0x3f]
-    }
-
-    carry = (x << (6 - shift)) & 0x3f
-    shift += 2 // Each byte prints 6 bits and leaves 2 bits
-  }
-
-  if (shift !== 2) o += alphabet[carry] // shift 2 means we have no carry left
-  if (padding) o += ['', '==', '='][length - fullChunksBytes]
-
-  return o
-}
-
-// Assumes no chars after =, checked
-let fromBase64jsMap
-
-function fromBase64js(str) {
-  const map = fromBase64jsMap || new Array(256)
-  if (!fromBase64jsMap) {
-    fromBase64jsMap = map
-    BASE64.forEach((c, i) => (map[c.charCodeAt(0)] = i))
-    map['-'.charCodeAt(0)] = map['+'.charCodeAt(0)] // for base64url
-    map['_'.charCodeAt(0)] = map['/'.charCodeAt(0)] // for base64url
-  }
-
-  let inputLength = str.length
-  while (str[inputLength - 1] === '=') inputLength--
-
-  const arr = new Uint8Array(Math.floor((inputLength * 3) / 4))
-  const tailLength = inputLength % 4
-  const mainLength = inputLength - tailLength // multiples of 4
-
-  let at = 0
-  let i = 0
-  let tmp
-
-  while (i < mainLength) {
-    tmp =
-      (map[str.charCodeAt(i)] << 18) |
-      (map[str.charCodeAt(i + 1)] << 12) |
-      (map[str.charCodeAt(i + 2)] << 6) |
-      map[str.charCodeAt(i + 3)]
-    arr[at++] = tmp >> 16
-    arr[at++] = (tmp >> 8) & 0xff
-    arr[at++] = tmp & 0xff
-    i += 4
-  }
-
-  if (tailLength === 3) {
-    tmp =
-      (map[str.charCodeAt(i)] << 10) |
-      (map[str.charCodeAt(i + 1)] << 4) |
-      (map[str.charCodeAt(i + 2)] >> 2)
-    arr[at++] = (tmp >> 8) & 0xff
-    arr[at++] = tmp & 0xff
-  } else if (tailLength === 2) {
-    tmp = (map[str.charCodeAt(i)] << 2) | (map[str.charCodeAt(i + 1)] >> 4)
-    arr[at++] = tmp & 0xff
-  }
-
-  return arr
-}

package/fallback/base64.js

@@ -0,0 +1,127 @@
+import { assertUint8 } from '../assert.js'
+
+// See https://datatracker.ietf.org/doc/html/rfc4648
+
+const { TextDecoder } = globalThis
+const nativeDecoder = TextDecoder?.toString().includes('[native code]') ? new TextDecoder() : null
+const BASE64 = [...'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/']
+const BASE64URL = [...'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_']
+const BASE64_PAIRS = []
+const BASE64URL_PAIRS = []
+const BASE64_CODES = nativeDecoder ? new Uint8Array(64) : null
+const BASE64URL_CODES = nativeDecoder ? new Uint8Array(64) : null
+
+// Alternatively, we could have mapped 0-255 bytes to charcodes and just used btoa(ascii),
+// but that approach is _slower_ than our toBase64js function, even on Hermes
+
+// We construct output by concatenating chars, this seems to be fine enough on modern JS engines
+export function toBase64(arr, isURL, padding) {
+  assertUint8(arr)
+  const fullChunks = Math.floor(arr.length / 3)
+  const fullChunksBytes = fullChunks * 3
+  let o = ''
+  let i = 0
+
+  const alphabet = isURL ? BASE64URL : BASE64
+  const pairs = isURL ? BASE64URL_PAIRS : BASE64_PAIRS
+  const map = isURL ? BASE64_CODES : BASE64URL_CODES
+  if (pairs.length === 0) {
+    for (let i = 0; i < 64; i++) {
+      for (let j = 0; j < 64; j++) pairs.push(`${alphabet[i]}${alphabet[j]}`)
+      if (map) map[i] = alphabet[i].charCodeAt(0)
+    }
+  }
+
+  // Fast path for complete blocks
+  // This whole loop can be commented out, the algorithm won't change, it's just an optimization of the next loop
+  if (nativeDecoder) {
+    const oa = new Uint8Array(fullChunks * 4)
+    for (let j = 0; i < fullChunksBytes; i += 3) {
+      const a = arr[i]
+      const b = arr[i + 1]
+      const c = arr[i + 2]
+      oa[j++] = map[a >> 2]
+      oa[j++] = map[((a & 0x3) << 4) | (b >> 4)]
+      oa[j++] = map[((b & 0xf) << 2) | (c >> 6)]
+      oa[j++] = map[c & 0x3f]
+    }
+
+    o = nativeDecoder.decode(oa)
+  } else {
+    for (; i < fullChunksBytes; i += 3) {
+      const a = arr[i]
+      const b = arr[i + 1]
+      const c = arr[i + 2]
+      o += pairs[(a << 4) | (b >> 4)] + pairs[((b & 0x0f) << 8) | c]
+    }
+  }
+
+  // If we have something left, process it with a full algo
+  let carry = 0
+  let shift = 2 // First byte needs to be shifted by 2 to get 6 bits
+  const length = arr.length
+  for (; i < length; i++) {
+    const x = arr[i]
+    o += alphabet[carry | (x >> shift)] // shift >= 2, so this fits
+    if (shift === 6) {
+      shift = 0
+      o += alphabet[x & 0x3f]
+    }
+
+    carry = (x << (6 - shift)) & 0x3f
+    shift += 2 // Each byte prints 6 bits and leaves 2 bits
+  }
+
+  if (shift !== 2) o += alphabet[carry] // shift 2 means we have no carry left
+  if (padding) o += ['', '==', '='][length - fullChunksBytes]
+
+  return o
+}
+
+let fromBase64jsMap
+
+// Assumes valid input and no chars after =, checked at API
+// Last chunk is rechecked at API too
+export function fromBase64(str) {
+  const map = fromBase64jsMap || new Array(256)
+  if (!fromBase64jsMap) {
+    fromBase64jsMap = map
+    BASE64.forEach((c, i) => (map[c.charCodeAt(0)] = i))
+    map['-'.charCodeAt(0)] = map['+'.charCodeAt(0)] // for base64url
+    map['_'.charCodeAt(0)] = map['/'.charCodeAt(0)] // for base64url
+  }
+
+  let inputLength = str.length
+  while (str[inputLength - 1] === '=') inputLength--
+
+  const arr = new Uint8Array(Math.floor((inputLength * 3) / 4))
+  const tailLength = inputLength % 4
+  const mainLength = inputLength - tailLength // multiples of 4
+
+  let at = 0
+  let i = 0
+  let tmp
+
+  while (i < mainLength) {
+    // a [ b c ] d, each 6 bits
+    const bc = (map[str.charCodeAt(i + 1)] << 6) | map[str.charCodeAt(i + 2)]
+    arr[at++] = (map[str.charCodeAt(i)] << 2) | (bc >> 10)
+    arr[at++] = (bc >> 2) & 0xff
+    arr[at++] = ((bc << 6) & 0xff) | map[str.charCodeAt(i + 3)]
+    i += 4
+  }
+
+  if (tailLength === 3) {
+    tmp =
+      (map[str.charCodeAt(i)] << 10) |
+      (map[str.charCodeAt(i + 1)] << 4) |
+      (map[str.charCodeAt(i + 2)] >> 2)
+    arr[at++] = (tmp >> 8) & 0xff
+    arr[at++] = tmp & 0xff
+  } else if (tailLength === 2) {
+    tmp = (map[str.charCodeAt(i)] << 2) | (map[str.charCodeAt(i + 1)] >> 4)
+    arr[at++] = tmp & 0xff
+  }
+
+  return arr
+}

package/fallback/hex.js

@@ -0,0 +1,90 @@
+import { assert, assertUint8 } from '../assert.js'
+
+// We use TextEncoder here to parse strings to charcodes, this is faster than individual charCodeAt calls
+const { TextEncoder } = globalThis // Buffer is optional, only used when native
+const nativeEncoder = TextEncoder?.toString().includes('[native code]') ? new TextEncoder() : null
+
+let hexArray
+let dehexArray
+
+function toHexPart(arr, start, end) {
+  let o = ''
+  let i = start
+  const last3 = end - 3
+  // Unrolled loop is faster
+  while (i < last3) {
+    const a = arr[i++]
+    const b = arr[i++]
+    const c = arr[i++]
+    const d = arr[i++]
+    o += hexArray[a]
+    o += hexArray[b]
+    o += hexArray[c]
+    o += hexArray[d]
+  }
+
+  while (i < end) o += hexArray[arr[i++]]
+  return o
+}
+
+export function toHex(arr) {
+  assertUint8(arr)
+
+  if (!hexArray) hexArray = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'))
+  const length = arr.length // this helps Hermes
+
+  if (length > 30_000) {
+    // Limit concatenation to avoid excessive GC
+    // Thresholds checked on Hermes
+    const concat = []
+    for (let i = 0; i < length; ) {
+      const step = i + 500
+      const end = step > length ? length : step
+      concat.push(toHexPart(arr, i, end))
+      i = end
+    }
+
+    const res = concat.join('')
+    concat.length = 0
+    return res
+  }
+
+  return toHexPart(arr, 0, length)
+}
+
+export function fromHex(str) {
+  if (typeof str !== 'string') throw new TypeError('Input is not a string')
+  assert(str.length % 2 === 0, 'Input is not a hex string')
+
+  // We don't use native Buffer impl, as rechecking input make it slower than pure js
+  // This path is used only on older engines though
+
+  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 length = str.length / 2 // this helps Hermes in loops
+  const arr = new Uint8Array(length)
+  let j = 0
+  if (nativeEncoder) {
+    // Native encoder path is beneficial even for small arrays in Hermes
+    const codes = nativeEncoder.encode(str)
+    for (let i = 0; i < length; i++) {
+      const a = dehexArray[codes[j++]] * 16 + dehexArray[codes[j++]]
+      if (!a && a !== 0) throw new Error('Input is not a hex string')
+      arr[i] = a
+    }
+  } else {
+    for (let i = 0; i < length; i++) {
+      const a = dehexArray[str.charCodeAt(j++)] * 16 + dehexArray[str.charCodeAt(j++)]
+      if (!a && a !== 0) throw new Error('Input is not a hex string')
+      arr[i] = a
+    }
+  }
+
+  return arr
+}

package/hex.js

@@ -1,78 +1,22 @@
-import { assertTypedArray, assert } from './assert.js'
-import { fromTypedArray } from './array.js'
+import { assertTypedArray } from './assert.js'
+import { typedView } from './array.js'
+import * as js from './fallback/hex.js'
 
 const { Buffer } = globalThis // Buffer is optional, only used when native
 const haveNativeBuffer = Buffer && !Buffer.TYPED_ARRAY_SUPPORT
 const { toHex: webHex } = Uint8Array.prototype // Modern engines have this
 
-let hexArray
-let dehexArray
-
 export function toHex(arr) {
   assertTypedArray(arr)
   if (!(arr instanceof Uint8Array)) arr = new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength)
+  if (arr.length === 0) return ''
   if (webHex && arr.toHex === webHex) return arr.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'))
-  const length = arr.length // this helps Hermes
-
-  if (length > 30000) {
-    // Limit concatenation to avoid excessive GC
-    // Thresholds checked on Hermes
-    const concat = []
-    for (let i = 0; i < length; ) {
-      const step = i + 500
-      const end = step > length ? length : step
-      let chunk = ''
-      for (; i < end; i++) chunk += hexArray[arr[i]]
-      concat.push(chunk)
-    }
-
-    const res = concat.join('')
-    concat.length = 0
-    return res
-  }
-
-  let out = ''
-  for (let i = 0; i < length; i++) out += hexArray[arr[i]]
-  return out
+  if (!haveNativeBuffer) return js.toHex(arr)
+  if (arr.constructor === Buffer && Buffer.isBuffer(arr)) return arr.toString('hex')
+  return Buffer.from(arr.buffer, arr.byteOffset, arr.byteLength).toString('hex')
 }
 
 // Unlike Buffer.from(), throws on invalid input
-let fromHex
-if (Uint8Array.fromHex) {
-  fromHex = (str, format = 'uint8') => fromTypedArray(Uint8Array.fromHex(str), format)
-} else {
-  fromHex = (str, format = 'uint8') => {
-    if (typeof str !== 'string') throw new TypeError('Input is not a string')
-    assert(str.length % 2 === 0, 'Input is not a hex string')
-
-    // We don't use native Buffer impl, as rechecking input make it slower than pure js
-    // This path is used only on older engines though
-
-    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(str.length / 2)
-    let j = 0
-    const length = arr.length // this helps Hermes
-    for (let i = 0; i < length; i++) {
-      const a = dehexArray[str.charCodeAt(j++)] * 16 + dehexArray[str.charCodeAt(j++)]
-      if (!a && Number.isNaN(a)) throw new Error('Input is not a hex string')
-      arr[i] = a
-    }
-
-    return fromTypedArray(arr, format)
-  }
-}
-
-export { fromHex }
+export const fromHex = Uint8Array.fromHex
+  ? (str, format = 'uint8') => typedView(Uint8Array.fromHex(str), format)
+  : (str, format = 'uint8') => typedView(js.fromHex(str), format)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/bytes",
-  "version": "1.0.0-rc.2",
+  "version": "1.0.0-rc.3",
   "description": "Various operations on Uint8Array data",
   "scripts": {
     "lint": "eslint .",
@@ -39,14 +39,16 @@
   },
   "type": "module",
   "files": [
+    "/fallback/base64.js",
+    "/fallback/hex.js",
+    "/array.js",
     "/assert.js",
     "/base64.js",
-    "/array.js",
     "/hex.js"
   ],
   "exports": {
-    "./base64.js": "./base64.js",
     "./array.js": "./array.js",
+    "./base64.js": "./base64.js",
     "./hex.js": "./hex.js"
   },
   "dependencies": {},