@exodus/bytes 1.0.0-rc.0 → 1.0.0-rc.10

package/fallback/_utils.js

@@ -0,0 +1,118 @@
+const { Buffer, TextEncoder, TextDecoder } = globalThis
+const haveNativeBuffer = Buffer && !Buffer.TYPED_ARRAY_SUPPORT
+let isNative = (x) => x && (haveNativeBuffer || `${x}`.includes('[native code]')) // we consider Node.js TextDecoder/TextEncoder native
+if (!haveNativeBuffer && isNative(() => {})) isNative = () => false // e.g. XS, we don't want false positives
+
+export const nativeEncoder = isNative(TextEncoder) ? new TextEncoder() : null
+export const nativeDecoder = isNative(TextDecoder)
+  ? new TextDecoder('utf-8', { ignoreBOM: true })
+  : null
+export const nativeBuffer = haveNativeBuffer ? Buffer : null
+export const isHermes = Boolean(globalThis.HermesInternal)
+export const isDeno = Boolean(globalThis.Deno)
+export const isLE = new Uint8Array(Uint16Array.of(258).buffer)[0] === 2
+
+// 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
+let nativeDecoderLatin1impl = null
+if (isNative(TextDecoder)) {
+  // Not all barebone engines with TextDecoder support something except utf-8, detect
+  try {
+    nativeDecoderLatin1impl = new TextDecoder('latin1', { ignoreBOM: true })
+  } catch {}
+}
+
+export const nativeDecoderLatin1 = nativeDecoderLatin1impl
+export const canDecoders = Boolean(nativeDecoderLatin1impl)
+
+// Block Firefox < 146 specifically from using native hex/base64, as it's very slow there
+// Refs: https://bugzilla.mozilla.org/show_bug.cgi?id=1994067 (and linked issues), fixed in 146
+// Before that, all versions of Firefox >= 133 are slow
+// TODO: this could be removed when < 146 usage diminishes (note ESR)
+// We do not worry about false-negatives here but worry about false-positives!
+function shouldSkipBuiltins() {
+  const g = globalThis
+  // First, attempt to exclude as many things as we can using trivial checks, just in case, and to not hit ua
+  if (haveNativeBuffer || isHermes || !g.window || g.chrome || !g.navigator) return false
+  try {
+    // This was fixed specifically in Firefox 146. Other engines except Hermes (already returned) get this right
+    new WeakSet().add(Symbol()) // eslint-disable-line symbol-description
+    return false
+  } catch {
+    // In catch and not after in case if something too smart optimizes out code in try. False-negative is acceptable in that case
+    if (!('onmozfullscreenerror' in g)) return false // Firefox has it (might remove in the future, but we don't care)
+    return /firefox/i.test(g.navigator.userAgent || '') // as simple as we can
+  }
+
+  return false // eslint-disable-line no-unreachable
+}
+
+export const skipWeb = shouldSkipBuiltins()
+
+function decodePartAddition(a, start, end, m) {
+  let o = ''
+  let i = start
+  for (const last3 = end - 3; i < last3; i += 4) {
+    const x0 = a[i]
+    const x1 = a[i + 1]
+    const x2 = a[i + 2]
+    const x3 = a[i + 3]
+    o += m[x0]
+    o += m[x1]
+    o += m[x2]
+    o += m[x3]
+  }
+
+  while (i < end) o += m[a[i++]]
+  return o
+}
+
+// Decoding with templates is faster on Hermes
+function decodePartTemplates(a, start, end, m) {
+  let o = ''
+  let i = start
+  for (const last15 = end - 15; i < last15; i += 16) {
+    const x0 = a[i]
+    const x1 = a[i + 1]
+    const x2 = a[i + 2]
+    const x3 = a[i + 3]
+    const x4 = a[i + 4]
+    const x5 = a[i + 5]
+    const x6 = a[i + 6]
+    const x7 = a[i + 7]
+    const x8 = a[i + 8]
+    const x9 = a[i + 9]
+    const x10 = a[i + 10]
+    const x11 = a[i + 11]
+    const x12 = a[i + 12]
+    const x13 = a[i + 13]
+    const x14 = a[i + 14]
+    const x15 = a[i + 15]
+    o += `${m[x0]}${m[x1]}${m[x2]}${m[x3]}${m[x4]}${m[x5]}${m[x6]}${m[x7]}${m[x8]}${m[x9]}${m[x10]}${m[x11]}${m[x12]}${m[x13]}${m[x14]}${m[x15]}`
+  }
+
+  while (i < end) o += m[a[i++]]
+  return o
+}
+
+const decodePart = isHermes ? decodePartTemplates : decodePartAddition
+export function decode2string(arr, start, end, m) {
+  if (start - end > 30_000) {
+    // Limit concatenation to avoid excessive GC
+    // Thresholds checked on Hermes for toHex
+    const concat = []
+    for (let i = start; i < end; ) {
+      const step = i + 500
+      const iNext = step > end ? end : step
+      concat.push(decodePart(arr, i, iNext, m))
+      i = iNext
+    }
+
+    const res = concat.join('')
+    concat.length = 0
+    return res
+  }
+
+  return decodePart(arr, start, end, m)
+}

package/fallback/base32.js

@@ -0,0 +1,233 @@
+import { assertUint8 } from '../assert.js'
+import { nativeEncoder, nativeDecoder, isHermes } from './_utils.js'
+import { encodeAscii, decodeAscii } from './latin1.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'
+
+const useTemplates = isHermes // 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)
+  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]
+      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 = 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]
+      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]
+      o += pairs[x1]
+      o += pairs[x2]
+      o += pairs[x3]
+    }
+  }
+
+  // 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 ? 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
+  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 = encodeAscii(str, E_CHAR)
+    for (; i < mainLength; i += 8) {
+      // each 5 bits, grouped 5 * 4 = 20
+      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 + 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 {
+    for (; i < mainLength; i += 8) {
+      // each 5 bits, grouped 5 * 4 = 20
+      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 + 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
+    }
+  }
+
+  // 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

@@ -0,0 +1,192 @@
+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
+
+const BASE64 = [...'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/']
+const BASE64URL = [...'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_']
+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'
+
+// 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 = (arr.length / 3) | 0
+  const fullChunksBytes = fullChunks * 3
+  let o = ''
+  let i = 0
+
+  const alphabet = isURL ? BASE64URL : BASE64
+  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 Uint16Array(fullChunks * 2)
+    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 + 1] = codepairs[((b & 0x0f) << 8) | c]
+    }
+
+    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)]
+      o += 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
+}
+
+// TODO: can this be optimized? This only affects non-Hermes barebone engines though
+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 fromBase64(str, isURL) {
+  let inputLength = str.length
+  while (str[inputLength - 1] === '=') inputLength--
+  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
+
+  if (nativeEncoder) {
+    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 + 1] = (a >> 8) & 0xff
+      arr[at + 2] = a & 0xff
+      at += 3
+    }
+  } else {
+    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 + 1] = (a >> 8) & 0xff
+      arr[at + 2] = a & 0xff
+      at += 3
+    }
+  }
+
+  // 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
+  }
+
+  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
+}