@exodus/bytes 1.0.0-rc.4 → 1.0.0-rc.6

package/assert.js

@@ -1,7 +1,3 @@
-export function assert(x, msg) {
-  if (!x) throw new Error(msg || 'Assertion failed')
-}
-
 export function assertEmptyRest(rest) {
   if (Object.keys(rest).length > 0) throw new TypeError('Unexpected extra options')
 }

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

@@ -0,0 +1,212 @@
+import { typedView } from './array.js'
+import { assertUint8 } from './assert.js'
+import { nativeDecoder, nativeEncoder } from './fallback/_utils.js'
+import { encodeAscii } from './fallback/latin1.js'
+
+const alphabet = [...'123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz']
+const codes = new Uint8Array(alphabet.map((x) => x.charCodeAt(0)))
+const ZERO = alphabet[0]
+const zeroC = codes[0]
+
+const _0n = BigInt(0)
+const _1n = BigInt(1)
+const _8n = BigInt(8)
+const _32n = BigInt(32)
+const _58n = BigInt(58)
+const _0xffffffffn = BigInt(0xff_ff_ff_ff)
+
+let table // 15 * 82, diagonal, <1kb
+let fromMap
+
+const E_CHAR = 'Invalid character in base58 input'
+
+const shouldUseBigIntFrom = Boolean(globalThis.HermesInternal) // faster only on Hermes, numbers path beats it on normal engines
+
+export function toBase58(arr) {
+  assertUint8(arr)
+  const length = arr.length
+  if (length === 0) return ''
+
+  let zeros = 0
+  while (zeros < length && arr[zeros] === 0) zeros++
+
+  if (length > 60) {
+    // Slow path. Can be optimized ~10%, but the main factor is /58n division anyway, so doesn't matter much
+    let x = _0n
+    for (let i = 0; i < arr.length; i++) x = (x << _8n) | BigInt(arr[i])
+
+    let out = ''
+    while (x) {
+      const d = x / _58n
+      out = alphabet[Number(x - _58n * d)] + out
+      x = d
+    }
+
+    return ZERO.repeat(zeros) + out
+  }
+
+  // We run fast mode operations only on short (<=60 bytes) inputs, via precomputation table
+  if (!table) {
+    table = []
+    let x = _1n
+    for (let i = 0; i < 15; i++) {
+      // Convert x to base 58 digits
+      const in58 = []
+      let y = x
+      while (y) {
+        const d = y / _58n
+        in58.push(Number(y - _58n * d))
+        y = d
+      }
+
+      table.push(new Uint8Array(in58))
+      x <<= _32n
+    }
+  }
+
+  const res = []
+  {
+    let j = 0
+    // We group each 4 bytes into 32-bit chunks
+    // Not using u32arr to not deal with remainder + BE/LE differences
+    for (let i = length - 1; i >= 0; i -= 4) {
+      let c
+      if (i > 2) {
+        c = (arr[i] | (arr[i - 1] << 8) | (arr[i - 2] << 16) | (arr[i - 3] << 24)) >>> 0
+      } else if (i > 1) {
+        c = arr[i] | (arr[i - 1] << 8) | (arr[i - 2] << 16)
+      } else {
+        c = i === 1 ? arr[i] | (arr[i - 1] << 8) : arr[i]
+      }
+
+      const row = table[j++]
+      if (c === 0) continue
+      const olen = res.length
+      const nlen = row.length
+      let k = 0
+      for (; k < olen; k++) res[k] += c * row[k]
+      while (k < nlen) res.push(c * row[k++])
+    }
+  }
+
+  // We can now do a single scan over regular numbers under MAX_SAFE_INTEGER
+  // Note: can't use int32 operations on them, as they are outside of 2**32 range
+  // This is faster though
+  {
+    let carry = 0
+    let i = 0
+    while (i < res.length) {
+      const c = res[i] + carry
+      carry = Math.floor(c / 58)
+      res[i++] = c - carry * 58
+    }
+
+    while (carry) {
+      const c = carry
+      carry = Math.floor(c / 58)
+      res[i++] = c - carry * 58
+    }
+  }
+
+  if (nativeDecoder) {
+    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)
+  }
+
+  let out = ''
+  for (let i = res.length - 1; i >= 0; i--) out += alphabet[res[i]]
+  return ZERO.repeat(zeros) + out
+}
+
+// TODO: test on 'z'.repeat(from 1 to smth)
+export function fromBase58(str, format = 'uint8') {
+  if (typeof str !== 'string') throw new TypeError('Input is not a string')
+  const length = str.length
+  if (length === 0) return typedView(new Uint8Array(), format)
+
+  let zeros = 0
+  while (zeros < length && str.charCodeAt(zeros) === zeroC) zeros++
+
+  if (!fromMap) {
+    fromMap = new Int8Array(256).fill(-1)
+    for (let i = 0; i < 58; i++) fromMap[alphabet[i].charCodeAt(0)] = i
+  }
+
+  const size = zeros + (((length - zeros) * 3 + 1) >> 2) // 3/4 rounded up, larger than ~0.73 coef to fit everything
+  const res = new Uint8Array(size)
+  let at = size // where is the first significant byte written
+
+  if (shouldUseBigIntFrom) {
+    let x = _0n
+
+    // nativeEncoder gives a benefit here
+    if (nativeEncoder) {
+      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)
+        x = x * _58n + BigInt(c)
+      }
+    } else {
+      for (let i = zeros; i < length; i++) {
+        const charCode = str.charCodeAt(i)
+        const c = fromMap[charCode]
+        if (charCode > 255 || c < 0) throw new SyntaxError(E_CHAR)
+        x = x * _58n + BigInt(c)
+      }
+    }
+
+    while (x) {
+      let y = Number(x & _0xffffffffn)
+      x >>= 32n
+      res[--at] = y & 0xff
+      y >>>= 8
+      if (!x && !y) break
+      res[--at] = y & 0xff
+      y >>>= 8
+      if (!x && !y) break
+      res[--at] = y & 0xff
+      y >>>= 8
+      if (!x && !y) break
+      res[--at] = y & 0xff
+    }
+  } else {
+    for (let i = zeros; i < length; i++) {
+      const charCode = str.charCodeAt(i)
+      let c = fromMap[charCode]
+      if (charCode > 255 || c < 0) throw new SyntaxError(E_CHAR)
+
+      let k = size - 1
+      for (;;) {
+        if (c === 0 && k < at) break
+        c += 58 * res[k]
+        res[k] = c & 0xff
+        c >>>= 8
+        k--
+        // unroll a bit
+        if (c === 0 && k < at) break
+        c += 58 * res[k]
+        res[k] = c & 0xff
+        c >>>= 8
+        k--
+        if (c === 0 && k < at) break
+        c += 58 * res[k]
+        res[k] = c & 0xff
+        c >>>= 8
+        k--
+        if (c === 0 && k < at) break
+        c += 58 * res[k]
+        res[k] = c & 0xff
+        c >>>= 8
+        k--
+      }
+
+      at = k + 1
+      if (c !== 0 || at < zeros) throw new Error('Unexpected') // unreachable
+    }
+  }
+
+  return typedView(res.slice(at - zeros), format) // slice is faster for small sizes than subarray
+}

package/base58check.js

@@ -0,0 +1,68 @@
+import { typedView } from './array.js'
+import { assertUint8 } from './assert.js'
+import { toBase58, fromBase58 } from './base58.js'
+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 E_CHECKSUM = 'Invalid checksum'
+
+// 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)
+}
+
+function decodeWithChecksum(str) {
+  const arr = fromBase58(str) // checks input
+  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)
+}
+
+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).toString('base64'), 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).toString('base64url'), 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/base32.js

@@ -1,5 +1,6 @@
 import { assertUint8 } from '../assert.js'
 import { nativeEncoder, nativeDecoder } from './_utils.js'
+import { encodeAscii } 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)
+  } 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
     }
   }