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

package/base32.js

@@ -12,14 +12,21 @@ export const toBase32 = (arr, { padding = false } = {}) => js.toBase32(arr, fals
 export const toBase32hex = (arr, { padding = false } = {}) => js.toBase32(arr, true, padding)
 
 // By default, valid padding is accepted but not required
-export const fromBase32 = (str, { format = 'uint8', padding = 'both', ...rest } = {}) =>
-  fromBase32common(str, false, padding, format, rest)
-export const fromBase32hex = (str, { format = 'uint8', padding = 'both', ...rest } = {}) =>
-  fromBase32common(str, true, padding, format, rest)
+export function fromBase32(str, options) {
+  if (!options) return fromBase32common(str, false, 'both', 'uint8', null)
+  const { format = 'uint8', padding = 'both', ...rest } = options
+  return fromBase32common(str, false, padding, format, rest)
+}
+
+export function fromBase32hex(str, options) {
+  if (!options) return fromBase32common(str, true, 'both', 'uint8', null)
+  const { format = 'uint8', padding = 'both', ...rest } = options
+  return fromBase32common(str, true, padding, format, rest)
+}
 
 function fromBase32common(str, isBase32Hex, padding, format, rest) {
   if (typeof str !== 'string') throw new TypeError('Input is not a string')
-  assertEmptyRest(rest)
+  if (rest !== null) assertEmptyRest(rest)
 
   if (padding === true) {
     if (str.length % 8 !== 0) throw new SyntaxError(E_PADDING)

package/base58.js

@@ -1,6 +1,7 @@
 import { typedView } from './array.js'
 import { assertUint8 } from './assert.js'
 import { nativeDecoder, nativeEncoder } from './fallback/_utils.js'
+import { encodeAscii, decodeAscii } from './fallback/latin1.js'
 
 const alphabet = [...'123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz']
 const codes = new Uint8Array(alphabet.map((x) => x.charCodeAt(0)))
@@ -103,7 +104,7 @@ export function toBase58(arr) {
     while (carry) {
       const c = carry
       carry = Math.floor(c / 58)
-      res[i++] = c - carry * 58
+      res.push(c - carry * 58)
     }
   }
 
@@ -111,7 +112,7 @@ export function toBase58(arr) {
     const oa = new Uint8Array(res.length)
     let j = 0
     for (let i = res.length - 1; i >= 0; i--) oa[j++] = codes[res[i]]
-    return ZERO.repeat(zeros) + nativeDecoder.decode(oa)
+    return ZERO.repeat(zeros) + decodeAscii(oa)
   }
 
   let out = ''
@@ -142,8 +143,7 @@ export function fromBase58(str, format = 'uint8') {
 
     // nativeEncoder gives a benefit here
     if (nativeEncoder) {
-      const codes = nativeEncoder.encode(str)
-      if (codes.length !== str.length) throw new SyntaxError(E_CHAR) // non-ascii
+      const codes = encodeAscii(str, E_CHAR)
       for (let i = zeros; i < length; i++) {
         const c = fromMap[codes[i]]
         if (c < 0) throw new SyntaxError(E_CHAR)

package/base58check.js

@@ -6,25 +6,63 @@ import { hashSync } from '@exodus/crypto/hash'
 // Note: while API is async, we use hashSync for now until we improve webcrypto perf for hash256
 // Inputs to base58 are typically very small, and that makes a difference
 
-const hash256 = (x) => hashSync('sha256', hashSync('sha256', x, 'uint8'), 'uint8')
-
 const E_CHECKSUM = 'Invalid checksum'
 
-export async function toBase58check(arr) {
-  assertUint8(arr)
-  const checksum = hash256(arr)
+// checksum length is 4, i.e. only the first 4 bytes of the hash are used
+
+function encodeWithChecksum(arr, checksum) {
+  // arr type in already validated in input
   const res = new Uint8Array(arr.length + 4)
   res.set(arr, 0)
   res.set(checksum.subarray(0, 4), arr.length)
   return toBase58(res)
 }
 
-export async function fromBase58check(str, format = 'uint8') {
+function decodeWithChecksum(str) {
   const arr = fromBase58(str) // checks input
-  const len4 = arr.length - 4
-  const payload = arr.subarray(0, len4)
-  const c = arr.subarray(len4)
-  const r = hash256(payload)
+  const payloadSize = arr.length - 4
+  if (payloadSize < 0) throw new Error(E_CHECKSUM)
+  return [arr.subarray(0, payloadSize), arr.subarray(payloadSize)]
+}
+
+function assertChecksum(c, r) {
   if ((c[0] ^ r[0]) | (c[1] ^ r[1]) | (c[2] ^ r[2]) | (c[3] ^ r[3])) throw new Error(E_CHECKSUM)
-  return typedView(payload, format)
 }
+
+export const makeBase58check = (hashAlgo, hashAlgoSync) => {
+  const apis = {
+    async encode(arr) {
+      assertUint8(arr)
+      return encodeWithChecksum(arr, await hashAlgo(arr))
+    },
+    async decode(str, format = 'uint8') {
+      const [payload, checksum] = decodeWithChecksum(str)
+      assertChecksum(checksum, await hashAlgo(payload))
+      return typedView(payload, format)
+    },
+  }
+  if (!hashAlgoSync) return apis
+  return {
+    ...apis,
+    encodeSync(arr) {
+      assertUint8(arr)
+      return encodeWithChecksum(arr, hashAlgoSync(arr))
+    },
+    decodeSync(str, format = 'uint8') {
+      const [payload, checksum] = decodeWithChecksum(str)
+      assertChecksum(checksum, hashAlgoSync(payload))
+      return typedView(payload, format)
+    },
+  }
+}
+
+const hash256sync = (x) => hashSync('sha256', hashSync('sha256', x, 'uint8'), 'uint8')
+const hash256 = hash256sync // See note at the top
+const {
+  encode: toBase58check,
+  decode: fromBase58check,
+  encodeSync: toBase58checkSync,
+  decodeSync: fromBase58checkSync,
+} = makeBase58check(hash256, hash256sync)
+
+export { toBase58check, fromBase58check, toBase58checkSync, fromBase58checkSync }

package/base64.js

@@ -1,5 +1,6 @@
 import { assertUint8, assertEmptyRest } from './assert.js'
 import { typedView } from './array.js'
+import { decodeLatin1, encodeLatin1 } from './fallback/latin1.js'
 import * as js from './fallback/base64.js'
 
 // See https://datatracker.ietf.org/doc/html/rfc4648
@@ -7,42 +8,49 @@ import * as js from './fallback/base64.js'
 // base64:    A-Za-z0-9+/ and = if padding not disabled
 // base64url: A-Za-z0-9_- and = if padding enabled
 
-const { Buffer, atob } = globalThis // Buffer is optional, only used when native
+const { Buffer, atob, btoa } = globalThis // Buffer is optional, only used when native
 const haveNativeBuffer = Buffer && !Buffer.TYPED_ARRAY_SUPPORT
 const { toBase64: web64 } = Uint8Array.prototype // Modern engines have this
 
 const { E_CHAR, E_PADDING, E_LENGTH, E_LAST } = js
 
-const shouldUseAtob = atob && Boolean(globalThis.HermesInternal) // faster only on Hermes (and a little in old Chrome), js path beats it on normal engines
+// faster only on Hermes (and a little in old Chrome), js path beats it on normal engines
+const shouldUseBtoa = btoa && Boolean(globalThis.HermesInternal)
+const shouldUseAtob = atob && Boolean(globalThis.HermesInternal)
 
 // For native Buffer codepaths only
 const isBuffer = (x) => x.constructor === Buffer && Buffer.isBuffer(x)
 const toBuffer = (x) => (isBuffer(x) ? x : Buffer.from(x.buffer, x.byteOffset, x.byteLength))
 
-export function toBase64(x, { padding = true } = {}) {
-  assertUint8(x)
-  if (web64 && x.toBase64 === web64) {
-    return padding ? x.toBase64() : x.toBase64({ omitPadding: !padding }) // Modern, optionless is slightly faster
-  }
-
-  if (!haveNativeBuffer) return js.toBase64(x, false, padding) // Fallback
-  const res = toBuffer(x).toString('base64') // Older Node.js
+function maybeUnpad(res, padding) {
   if (padding) return res
   const at = res.indexOf('=', res.length - 3)
   return at === -1 ? res : res.slice(0, at)
 }
 
+function maybePad(res, padding) {
+  return padding && res.length % 4 !== 0 ? res + '='.repeat(4 - (res.length % 4)) : res
+}
+
+const toUrl = (x) => x.replaceAll('+', '-').replaceAll('/', '_')
+const fromUrl = (x) => x.replaceAll('-', '+').replaceAll('_', '/')
+const haveWeb = (x) => web64 && x.toBase64 === web64
+
+export function toBase64(x, { padding = true } = {}) {
+  assertUint8(x)
+  if (haveWeb(x)) return padding ? x.toBase64() : x.toBase64({ omitPadding: !padding }) // Modern, optionless is slightly faster
+  if (haveNativeBuffer) return maybeUnpad(toBuffer(x).base64Slice(0, x.byteLength), padding) // Older Node.js
+  if (shouldUseBtoa) return maybeUnpad(btoa(decodeLatin1(x)), padding)
+  return js.toBase64(x, false, padding) // Fallback
+}
+
 // NOTE: base64url omits padding by default
 export function toBase64url(x, { padding = false } = {}) {
   assertUint8(x)
-  if (web64 && x.toBase64 === web64) {
-    return x.toBase64({ alphabet: 'base64url', omitPadding: !padding }) // Modern
-  }
-
-  if (!haveNativeBuffer) return js.toBase64(x, true, padding) // Fallback
-  if (x.constructor === Buffer && Buffer.isBuffer(x)) return x.toString('base64url') // Older Node.js
-  const res = toBuffer(x).toString('base64url') // Older Node.js
-  return padding && res.length % 4 !== 0 ? res + '='.repeat(4 - (res.length % 4)) : res
+  if (haveWeb(x)) return x.toBase64({ alphabet: 'base64url', omitPadding: !padding }) // Modern
+  if (haveNativeBuffer) return maybePad(toBuffer(x).base64urlSlice(0, x.byteLength), padding) // Older Node.js
+  if (shouldUseBtoa) return maybeUnpad(toUrl(btoa(decodeLatin1(x))), padding)
+  return js.toBase64(x, true, padding) // Fallback
 }
 
 // Unlike Buffer.from(), throws on invalid input (non-base64 symbols and incomplete chunks)
@@ -50,14 +58,17 @@ export function toBase64url(x, { padding = false } = {}) {
 // NOTE: Always operates in strict mode for last chunk
 
 // By default accepts both padded and non-padded variants, only strict base64
-export function fromBase64(str, options = {}) {
+export function fromBase64(str, options) {
   if (typeof options === 'string') options = { format: options } // Compat due to usage, TODO: remove
+  if (!options) return fromBase64common(str, false, 'both', 'uint8', null)
   const { format = 'uint8', padding = 'both', ...rest } = options
   return fromBase64common(str, false, padding, format, rest)
 }
 
 // By default accepts only non-padded strict base64url
-export function fromBase64url(str, { format = 'uint8', padding = false, ...rest } = {}) {
+export function fromBase64url(str, options) {
+  if (!options) return fromBase64common(str, true, false, 'uint8', null)
+  const { format = 'uint8', padding = false, ...rest } = options
   return fromBase64common(str, true, padding, format, rest)
 }
 
@@ -69,7 +80,7 @@ export function fromBase64any(str, { format = 'uint8', padding = 'both', ...rest
 
 function fromBase64common(str, isBase64url, padding, format, rest) {
   if (typeof str !== 'string') throw new TypeError('Input is not a string')
-  assertEmptyRest(rest)
+  if (rest !== null) assertEmptyRest(rest)
   const auto = padding === 'both' ? str.endsWith('=') : undefined
   // Older JSC supporting Uint8Array.fromBase64 lacks proper checks
   if (padding === true || auto === true) {
@@ -84,49 +95,70 @@ function fromBase64common(str, isBase64url, padding, format, rest) {
     throw new TypeError('Invalid padding option')
   }
 
-  return typedView(fromBase64impl(str, isBase64url), format)
+  return typedView(fromBase64impl(str, isBase64url, padding), format)
 }
 
 // ASCII whitespace is U+0009 TAB, U+000A LF, U+000C FF, U+000D CR, or U+0020 SPACE
 const ASCII_WHITESPACE = /[\t\n\f\r ]/ // non-u for JSC perf
 
+function noWhitespaceSeen(str, arr) {
+  const at = str.indexOf('=', str.length - 3)
+  const paddingLength = at >= 0 ? str.length - at : 0
+  const chars = str.length - paddingLength
+  const e = chars % 4 // extra chars past blocks of 4
+  const b = arr.length - ((chars - e) / 4) * 3 // remaining bytes not covered by full blocks of chars
+  return (e === 0 && b === 0) || (e === 2 && b === 1) || (e === 3 && b === 2)
+}
+
 let fromBase64impl
 if (Uint8Array.fromBase64) {
   // NOTICE: this is actually slower than our JS impl in older JavaScriptCore and (slightly) in SpiderMonkey, but faster on V8 and new JavaScriptCore
-  fromBase64impl = (str, isBase64url) => {
+  fromBase64impl = (str, isBase64url, padding) => {
     const alphabet = isBase64url ? 'base64url' : 'base64'
-    if (ASCII_WHITESPACE.test(str)) throw new SyntaxError(E_CHAR) // all other chars are checked natively
-    const padded = str.length % 4 > 0 ? `${str}${'='.repeat(4 - (str.length % 4))}` : str
-    return Uint8Array.fromBase64(padded, { alphabet, lastChunkHandling: 'strict' })
+
+    let arr
+    if (padding === true) {
+      // Padding is required from user, and we already checked that string length is divisible by 4
+      // Padding might still be wrong due to whitespace, but in that case native impl throws expected error
+      arr = Uint8Array.fromBase64(str, { alphabet, lastChunkHandling: 'strict' })
+    } else {
+      try {
+        const padded = str.length % 4 > 0 ? `${str}${'='.repeat(4 - (str.length % 4))}` : str
+        arr = Uint8Array.fromBase64(padded, { alphabet, lastChunkHandling: 'strict' })
+      } catch (err) {
+        // Normalize error: whitespace in input could have caused added padding to be invalid
+        // But reporting that as a padding error would be confusing
+        throw ASCII_WHITESPACE.test(str) ? new SyntaxError(E_CHAR) : err
+      }
+    }
+
+    // We don't allow whitespace in input, but that can be rechecked based on output length
+    // All other chars are checked natively
+    if (!noWhitespaceSeen(str, arr)) throw new SyntaxError(E_CHAR)
+    return arr
   }
 } else {
-  fromBase64impl = (str, isBase64url) => {
+  fromBase64impl = (str, isBase64url, padding) => {
     let arr
     if (haveNativeBuffer) {
-      const invalidRegex = isBase64url ? /[^0-9a-z=_-]/iu : /[^0-9a-z=+/]/iu
-      if (invalidRegex.test(str)) throw new SyntaxError(E_CHAR)
-      const at = str.indexOf('=')
-      if (at >= 0 && /[^=]/iu.test(str.slice(at))) throw new SyntaxError(E_PADDING)
       arr = Buffer.from(str, 'base64')
+      // Rechecking is cheaper than regexes on Node.js
+      const r = isBase64url ? maybeUnpad(str, padding === false) : maybePad(str, padding !== true)
+      if (r !== arr.toString(isBase64url ? 'base64url' : 'base64')) throw new SyntaxError(E_PADDING)
     } else if (shouldUseAtob) {
       // atob is faster than manual parsing on Hermes
       if (isBase64url) {
         if (/[\t\n\f\r +/]/.test(str)) throw new SyntaxError(E_CHAR) // atob verifies other invalid input
-        str = str.replaceAll('-', '+').replaceAll('_', '/')
-      } else {
-        if (ASCII_WHITESPACE.test(str)) throw new SyntaxError(E_CHAR) // all other chars are checked natively
+        str = fromUrl(str)
       }
 
-      let raw
       try {
-        raw = atob(str)
+        arr = encodeLatin1(atob(str))
       } catch {
         throw new SyntaxError(E_CHAR) // convert atob errors
       }
 
-      const length = raw.length
-      arr = new Uint8Array(length)
-      for (let i = 0; i < length; i++) arr[i] = raw.charCodeAt(i)
+      if (!isBase64url && !noWhitespaceSeen(str, arr)) throw new SyntaxError(E_CHAR) // base64url checks input above
     } else {
       return js.fromBase64(str, isBase64url) // early return to skip last chunk verification, it's already validated in js
     }
@@ -135,7 +167,7 @@ if (Uint8Array.fromBase64) {
       // Check last chunk to be strict if it was incomplete
       const expected = toBase64(arr.subarray(-(arr.length % 3)))
       const end = str.length % 4 === 0 ? str.slice(-4) : str.slice(-(str.length % 4)).padEnd(4, '=')
-      const actual = isBase64url ? end.replaceAll('-', '+').replaceAll('_', '/') : end
+      const actual = isBase64url ? fromUrl(end) : end
       if (expected !== actual) throw new SyntaxError(E_LAST)
     }
 

package/fallback/_utils.js

@@ -3,4 +3,13 @@ const haveNativeBuffer = Buffer && !Buffer.TYPED_ARRAY_SUPPORT
 const isNative = (x) => x && (haveNativeBuffer || `${x}`.includes('[native code]')) // we consider Node.js TextDecoder/TextEncoder native
 const nativeEncoder = isNative(TextEncoder) ? new TextEncoder() : null
 const nativeDecoder = isNative(TextDecoder) ? new TextDecoder('utf8', { ignoreBOM: true }) : null
-export { nativeEncoder, nativeDecoder }
+const nativeBuffer = haveNativeBuffer ? Buffer : null
+
+// Actually windows-1252, compatible with ascii and latin1 decoding
+// Beware that on non-latin1, i.e. on windows-1252, this is broken in ~all Node.js versions released
+// in 2025 due to a regression, so we call it Latin1 as it's usable only for that
+const nativeDecoderLatin1 = isNative(TextDecoder)
+  ? new TextDecoder('latin1', { ignoreBOM: true })
+  : null
+
+export { nativeEncoder, nativeDecoder, nativeDecoderLatin1, nativeBuffer }

package/fallback/base32.js

@@ -1,5 +1,6 @@
 import { assertUint8 } from '../assert.js'
 import { nativeEncoder, nativeDecoder } from './_utils.js'
+import { encodeAscii, decodeAscii } from './latin1.js'
 
 // See https://datatracker.ietf.org/doc/html/rfc4648
 
@@ -13,6 +14,8 @@ export const E_PADDING = 'Invalid base32 padding'
 export const E_LENGTH = 'Invalid base32 length'
 export const E_LAST = 'Invalid last chunk'
 
+const useTemplates = Boolean(globalThis.HermesInternal) // Faster on Hermes and JSC, but we use it only on Hermes
+
 // We construct output by concatenating chars, this seems to be fine enough on modern JS engines
 export function toBase32(arr, isBase32Hex, padding) {
   assertUint8(arr)
@@ -54,13 +57,32 @@ export function toBase32(arr, isBase32Hex, padding) {
       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
+      const x0 = (a << 2) | (b >> 6) // 8 + 8 - 5 - 5 = 6 left
+      const x1 = ((b & 0x3f) << 4) | (c >> 4) // 6 + 8 - 5 - 5 = 4 left
+      const x2 = ((c & 0xf) << 6) | (d >> 2) // 4 + 8 - 5 - 5 = 2 left
+      const x3 = ((d & 0x3) << 8) | e // 2 + 8 - 5 - 5 = 0 left
+      oa[j] = codepairs[x0]
+      oa[j + 1] = codepairs[x1]
+      oa[j + 2] = codepairs[x2]
+      oa[j + 3] = codepairs[x3]
+      j += 4
     }
 
-    o = nativeDecoder.decode(oa)
+    o = decodeAscii(oa)
+  } else if (useTemplates) {
+    // Templates are faster only on Hermes and JSC. Browsers have TextDecoder anyway
+    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]
+      const x0 = (a << 2) | (b >> 6) // 8 + 8 - 5 - 5 = 6 left
+      const x1 = ((b & 0x3f) << 4) | (c >> 4) // 6 + 8 - 5 - 5 = 4 left
+      const x2 = ((c & 0xf) << 6) | (d >> 2) // 4 + 8 - 5 - 5 = 2 left
+      const x3 = ((d & 0x3) << 8) | e // 2 + 8 - 5 - 5 = 0 left
+      o += `${pairs[x0]}${pairs[x1]}${pairs[x2]}${pairs[x3]}`
+    }
   } else {
     for (; i < fullChunksBytes; i += 5) {
       const a = arr[i]
@@ -68,10 +90,14 @@ export function toBase32(arr, isBase32Hex, padding) {
       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
+      const x0 = (a << 2) | (b >> 6) // 8 + 8 - 5 - 5 = 6 left
+      const x1 = ((b & 0x3f) << 4) | (c >> 4) // 6 + 8 - 5 - 5 = 4 left
+      const x2 = ((c & 0xf) << 6) | (d >> 2) // 4 + 8 - 5 - 5 = 2 left
+      const x3 = ((d & 0x3) << 8) | e // 2 + 8 - 5 - 5 = 0 left
+      o += pairs[x0]
+      o += pairs[x1]
+      o += pairs[x2]
+      o += pairs[x3]
     }
   }
 
@@ -97,7 +123,7 @@ export function toBase32(arr, isBase32Hex, padding) {
 }
 
 // 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
+const mapSize = nativeEncoder ? 128 : 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
@@ -127,38 +153,47 @@ export function fromBase32(str, isBase32Hex) {
   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) {
+    const codes = encodeAscii(str, E_CHAR)
+    for (; i < mainLength; i += 8) {
       // 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++]]
+      const x0 = codes[i]
+      const x1 = codes[i + 1]
+      const x2 = codes[i + 2]
+      const x3 = codes[i + 3]
+      const x4 = codes[i + 4]
+      const x5 = codes[i + 5]
+      const x6 = codes[i + 6]
+      const x7 = codes[i + 7]
+      const a = (m[x0] << 15) | (m[x1] << 10) | (m[x2] << 5) | m[x3]
+      const b = (m[x4] << 15) | (m[x5] << 10) | (m[x6] << 5) | m[x7]
       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
+      arr[at] = a >> 12
+      arr[at + 1] = (a >> 4) & 0xff
+      arr[at + 2] = ((a << 4) & 0xff) | (b >> 16)
+      arr[at + 3] = (b >> 8) & 0xff
+      arr[at + 4] = b & 0xff
+      at += 5
     }
   } else {
-    while (i < mainLength) {
+    for (; i < mainLength; i += 8) {
       // 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++)]
+      const x0 = str.charCodeAt(i)
+      const x1 = str.charCodeAt(i + 1)
+      const x2 = str.charCodeAt(i + 2)
+      const x3 = str.charCodeAt(i + 3)
+      const x4 = str.charCodeAt(i + 4)
+      const x5 = str.charCodeAt(i + 5)
+      const x6 = str.charCodeAt(i + 6)
+      const x7 = str.charCodeAt(i + 7)
+      const a = (m[x0] << 15) | (m[x1] << 10) | (m[x2] << 5) | m[x3]
+      const b = (m[x4] << 15) | (m[x5] << 10) | (m[x6] << 5) | m[x7]
       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
+      arr[at] = a >> 12
+      arr[at + 1] = (a >> 4) & 0xff
+      arr[at + 2] = ((a << 4) & 0xff) | (b >> 16)
+      arr[at + 3] = (b >> 8) & 0xff
+      arr[at + 4] = b & 0xff
+      at += 5
     }
   }
 

package/fallback/base64.js

@@ -1,5 +1,6 @@
 import { assertUint8 } from '../assert.js'
 import { nativeEncoder, nativeDecoder } from './_utils.js'
+import { encodeAscii, decodeAscii } from './latin1.js'
 
 // See https://datatracker.ietf.org/doc/html/rfc4648
 
@@ -13,13 +14,10 @@ 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
-
 // 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 fullChunks = (arr.length / 3) | 0
   const fullChunksBytes = fullChunks * 3
   let o = ''
   let i = 0
@@ -51,21 +49,49 @@ export function toBase64(arr, isURL, padding) {
   // 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 * 2)
-    for (let j = 0; i < fullChunksBytes; i += 3) {
+    let j = 0
+    for (const last = arr.length - 11; i < last; i += 12, j += 8) {
+      const x0 = arr[i]
+      const x1 = arr[i + 1]
+      const x2 = arr[i + 2]
+      const x3 = arr[i + 3]
+      const x4 = arr[i + 4]
+      const x5 = arr[i + 5]
+      const x6 = arr[i + 6]
+      const x7 = arr[i + 7]
+      const x8 = arr[i + 8]
+      const x9 = arr[i + 9]
+      const x10 = arr[i + 10]
+      const x11 = arr[i + 11]
+      oa[j] = codepairs[(x0 << 4) | (x1 >> 4)]
+      oa[j + 1] = codepairs[((x1 & 0x0f) << 8) | x2]
+      oa[j + 2] = codepairs[(x3 << 4) | (x4 >> 4)]
+      oa[j + 3] = codepairs[((x4 & 0x0f) << 8) | x5]
+      oa[j + 4] = codepairs[(x6 << 4) | (x7 >> 4)]
+      oa[j + 5] = codepairs[((x7 & 0x0f) << 8) | x8]
+      oa[j + 6] = codepairs[(x9 << 4) | (x10 >> 4)]
+      oa[j + 7] = codepairs[((x10 & 0x0f) << 8) | x11]
+    }
+
+    // i < last here is equivalent to i < fullChunksBytes
+    for (const last = arr.length - 2; i < last; i += 3, j += 2) {
       const a = arr[i]
       const b = arr[i + 1]
       const c = arr[i + 2]
-      oa[j++] = codepairs[(a << 4) | (b >> 4)]
-      oa[j++] = codepairs[((b & 0x0f) << 8) | c]
+      oa[j] = codepairs[(a << 4) | (b >> 4)]
+      oa[j + 1] = codepairs[((b & 0x0f) << 8) | c]
     }
 
-    o = nativeDecoder.decode(oa)
+    o = decodeAscii(oa)
   } else {
+    // This can be optimized by ~25% with templates on Hermes, but this codepath is not called on Hermes, it uses btoa
+    // Check git history for templates version
     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]
+      o += pairs[(a << 4) | (b >> 4)]
+      o += pairs[((b & 0x0f) << 8) | c]
     }
   }
 
@@ -92,9 +118,8 @@ export function toBase64(arr, isURL, padding) {
 }
 
 // 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
+const mapSize = nativeEncoder ? 128 : 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--
@@ -121,26 +146,31 @@ export function fromBase64(str, isURL) {
   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) {
-      const a = (m[codes[i++]] << 18) | (m[codes[i++]] << 12) | (m[codes[i++]] << 6) | m[codes[i++]]
+    const codes = encodeAscii(str, E_CHAR)
+    for (; i < mainLength; i += 4) {
+      const c0 = codes[i]
+      const c1 = codes[i + 1]
+      const c2 = codes[i + 2]
+      const c3 = codes[i + 3]
+      const a = (m[c0] << 18) | (m[c1] << 12) | (m[c2] << 6) | m[c3]
       if (a < 0) throw new SyntaxError(E_CHAR)
-      arr[at++] = a >> 16
-      arr[at++] = (a >> 8) & 0xff
-      arr[at++] = a & 0xff
+      arr[at] = a >> 16
+      arr[at + 1] = (a >> 8) & 0xff
+      arr[at + 2] = a & 0xff
+      at += 3
     }
   } 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++)]
+    for (; i < mainLength; i += 4) {
+      const c0 = str.charCodeAt(i)
+      const c1 = str.charCodeAt(i + 1)
+      const c2 = str.charCodeAt(i + 2)
+      const c3 = str.charCodeAt(i + 3)
+      const a = (m[c0] << 18) | (m[c1] << 12) | (m[c2] << 6) | m[c3]
       if (a < 0) throw new SyntaxError(E_CHAR)
-      arr[at++] = a >> 16
-      arr[at++] = (a >> 8) & 0xff
-      arr[at++] = a & 0xff
+      arr[at] = a >> 16
+      arr[at + 1] = (a >> 8) & 0xff
+      arr[at + 2] = a & 0xff
+      at += 3
     }
   }