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

package/fallback/base32.js

@@ -0,0 +1,198 @@
+import { assertUint8 } from '../assert.js'
+import { nativeEncoder, nativeDecoder } from './_utils.js'
+
+// See https://datatracker.ietf.org/doc/html/rfc4648
+
+const BASE32 = [...'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'] // RFC 4648, #6
+const BASE32HEX = [...'0123456789ABCDEFGHIJKLMNOPQRSTUV'] // RFC 4648, #7
+const BASE32_HELPERS = {}
+const BASE32HEX_HELPERS = {}
+
+export const E_CHAR = 'Invalid character in base32 input'
+export const E_PADDING = 'Invalid base32 padding'
+export const E_LENGTH = 'Invalid base32 length'
+export const E_LAST = 'Invalid last chunk'
+
+// We construct output by concatenating chars, this seems to be fine enough on modern JS engines
+export function toBase32(arr, isBase32Hex, padding) {
+  assertUint8(arr)
+  const fullChunks = Math.floor(arr.length / 5)
+  const fullChunksBytes = fullChunks * 5
+  let o = ''
+  let i = 0
+
+  const alphabet = isBase32Hex ? BASE32HEX : BASE32
+  const helpers = isBase32Hex ? BASE32HEX_HELPERS : BASE32_HELPERS
+  if (!helpers.pairs) {
+    helpers.pairs = []
+    if (nativeDecoder) {
+      // Lazy to save memory in case if this is not needed
+      helpers.codepairs = new Uint16Array(32 * 32)
+      const u16 = helpers.codepairs
+      const u8 = new Uint8Array(u16.buffer, u16.byteOffset, u16.byteLength) // write as 1-byte to ignore BE/LE difference
+      for (let i = 0; i < 32; i++) {
+        const ic = alphabet[i].charCodeAt(0)
+        for (let j = 0; j < 32; j++) u8[(i << 6) | (j << 1)] = u8[(j << 6) | ((i << 1) + 1)] = ic
+      }
+    } else {
+      const p = helpers.pairs
+      for (let i = 0; i < 32; i++) {
+        for (let j = 0; j < 32; j++) p.push(`${alphabet[i]}${alphabet[j]}`)
+      }
+    }
+  }
+
+  const { pairs, codepairs } = helpers
+
+  // 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 Uint16Array(fullChunks * 4)
+    for (let j = 0; i < fullChunksBytes; i += 5) {
+      const a = arr[i]
+      const b = arr[i + 1]
+      const c = arr[i + 2]
+      const d = arr[i + 3]
+      const e = arr[i + 4]
+      oa[j++] = codepairs[(a << 2) | (b >> 6)] // 8 + 8 - 5 - 5 = 6 left
+      oa[j++] = codepairs[((b & 0x3f) << 4) | (c >> 4)] // 6 + 8 - 5 - 5 = 4 left
+      oa[j++] = codepairs[((c & 0xf) << 6) | (d >> 2)] // 4 + 8 - 5 - 5 = 2 left
+      oa[j++] = codepairs[((d & 0x3) << 8) | e] // 2 + 8 - 5 - 5 = 0 left
+    }
+
+    o = nativeDecoder.decode(oa)
+  } else {
+    for (; i < fullChunksBytes; i += 5) {
+      const a = arr[i]
+      const b = arr[i + 1]
+      const c = arr[i + 2]
+      const d = arr[i + 3]
+      const e = arr[i + 4]
+      o += pairs[(a << 2) | (b >> 6)] // 8 + 8 - 5 - 5 = 6 left
+      o += pairs[((b & 0x3f) << 4) | (c >> 4)] // 6 + 8 - 5 - 5 = 4 left
+      o += pairs[((c & 0xf) << 6) | (d >> 2)] // 4 + 8 - 5 - 5 = 2 left
+      o += pairs[((d & 0x3) << 8) | e] // 2 + 8 - 5 - 5 = 0 left
+    }
+  }
+
+  // If we have something left, process it with a full algo
+  let carry = 0
+  let shift = 3 // First byte needs to be shifted by 3 to get 5 bits
+  for (; i < arr.length; i++) {
+    const x = arr[i]
+    o += alphabet[carry | (x >> shift)] // shift >= 3, so this fits
+    if (shift >= 5) {
+      shift -= 5
+      o += alphabet[(x >> shift) & 0x1f]
+    }
+
+    carry = (x << (5 - shift)) & 0x1f
+    shift += 3 // Each byte prints 5 bits and leaves 3 bits
+  }
+
+  if (shift !== 3) o += alphabet[carry] // shift 3 means we have no carry left
+  if (padding) o += ['', '======', '====', '===', '='][arr.length - fullChunksBytes]
+
+  return o
+}
+
+// TODO: can this be optimized? This only affects non-Hermes barebone engines though
+const mapSize = nativeEncoder ? 256 : 65_536 // we have to store 64 KiB map or recheck everything if we can't decode to byte array
+
+export function fromBase32(str, isBase32Hex) {
+  let inputLength = str.length
+  while (str[inputLength - 1] === '=') inputLength--
+  const paddingLength = str.length - inputLength
+  const tailLength = inputLength % 8
+  const mainLength = inputLength - tailLength // multiples of 8
+  if (![0, 2, 4, 5, 7].includes(tailLength)) throw new SyntaxError(E_LENGTH) // fast verification
+  if (paddingLength > 7 || (paddingLength !== 0 && str.length % 8 !== 0)) {
+    throw new SyntaxError(E_PADDING)
+  }
+
+  const alphabet = isBase32Hex ? BASE32HEX : BASE32
+  const helpers = isBase32Hex ? BASE32HEX_HELPERS : BASE32_HELPERS
+
+  if (!helpers.fromMap) {
+    helpers.fromMap = new Int8Array(mapSize).fill(-1) // no regex input validation here, so we map all other bytes to -1 and recheck sign
+    alphabet.forEach((c, i) => {
+      helpers.fromMap[c.charCodeAt(0)] = helpers.fromMap[c.toLowerCase().charCodeAt(0)] = i
+    })
+  }
+
+  const m = helpers.fromMap
+
+  const arr = new Uint8Array(Math.floor((inputLength * 5) / 8))
+  let at = 0
+  let i = 0
+
+  if (nativeEncoder) {
+    const codes = nativeEncoder.encode(str)
+    if (codes.length !== str.length) throw new SyntaxError(E_CHAR) // non-ascii
+    while (i < mainLength) {
+      // each 5 bits, grouped 5 * 4 = 20
+      const a = (m[codes[i++]] << 15) | (m[codes[i++]] << 10) | (m[codes[i++]] << 5) | m[codes[i++]]
+      const b = (m[codes[i++]] << 15) | (m[codes[i++]] << 10) | (m[codes[i++]] << 5) | m[codes[i++]]
+      if (a < 0 || b < 0) throw new SyntaxError(E_CHAR)
+      arr[at++] = a >> 12
+      arr[at++] = (a >> 4) & 0xff
+      arr[at++] = ((a << 4) & 0xff) | (b >> 16)
+      arr[at++] = (b >> 8) & 0xff
+      arr[at++] = b & 0xff
+    }
+  } else {
+    while (i < mainLength) {
+      // each 5 bits, grouped 5 * 4 = 20
+      const a =
+        (m[str.charCodeAt(i++)] << 15) |
+        (m[str.charCodeAt(i++)] << 10) |
+        (m[str.charCodeAt(i++)] << 5) |
+        m[str.charCodeAt(i++)]
+      const b =
+        (m[str.charCodeAt(i++)] << 15) |
+        (m[str.charCodeAt(i++)] << 10) |
+        (m[str.charCodeAt(i++)] << 5) |
+        m[str.charCodeAt(i++)]
+      if (a < 0 || b < 0) throw new SyntaxError(E_CHAR)
+      arr[at++] = a >> 12
+      arr[at++] = (a >> 4) & 0xff
+      arr[at++] = ((a << 4) & 0xff) | (b >> 16)
+      arr[at++] = (b >> 8) & 0xff
+      arr[at++] = b & 0xff
+    }
+  }
+
+  // Last block, valid tailLength: 0 2 4 5 7, checked already
+  // We check last chunk to be strict
+  if (tailLength < 2) return arr
+  const ab = (m[str.charCodeAt(i++)] << 5) | m[str.charCodeAt(i++)]
+  if (ab < 0) throw new SyntaxError(E_CHAR)
+  arr[at++] = ab >> 2
+  if (tailLength < 4) {
+    if (ab & 0x3) throw new SyntaxError(E_LAST)
+    return arr
+  }
+
+  const cd = (m[str.charCodeAt(i++)] << 5) | m[str.charCodeAt(i++)]
+  if (cd < 0) throw new SyntaxError(E_CHAR)
+  arr[at++] = ((ab << 6) & 0xff) | (cd >> 4)
+  if (tailLength < 5) {
+    if (cd & 0xf) throw new SyntaxError(E_LAST)
+    return arr
+  }
+
+  const e = m[str.charCodeAt(i++)]
+  if (e < 0) throw new SyntaxError(E_CHAR)
+  arr[at++] = ((cd << 4) & 0xff) | (e >> 1) // 4 + 4
+  if (tailLength < 7) {
+    if (e & 0x1) throw new SyntaxError(E_LAST)
+    return arr
+  }
+
+  const fg = (m[str.charCodeAt(i++)] << 5) | m[str.charCodeAt(i++)]
+  if (fg < 0) throw new SyntaxError(E_CHAR)
+  arr[at++] = ((e << 7) & 0xff) | (fg >> 3) // 1 + 5 + 2
+  // Can't be 8, so no h
+  if (fg & 0x7) throw new SyntaxError(E_LAST)
+  return arr
+}

package/fallback/base64.js

@@ -1,15 +1,17 @@
 import { assertUint8 } from '../assert.js'
+import { nativeEncoder, nativeDecoder } from './_utils.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
+const BASE64_HELPERS = {}
+const BASE64URL_HELPERS = {}
+
+export const E_CHAR = 'Invalid character in base64 input'
+export const E_PADDING = 'Invalid base64 padding'
+export const E_LENGTH = 'Invalid base64 length'
+export const E_LAST = 'Invalid last chunk'
 
 // 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
@@ -23,27 +25,38 @@ export function toBase64(arr, isURL, padding) {
   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)
+  const helpers = isURL ? BASE64URL_HELPERS : BASE64_HELPERS
+  if (!helpers.pairs) {
+    helpers.pairs = []
+    if (nativeDecoder) {
+      // Lazy to save memory in case if this is not needed
+      helpers.codepairs = new Uint16Array(64 * 64)
+      const u16 = helpers.codepairs
+      const u8 = new Uint8Array(u16.buffer, u16.byteOffset, u16.byteLength) // write as 1-byte to ignore BE/LE difference
+      for (let i = 0; i < 64; i++) {
+        const ic = alphabet[i].charCodeAt(0)
+        for (let j = 0; j < 64; j++) u8[(i << 7) | (j << 1)] = u8[(j << 7) | ((i << 1) + 1)] = ic
+      }
+    } else {
+      const p = helpers.pairs
+      for (let i = 0; i < 64; i++) {
+        for (let j = 0; j < 64; j++) p.push(`${alphabet[i]}${alphabet[j]}`)
+      }
     }
   }
 
+  const { pairs, codepairs } = helpers
+
   // 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)
+    const oa = new Uint16Array(fullChunks * 2)
     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]
+      oa[j++] = codepairs[(a << 4) | (b >> 4)]
+      oa[j++] = codepairs[((b & 0x0f) << 8) | c]
     }
 
     o = nativeDecoder.decode(oa)
@@ -78,50 +91,72 @@ export function toBase64(arr, isURL, padding) {
   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
-  }
+// TODO: can this be optimized? This only affects non-Hermes barebone engines though
+const mapSize = nativeEncoder ? 256 : 65_536 // we have to store 64 KiB map or recheck everything if we can't decode to byte array
 
+// Last chunk is rechecked at API
+export function fromBase64(str, isURL) {
   let inputLength = str.length
   while (str[inputLength - 1] === '=') inputLength--
-
-  const arr = new Uint8Array(Math.floor((inputLength * 3) / 4))
+  const paddingLength = str.length - inputLength
   const tailLength = inputLength % 4
   const mainLength = inputLength - tailLength // multiples of 4
+  if (tailLength === 1) throw new SyntaxError(E_LENGTH)
+  if (paddingLength > 3 || (paddingLength !== 0 && str.length % 4 !== 0)) {
+    throw new SyntaxError(E_PADDING)
+  }
+
+  const alphabet = isURL ? BASE64URL : BASE64
+  const helpers = isURL ? BASE64URL_HELPERS : BASE64_HELPERS
 
+  if (!helpers.fromMap) {
+    helpers.fromMap = new Int8Array(mapSize).fill(-1) // no regex input validation here, so we map all other bytes to -1 and recheck sign
+    alphabet.forEach((c, i) => (helpers.fromMap[c.charCodeAt(0)] = i))
+  }
+
+  const m = helpers.fromMap
+
+  const arr = new Uint8Array(Math.floor((inputLength * 3) / 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 (nativeEncoder) {
+    const codes = nativeEncoder.encode(str)
+    if (codes.length !== str.length) throw new SyntaxError(E_CHAR) // non-ascii
+    while (i < mainLength) {
+      const a = (m[codes[i++]] << 18) | (m[codes[i++]] << 12) | (m[codes[i++]] << 6) | m[codes[i++]]
+      if (a < 0) throw new SyntaxError(E_CHAR)
+      arr[at++] = a >> 16
+      arr[at++] = (a >> 8) & 0xff
+      arr[at++] = a & 0xff
+    }
+  } else {
+    while (i < mainLength) {
+      const a =
+        (m[str.charCodeAt(i++)] << 18) |
+        (m[str.charCodeAt(i++)] << 12) |
+        (m[str.charCodeAt(i++)] << 6) |
+        m[str.charCodeAt(i++)]
+      if (a < 0) throw new SyntaxError(E_CHAR)
+      arr[at++] = a >> 16
+      arr[at++] = (a >> 8) & 0xff
+      arr[at++] = a & 0xff
+    }
   }
 
-  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
+  // Can be 0, 2 or 3, verified by padding checks already
+  if (tailLength < 2) return arr // 0
+  const ab = (m[str.charCodeAt(i++)] << 6) | m[str.charCodeAt(i++)]
+  if (ab < 0) throw new SyntaxError(E_CHAR)
+  arr[at++] = ab >> 4
+  if (tailLength < 3) {
+    if (ab & 0xf) throw new SyntaxError(E_LAST)
+    return arr // 2
   }
 
-  return arr
+  const c = m[str.charCodeAt(i++)]
+  if (c < 0) throw new SyntaxError(E_CHAR)
+  arr[at++] = ((ab << 4) & 0xff) | (c >> 2)
+  if (c & 0x3) throw new SyntaxError(E_LAST)
+  return arr // 3
 }

package/fallback/hex.js

@@ -1,12 +1,11 @@
-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
+import { assertUint8 } from '../assert.js'
+import { nativeEncoder } from './_utils.js'
 
 let hexArray
 let dehexArray
 
+export const E_HEX = 'Input is not a hex string'
+
 function toHexPart(arr, start, end) {
   let o = ''
   let i = start
@@ -52,15 +51,15 @@ export function toHex(arr) {
   return toHexPart(arr, 0, length)
 }
 
+// TODO: can this be optimized? This only affects non-Hermes barebone engines though
+const mapSize = nativeEncoder ? 256 : 65_536 // we have to store 64 KiB map or recheck everything if we can't decode to byte array
+
 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 (str.length % 2 !== 0) throw new SyntaxError(E_HEX)
 
   if (!dehexArray) {
-    dehexArray = new Array(103) // f is 102
+    dehexArray = new Int8Array(mapSize).fill(-1) // no regex input validation here, so we map all other bytes to -1 and recheck sign
     for (let i = 0; i < 16; i++) {
       const s = i.toString(16)
       dehexArray[s.charCodeAt(0)] = dehexArray[s.toUpperCase().charCodeAt(0)] = i
@@ -73,16 +72,31 @@ export function fromHex(str) {
   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
+    if (codes.length !== str.length) throw new SyntaxError(E_HEX) // non-ascii
+    const last3 = length - 3 // Unroll nativeEncoder path as this is what modern Hermes takes and a small perf improvement is nice there
+    let i = 0
+    while (i < last3) {
+      const a = (dehexArray[codes[j++]] << 4) | dehexArray[codes[j++]]
+      const b = (dehexArray[codes[j++]] << 4) | dehexArray[codes[j++]]
+      const c = (dehexArray[codes[j++]] << 4) | dehexArray[codes[j++]]
+      const d = (dehexArray[codes[j++]] << 4) | dehexArray[codes[j++]]
+      if (a < 0 || b < 0 || c < 0 || d < 0) throw new SyntaxError(E_HEX)
+      arr[i++] = a
+      arr[i++] = b
+      arr[i++] = c
+      arr[i++] = d
+    }
+
+    while (i < length) {
+      const res = (dehexArray[codes[j++]] << 4) | dehexArray[codes[j++]]
+      if (res < 0) throw new SyntaxError(E_HEX)
+      arr[i++] = res
     }
   } 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
+      const res = (dehexArray[str.charCodeAt(j++)] << 4) | dehexArray[str.charCodeAt(j++)]
+      if (res < 0) throw new SyntaxError(E_HEX)
+      arr[i] = res
     }
   }