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

package/base64.js

@@ -1,205 +1,177 @@
-import { assert, assertUint8 } from './assert.js'
-import { fromTypedArray } from './array.js'
+import { assertUint8, assertEmptyRest } from './assert.js'
+import { typedView } from './array.js'
+import { isHermes, skipWeb } from './fallback/_utils.js'
+import { decodeLatin1, encodeLatin1 } from './fallback/latin1.js'
+import * as js from './fallback/base64.js'
 
 // See https://datatracker.ietf.org/doc/html/rfc4648
 
-// base64:    A-Za-z0-9+/ and =
-// base64url: A-Za-z0-9_-
+// 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
 
-export function toBase64(x) {
+const { E_CHAR, E_PADDING, E_LENGTH, E_LAST } = js
+
+// faster only on Hermes (and a little in old Chrome), js path beats it on normal engines
+const shouldUseBtoa = btoa && isHermes
+const shouldUseAtob = atob && isHermes
+
+// 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))
+
+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 haveWeb = (x) => !skipWeb && web64 && x.toBase64 === web64
+
+export function toBase64(x, { padding = true } = {}) {
   assertUint8(x)
-  if (web64 && x.toBase64 === web64) return x.toBase64() // Modern
-  if (!haveNativeBuffer) return toBase64js(x, BASE64, true) // Fallback
-  if (x.constructor === Buffer && Buffer.isBuffer(x)) return x.toString('base64') // Older Node.js
-  return Buffer.from(x.buffer, x.byteOffset, x.byteLength).toString('base64') // Older Node.js
+  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
-export function toBase64url(x) {
+// 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: true }) // Modern
-  if (!haveNativeBuffer) return toBase64js(x, BASE64URL, false) // Fallback
-  if (x.constructor === Buffer && Buffer.isBuffer(x)) return x.toString('base64url') // Older Node.js
-  return Buffer.from(x.buffer, x.byteOffset, x.byteLength).toString('base64url') // Older Node.js
+  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)
 // Unlike Buffer.from() and Uint8Array.fromBase64(), does not allow spaces
 // NOTE: Always operates in strict mode for last chunk
 
-// Accepts both padded and non-padded variants, only strict base64
-export function fromBase64(str, format = 'uint8') {
-  if (typeof str !== 'string') throw new TypeError('Input is not a string')
+// By default accepts both padded and non-padded variants, only strict base64
+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)
+}
 
-  // These checks should be needed only for Buffer path, not Uint8Array.fromBase64 path, but JSC lacks proper checks
-  assert(str.length % 4 !== 1, 'Invalid base64 length') // JSC misses this in fromBase64
-  if (str.endsWith('=')) {
-    assert(str.length % 4 === 0, 'Invalid padded length') // JSC misses this too
-    assert(str[str.length - 3] !== '=', 'Excessive padding') // no more than two = at the end
-  }
+// By default accepts only non-padded strict base64url
+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)
+}
 
-  return fromTypedArray(fromBase64common(str, false), format)
+// By default accepts both padded and non-padded variants, base64 or base64url
+export function fromBase64any(str, { format = 'uint8', padding = 'both', ...rest } = {}) {
+  const isBase64url = !str.includes('+') && !str.includes('/') // likely to fail fast, as most input is non-url, also double scan is faster than regex
+  return fromBase64common(str, isBase64url, padding, format, rest)
 }
 
-// Accepts both only non-padded strict base64url
-export function fromBase64url(str, format = 'uint8') {
+function fromBase64common(str, isBase64url, padding, format, rest) {
   if (typeof str !== 'string') throw new TypeError('Input is not a string')
+  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) {
+    if (str.length % 4 !== 0) throw new SyntaxError(E_PADDING) // JSC misses this
+    if (str[str.length - 3] === '=') throw new SyntaxError(E_PADDING) // no more than two = at the end
+  } else if (padding === false || auto === false) {
+    if (str.length % 4 === 1) throw new SyntaxError(E_LENGTH) // JSC misses this in fromBase64
+    if (padding === false && str.endsWith('=')) {
+      throw new SyntaxError('Did not expect padding in base64 input') // inclusion is checked separately
+    }
+  } else {
+    throw new TypeError('Invalid padding option')
+  }
 
-  // These checks should be needed only for Buffer path, not Uint8Array.fromBase64 path, but JSC lacks proper checks
-  assert(str.length % 4 !== 1, 'Invalid base64 length') // JSC misses this in fromBase64
-  assert(!str.endsWith('='), 'Did not expect padding in base64url input') // inclusion is checked separately
+  return 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
 
-  return fromTypedArray(fromBase64common(str, true), format)
+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 fromBase64common
-if (Uint8Array.fromBase64) {
+let fromBase64impl
+if (!skipWeb && 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
-  fromBase64common = (str, isBase64url) => {
+  fromBase64impl = (str, isBase64url, padding) => {
     const alphabet = isBase64url ? 'base64url' : 'base64'
-    assert(!/\s/u.test(str), `Invalid character in ${alphabet} input`) // 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' })
-  }
-} else {
-  fromBase64common = (str, isBase64url) => {
-    if (isBase64url) {
-      assert(!/[^0-9a-z_-]/iu.test(str), 'Invalid character in base64url input')
-    } else {
-      assert(!/[^0-9a-z=+/]/iu.test(str), 'Invalid character in base64 input')
-    }
 
     let arr
-    if (!haveNativeBuffer && atob) {
-      // atob is faster than manual parsing on Hermes
-      const raw = atob(isBase64url ? str.replaceAll('-', '+').replaceAll('_', '/') : str)
-      const length = raw.length
-      arr = new Uint8Array(length)
-      for (let i = 0; i < length; i++) arr[i] = raw.charCodeAt(i)
+    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 {
-      // base64url is already checked to have no padding via a regex above
-      if (!isBase64url) {
-        const at = str.indexOf('=')
-        if (at >= 0) assert(!/[^=]/iu.test(str.slice(at)), 'Invalid padding')
+      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
       }
-
-      arr = haveNativeBuffer ? Buffer.from(str, 'base64') : fromBase64js(str)
-    }
-
-    if (arr.length % 3 !== 0) {
-      // 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
-      if (expected !== actual) throw new Error('Invalid last chunk')
     }
 
+    // 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
   }
-}
-
-const BASE64 = [...'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/']
-const BASE64URL = [...'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_']
-
-const BASE64_PAIRS = []
-const BASE64URL_PAIRS = []
-
-// We construct output by concatenating chars, this seems to be fine enough on modern JS engines
-function toBase64js(arr, alphabet, padding) {
-  assertUint8(arr)
-  const fullChunks = Math.floor(arr.length / 3)
-  const fullChunksBytes = fullChunks * 3
-  let o = ''
-  let i = 0
-
-  const pairs = alphabet === BASE64URL ? BASE64URL_PAIRS : BASE64_PAIRS
-  if (pairs.length === 0) {
-    for (let i = 0; i < 64; i++) {
-      for (let j = 0; j < 64; j++) pairs.push(`${alphabet[i]}${alphabet[j]}`)
-    }
+} else if (haveNativeBuffer) {
+  fromBase64impl = (str, isBase64url, padding) => {
+    const arr = Buffer.from(str, 'base64')
+    // Rechecking by re-encoding is cheaper than regexes on Node.js
+    const got = isBase64url ? maybeUnpad(str, padding === false) : maybePad(str, padding !== true)
+    const valid = isBase64url ? arr.base64urlSlice(0, arr.length) : arr.base64Slice(0, arr.length)
+    if (got !== valid) throw new SyntaxError(E_PADDING)
+    return arr // fully checked
   }
-
-  // Fast path for complete blocks
-  // This whole loop can be commented out, the algorithm won't change, it's just an optimization of the next loop
-  for (; i < fullChunksBytes; i += 3) {
-    const a = arr[i]
-    const b = arr[i + 1]
-    const c = arr[i + 2]
-    o += pairs[(a << 4) | (b >> 4)] + pairs[((b & 0x0f) << 8) | c]
-  }
-
-  // If we have something left, process it with a full algo
-  let carry = 0
-  let shift = 2 // First byte needs to be shifted by 2 to get 6 bits
-  const length = arr.length
-  for (; i < length; i++) {
-    const x = arr[i]
-    o += alphabet[carry | (x >> shift)] // shift >= 2, so this fits
-    if (shift === 6) {
-      shift = 0
-      o += alphabet[x & 0x3f]
+} else if (shouldUseAtob) {
+  // atob is faster than manual parsing on Hermes
+  fromBase64impl = (str, isBase64url, padding) => {
+    let arr
+    if (isBase64url) {
+      if (/[\t\n\f\r +/]/.test(str)) throw new SyntaxError(E_CHAR) // atob verifies other invalid input
+      str = str.replaceAll('-', '+').replaceAll('_', '/') // from url to normal
     }
 
-    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
-}
+    try {
+      arr = encodeLatin1(atob(str))
+    } catch {
+      throw new SyntaxError(E_CHAR) // convert atob errors
+    }
 
-// Assumes no chars after =, checked
-let fromBase64jsMap
+    if (!isBase64url && !noWhitespaceSeen(str, arr)) throw new SyntaxError(E_CHAR) // base64url checks input above
 
-function fromBase64js(str) {
-  const map = fromBase64jsMap || new Array(256)
-  if (!fromBase64jsMap) {
-    fromBase64jsMap = map
-    BASE64.forEach((c, i) => (map[c.charCodeAt(0)] = i))
-    map['-'.charCodeAt(0)] = map['+'.charCodeAt(0)] // for base64url
-    map['_'.charCodeAt(0)] = map['/'.charCodeAt(0)] // for base64url
-  }
-
-  let inputLength = str.length
-  while (str[inputLength - 1] === '=') inputLength--
-
-  const arr = new Uint8Array(Math.floor((inputLength * 3) / 4))
-  const tailLength = inputLength % 4
-  const mainLength = inputLength - tailLength // multiples of 4
-
-  let at = 0
-  let i = 0
-  let tmp
-
-  while (i < mainLength) {
-    tmp =
-      (map[str.charCodeAt(i)] << 18) |
-      (map[str.charCodeAt(i + 1)] << 12) |
-      (map[str.charCodeAt(i + 2)] << 6) |
-      map[str.charCodeAt(i + 3)]
-    arr[at++] = tmp >> 16
-    arr[at++] = (tmp >> 8) & 0xff
-    arr[at++] = tmp & 0xff
-    i += 4
-  }
+    if (arr.length % 3 !== 0) {
+      // Check last chunk to be strict if it was incomplete
+      const expected = toBase64(arr.subarray(-(arr.length % 3))) // str is normalized to non-url already
+      const end = str.length % 4 === 0 ? str.slice(-4) : str.slice(-(str.length % 4)).padEnd(4, '=')
+      if (expected !== end) throw new SyntaxError(E_LAST)
+    }
 
-  if (tailLength === 3) {
-    tmp =
-      (map[str.charCodeAt(i)] << 10) |
-      (map[str.charCodeAt(i + 1)] << 4) |
-      (map[str.charCodeAt(i + 2)] >> 2)
-    arr[at++] = (tmp >> 8) & 0xff
-    arr[at++] = tmp & 0xff
-  } else if (tailLength === 2) {
-    tmp = (map[str.charCodeAt(i)] << 2) | (map[str.charCodeAt(i + 1)] >> 4)
-    arr[at++] = tmp & 0xff
+    return arr
   }
-
-  return arr
+} else {
+  fromBase64impl = (str, isBase64url, padding) => js.fromBase64(str, isBase64url) // validated in js
 }

package/bech32.js

@@ -0,0 +1,254 @@
+import { assertUint8 } from './assert.js'
+import { nativeEncoder } from './fallback/_utils.js'
+import { decodeAscii, encodeAscii, encodeLatin1 } from './fallback/latin1.js'
+
+const alphabet = [...'qpzry9x8gf2tvdw0s3jn54khce6mua7l']
+const BECH32 = 1
+const BECH32M = 0x2b_c8_30_a3
+
+const E_SIZE = 'Input length is out of range'
+const E_PREFIX = 'Missing or invalid prefix'
+const E_MIXED = 'Mixed-case string'
+const E_PADDING = 'Padding is invalid'
+const E_CHECKSUM = 'Invalid checksum'
+const E_CHARACTER = 'Non-bech32 character'
+const E_STRING = 'Input is not a string'
+
+// nativeEncoder path uses encodeAscii which asserts ascii, otherwise we have 0-255 bytes from encodeLatin1
+const c2x = new Int8Array(nativeEncoder ? 128 : 256).fill(-1)
+const x2c = new Uint8Array(32)
+for (let i = 0; i < alphabet.length; i++) {
+  const c = alphabet[i].charCodeAt(0)
+  c2x[c] = i
+  x2c[i] = c
+}
+
+// checksum size is 30 bits, 0x3f_ff_ff_ff
+// The good thing about the checksum is that it's linear over every bit
+const poly0 = new Uint32Array(32) // just precache all possible ones, it's only 1 KiB
+const p = (x) => ((x & 0x1_ff_ff_ff) << 5) ^ poly0[x >> 25]
+for (let i = 0; i < 32; i++) {
+  poly0[i] =
+    (i & 0b0_0001 ? 0x3b_6a_57_b2 : 0) ^
+    (i & 0b0_0010 ? 0x26_50_8e_6d : 0) ^
+    (i & 0b0_0100 ? 0x1e_a1_19_fa : 0) ^
+    (i & 0b0_1000 ? 0x3d_42_33_dd : 0) ^
+    (i & 0b1_0000 ? 0x2a_14_62_b3 : 0)
+}
+
+// 7 KiB more for faster p6/p8
+const poly1 = new Uint32Array(32)
+const poly2 = new Uint32Array(32)
+const poly3 = new Uint32Array(32)
+const poly4 = new Uint32Array(32)
+const poly5 = new Uint32Array(32)
+const poly6 = new Uint32Array(32)
+const poly7 = new Uint32Array(32)
+for (let i = 0; i < 32; i++) {
+  // poly0[i] === p(p(p(p(p(p(i))))))
+  poly1[i] = p(poly0[i]) // aka p(p(p(p(p(p(i << 5))))))
+  poly2[i] = p(poly1[i]) // aka p(p(p(p(p(p(i << 10))))))
+  poly3[i] = p(poly2[i]) // aka p(p(p(p(p(p(i << 15))))))
+  poly4[i] = p(poly3[i]) // aka p(p(p(p(p(p(i << 20))))))
+  poly5[i] = p(poly4[i]) // aka p(p(p(p(p(p(i << 25))))))
+  poly6[i] = p(poly5[i])
+  poly7[i] = p(poly6[i])
+}
+
+function p6(x) {
+  // Same as: return p(p(p(p(p(p(x))))))
+  const x0 = x & 0x1f
+  const x1 = (x >> 5) & 0x1f
+  const x2 = (x >> 10) & 0x1f
+  const x3 = (x >> 15) & 0x1f
+  const x4 = (x >> 20) & 0x1f
+  const x5 = (x >> 25) & 0x1f
+  return poly0[x0] ^ poly1[x1] ^ poly2[x2] ^ poly3[x3] ^ poly4[x4] ^ poly5[x5]
+}
+
+function p8(x) {
+  // Same as: return p(p(p(p(p(p(p(p(x))))))))
+  const x0 = x & 0x1f
+  const x1 = (x >> 5) & 0x1f
+  const x2 = (x >> 10) & 0x1f
+  const x3 = (x >> 15) & 0x1f
+  const x4 = (x >> 20) & 0x1f
+  const x5 = (x >> 25) & 0x1f
+  return poly2[x0] ^ poly3[x1] ^ poly4[x2] ^ poly5[x3] ^ poly6[x4] ^ poly7[x5]
+}
+
+// p(p(p(p(p(p(chk) ^ x0) ^ x1) ^ x2) ^ x3) ^ x4) ^ x5 === p6(chk) ^ merge(x0, x1, x2, x3, x4, x5)
+const merge = (a, b, c, d, e, f) => f ^ (e << 5) ^ (d << 10) ^ (c << 15) ^ (b << 20) ^ (a << 25)
+
+const prefixCache = new Map() // Cache 10 of them
+
+function pPrefix(prefix) {
+  if (prefix === 'bc') return 0x2_31_80_43 // perf
+  const cached = prefixCache.get(prefix)
+  if (cached !== undefined) return cached
+
+  // bech32_hrp_expand(s): [ord(x) >> 5 for x in s] + [0] + [ord(x) & 31 for x in s]
+  // We can do this in a single scan due to linearity, but it's not very beneficial
+  let chk = 1 // it starts with one (see def bech32_polymod in BIP_0173)
+  const length = prefix.length
+  for (let i = 0; i < length; i++) {
+    const c = prefix.charCodeAt(i)
+    if (c < 33 || c > 126) throw new Error(E_PREFIX) // each character having a value in the range [33-126]
+    chk = p(chk) ^ (c >> 5)
+  }
+
+  chk = p(chk) // <= for + [0]
+  for (let i = 0; i < length; i++) {
+    const c = prefix.charCodeAt(i)
+    chk = p(chk) ^ (c & 0x1f)
+  }
+
+  if (prefixCache.size < 10) prefixCache.set(prefix, chk)
+  return chk
+}
+
+function toBech32enc(prefix, bytes, limit, encoding) {
+  if (typeof prefix !== 'string' || !prefix) throw new TypeError(E_PREFIX)
+  if (typeof limit !== 'number') throw new TypeError(E_SIZE)
+  assertUint8(bytes)
+  const bytesLength = bytes.length
+  const wordsLength = Math.ceil((bytesLength * 8) / 5)
+  if (!(prefix.length + 7 + wordsLength <= limit)) throw new TypeError(E_SIZE)
+  prefix = prefix.toLowerCase()
+  const out = new Uint8Array(wordsLength + 6)
+
+  let chk = pPrefix(prefix)
+  let i = 0, j = 0 // prettier-ignore
+
+  // This loop is just an optimization of the next one
+  for (const length4 = bytesLength - 4; i < length4; i += 5, j += 8) {
+    const b0 = bytes[i], b1 = bytes[i + 1], b2 = bytes[i + 2], b3 = bytes[i + 3], b4 = bytes[i + 4] // prettier-ignore
+    const x0 = b0 >> 3
+    const x1 = ((b0 << 2) & 0x1f) | (b1 >> 6)
+    const x2 = (b1 >> 1) & 0x1f
+    const x3 = ((b1 << 4) & 0x1f) | (b2 >> 4)
+    const x4 = ((b2 << 1) & 0x1f) | (b3 >> 7)
+    const x5 = (b3 >> 2) & 0x1f
+    const x6 = ((b3 << 3) & 0x1f) | (b4 >> 5)
+    const x7 = b4 & 0x1f
+    chk = merge(x2, x3, x4, x5, x6, x7) ^ poly0[x1] ^ poly1[x0] ^ p8(chk)
+    out[j] = x2c[x0]
+    out[j + 1] = x2c[x1]
+    out[j + 2] = x2c[x2]
+    out[j + 3] = x2c[x3]
+    out[j + 4] = x2c[x4]
+    out[j + 5] = x2c[x5]
+    out[j + 6] = x2c[x6]
+    out[j + 7] = x2c[x7]
+  }
+
+  let value = 0, bits = 0 // prettier-ignore
+  for (; i < bytesLength; i++) {
+    value = ((value & 0xf) << 8) | bytes[i]
+    bits += 3
+    const x = (value >> bits) & 0x1f
+    chk = p(chk) ^ x
+    out[j++] = x2c[x]
+    if (bits >= 5) {
+      bits -= 5
+      const x = (value >> bits) & 0x1f
+      chk = p(chk) ^ x
+      out[j++] = x2c[x]
+    }
+  }
+
+  if (bits > 0) {
+    const x = (value << (5 - bits)) & 0x1f
+    chk = p(chk) ^ x
+    out[j++] = x2c[x]
+  }
+
+  chk = encoding ^ p6(chk)
+  out[j++] = x2c[(chk >> 25) & 0x1f]
+  out[j++] = x2c[(chk >> 20) & 0x1f]
+  out[j++] = x2c[(chk >> 15) & 0x1f]
+  out[j++] = x2c[(chk >> 10) & 0x1f]
+  out[j++] = x2c[(chk >> 5) & 0x1f]
+  out[j++] = x2c[(chk >> 0) & 0x1f]
+
+  return prefix + '1' + decodeAscii(out) // suboptimal in barebones, but actually ok in Hermes for not to care atm
+}
+
+function assertDecodeArgs(str, limit) {
+  if (typeof str !== 'string') throw new TypeError(E_STRING)
+  if (typeof limit !== 'number' || str.length < 8 || !(str.length <= limit)) throw new Error(E_SIZE)
+}
+
+function fromBech32enc(str, limit, encoding) {
+  assertDecodeArgs(str, limit)
+  const lower = str.toLowerCase()
+  if (str !== lower) {
+    if (str !== str.toUpperCase()) throw new Error(E_MIXED)
+    str = lower
+  }
+
+  const split = str.lastIndexOf('1')
+  if (split <= 0) throw new Error(E_PREFIX)
+  const prefix = str.slice(0, split)
+  const charsLength = str.length - split - 1
+  const wordsLength = charsLength - 6
+  if (wordsLength < 0) throw new Error(E_SIZE)
+  const bytesLength = (wordsLength * 5) >> 3
+  const slice = str.slice(split + 1)
+  const c = nativeEncoder ? encodeAscii(slice, E_CHARACTER) : encodeLatin1(slice) // suboptimal, but only affects non-Hermes barebones
+  const bytes = new Uint8Array(bytesLength)
+
+  let chk = pPrefix(prefix)
+  let i = 0, j = 0 // prettier-ignore
+
+  // This loop is just an optimization of the next one
+  for (const length7 = wordsLength - 7; i < length7; i += 8, j += 5) {
+    const c0 = c[i], c1 = c[i + 1], c2 = c[i + 2], c3 = c[i + 3], c4 = c[i + 4], c5 = c[i + 5], c6 = c[i + 6], c7 = c[i + 7] // prettier-ignore
+    const x0 = c2x[c0], x1 = c2x[c1], x2 = c2x[c2], x3 = c2x[c3], x4 = c2x[c4], x5 = c2x[c5], x6 = c2x[c6], x7 = c2x[c7] // prettier-ignore
+    if (x0 < 0 || x1 < 0 || x2 < 0 || x3 < 0 || x4 < 0 || x5 < 0 || x6 < 0 || x7 < 0) throw new SyntaxError(E_CHARACTER) // prettier-ignore
+    chk = merge(x2, x3, x4, x5, x6, x7) ^ poly0[x1] ^ poly1[x0] ^ p8(chk)
+    bytes[j] = (x0 << 3) | (x1 >> 2)
+    bytes[j + 1] = (((x1 << 6) | (x2 << 1)) & 0xff) | (x3 >> 4)
+    bytes[j + 2] = ((x3 << 4) & 0xff) | (x4 >> 1)
+    bytes[j + 3] = ((((x4 << 5) | x5) << 2) & 0xff) | (x6 >> 3)
+    bytes[j + 4] = ((x6 << 5) & 0xff) | x7
+  }
+
+  let value = 0, bits = 0 // prettier-ignore
+  for (; i < wordsLength; i++) {
+    const x = c2x[c[i]]
+    if (x < 0) throw new SyntaxError(E_CHARACTER)
+    chk = p(chk) ^ x
+    value = (value << 5) | x
+    bits += 5
+    if (bits >= 8) {
+      bits -= 8
+      bytes[j++] = (value >> bits) & 0xff
+    }
+  }
+
+  if (bits >= 5 || (value << (8 - bits)) & 0xff) throw new Error(E_PADDING)
+
+  // Checksum
+  {
+    const c0 = c[i], c1 = c[i + 1], c2 = c[i + 2], c3 = c[i + 3], c4 = c[i + 4], c5 = c[i + 5] // prettier-ignore
+    const x0 = c2x[c0], x1 = c2x[c1], x2 = c2x[c2], x3 = c2x[c3], x4 = c2x[c4], x5 = c2x[c5] // prettier-ignore
+    if (x0 < 0 || x1 < 0 || x2 < 0 || x3 < 0 || x4 < 0 || x5 < 0) throw new SyntaxError(E_CHARACTER)
+    if ((merge(x0, x1, x2, x3, x4, x5) ^ p6(chk)) !== encoding) throw new Error(E_CHECKSUM)
+  }
+
+  return { prefix, bytes }
+}
+
+// This is designed to be a very quick check, skipping all other validation
+export function getPrefix(str, limit = 90) {
+  assertDecodeArgs(str, limit)
+  const split = str.lastIndexOf('1')
+  if (split <= 0) throw new Error(E_PREFIX)
+  return str.slice(0, split).toLowerCase()
+}
+
+export const toBech32 = (prefix, bytes, limit = 90) => toBech32enc(prefix, bytes, limit, BECH32)
+export const fromBech32 = (str, limit = 90) => fromBech32enc(str, limit, BECH32)
+export const toBech32m = (prefix, bytes, limit = 90) => toBech32enc(prefix, bytes, limit, BECH32M)
+export const fromBech32m = (str, limit = 90) => fromBech32enc(str, limit, BECH32M)

package/encoding-lite.js

@@ -0,0 +1,7 @@
+export {
+  TextDecoder,
+  TextEncoder,
+  normalizeEncoding,
+  getBOMEncoding,
+  legacyHookDecode,
+} from './fallback/encoding.js'

package/encoding.js

@@ -0,0 +1,12 @@
+import { createMultibyteDecoder } from '@exodus/bytes/multi-byte.js' // eslint-disable-line @exodus/import/no-unresolved
+import { setMultibyteDecoder } from './fallback/encoding.js'
+
+setMultibyteDecoder(createMultibyteDecoder)
+
+export {
+  TextDecoder,
+  TextEncoder,
+  normalizeEncoding,
+  getBOMEncoding,
+  legacyHookDecode,
+} from './fallback/encoding.js'