@exodus/bytes 1.0.0-rc.8 → 1.0.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 Exodus Movement
+Copyright (c) 2024-2025 Exodus Movement
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,27 +1,309 @@
 # `@exodus/bytes`
 
-`Uint8Array` conversion to and from `base64`, `base32`, `base58`, `hex`, and `utf8`
+`Uint8Array` conversion to and from `base64`, `base32`, `base58`, `hex`, `utf8`, `utf16`, `bech32` and `wif`
 
-[Fast](./Performance.md)
+And a [`TextEncoder` / `TextDecoder` polyfill](#textencoder--textdecoder-polyfill)
 
-Performs proper input validation
+## Strict
+
+Performs proper input validation, ensures no garbage-in-garbage-out
+
+Tested on Node.js, Deno, Bun, browsers (including Servo), Hermes, QuickJS and barebone engines in CI [(how?)](https://github.com/ExodusMovement/test#exodustest)
+
+## Fast
+
+* `10-20x` faster than `Buffer` polyfill
+* `2-10x` faster than `iconv-lite`
+
+The above was for the js fallback
+
+It's up to `100x` when native impl is available \
+e.g. in `utf8fromString` on Hermes / React Native or `fromHex` in Chrome
+
+Also:
+* `3-8x` faster than `bs58`
+* `10-30x` faster than `@scure/base` (or `>100x` on Node.js <25)
+* Faster in `utf8toString` / `utf8fromString` than `Buffer` or `TextDecoder` / `TextEncoder` on Node.js
+
+See [Performance](./Performance.md) for more info
+
+## TextEncoder / TextDecoder polyfill
+
+```js
+import { TextDecoder, TextEncoder } from '@exodus/bytes/encoding.js'
+```
+
+Less than half the bundle size of [text-encoding](https://npmjs.com/text-encoding), [whatwg-encoding](https://npmjs.com/whatwg-encoding) or [iconv-lite](https://npmjs.com/iconv-lite) (gzipped or not), and [is much faster](#fast).
+See also [lite version](#lite-version).
+
+Spec compliant, passing WPT and covered with extra tests.
+
+Moreover, tests for this library uncovered [bugs in all major implementations](https://docs.google.com/spreadsheets/d/1pdEefRG6r9fZy61WHGz0TKSt8cO4ISWqlpBN5KntIvQ/edit).
+
+[Faster than Node.js native implementation on Node.js](https://github.com/nodejs/node/issues/61041#issuecomment-3649242024).
+
+### Caveat: `TextDecoder` / `TextEncoder` APIs are lossy by default per spec
+
+_These are only provided as a compatibility layer, prefer hardened APIs instead in new code._
+
+ * `TextDecoder` can (and should) be used with `{ fatal: true }` option for all purposes demanding correctness / lossless transforms
+
+ * `TextEncoder` does not support a fatal mode per spec, it always performs replacement.
+
+   That is not suitable for hashing, cryptography or consensus applications.\
+   Otherwise there would be non-equal strings with equal signatures and hashes — the collision is caused by the lossy transform of a JS string to bytes.
+   Those also survive e.g. `JSON.stringify`/`JSON.parse` or being sent over network.
+
+   Use strict APIs in new applications, see `utf8fromString` / `utf16fromString` below.\
+   Those throw on non-well-formed strings by default.
+
+### Lite version
+
+If you don't need support for legacy multi-byte encodings, you can use the lite import:
+```js
+import { TextDecoder, TextEncoder } from '@exodus/bytes/encoding-lite.js'
+```
+
+This reduces the bundle size 10x:\
+from 90 KiB gzipped for `@exodus/bytes/encoding.js` to 9 KiB gzipped for `@exodus/bytes/encoding-lite.js`.\
+(For comparison, `text-encoding` module is 190 KiB gzipped, and `iconv-lite` is 194 KiB gzipped).
+
+It still supports `utf-8`, `utf-16le`, `utf-16be` and all single-byte encodings specified by the spec,
+the only difference is support for legacy multi-byte encodings.
+
+See [the list of encodings](https://encoding.spec.whatwg.org/#names-and-labels).
 
 ## API
 
+### `@exodus/bytes/utf8.js`
+
+##### `utf8fromString(str, format = 'uint8')`
+##### `utf8fromStringLoose(str, format = 'uint8')`
+##### `utf8toString(arr)`
+##### `utf8toStringLoose(arr)`
+
+### `@exodus/bytes/utf16.js`
+
+##### `utf16fromString(str, format = 'uint16')`
+##### `utf16fromStringLoose(str, format = 'uint16')`
+##### `utf16toString(arr, 'uint16')`
+##### `utf16toStringLoose(arr, 'uint16')`
+
+### `@exodus/bytes/single-byte.js`
+
+##### `createSinglebyteDecoder(encoding, loose = false)`
+
+Create a decoder for a supported one-byte `encoding`.
+
+Returns a function `decode(arr)` that decodes bytes to a string.
+
+### `@exodus/bytes/multi-byte.js`
+
+##### `createMultibyteDecoder(encoding, loose = false)`
+
+Create a decoder for a supported legacy multi-byte `encoding`.
+
+Returns a function `decode(arr, stream = false)` that decodes bytes to a string.
+
+That function will have state while `stream = true` is used.
+
+##### `windows1252toString(arr)`
+
+Decode `windows-1252` bytes to a string.
+
+Also supports `ascii` and `latin-1` as those are strict subsets of `windows-1252`.
+
+There is no loose variant for this encoding, all bytes can be decoded.
+
+Same as `windows1252toString = createSinglebyteDecoder('windows-1252')`.
+
+### `@exodus/bytes/bigint.js`
+
+##### `fromBigInt(bigint, { length, format = 'uint8' })`
+##### `toBigInt(arr)`
+
 ### `@exodus/bytes/hex.js`
 
+##### `toHex(arr)`
+##### `fromHex(string)`
+
 ### `@exodus/bytes/base64.js`
 
+##### `toBase64(arr, { padding = true })`
+##### `toBase64url(arr, { padding = false })`
+##### `fromBase64(str, { format = 'uint8', padding = 'both' })`
+##### `fromBase64url(str, { format = 'uint8', padding = false })`
+##### `fromBase64any(str, { format = 'uint8', padding = 'both' })`
+
 ### `@exodus/bytes/base32.js`
 
-### `@exodus/bytes/hex.js`
+##### `toBase32(arr, { padding = false })`
+##### `toBase32hex(arr, { padding = false })`
+##### `fromBase32(str, { format = 'uint8', padding = 'both' })`
+##### `fromBase32hex(str, { format = 'uint8', padding = 'both' })`
+
+### `@exodus/bytes/bech32.js`
+
+##### `getPrefix(str, limit = 90)`
+##### `toBech32(prefix, bytes, limit = 90)`
+##### `fromBech32(str, limit = 90)`
+##### `toBech32m(prefix, bytes, limit = 90)`
+##### `fromBech32m(str, limit = 90)`
 
 ### `@exodus/bytes/base58.js`
 
+##### `toBase58(arr)`
+##### `fromBase58(str, format = 'uint8')`
+
+##### `toBase58xrp(arr)`
+##### `fromBase58xrp(str, format = 'uint8')`
+
 ### `@exodus/bytes/base58check.js`
 
+##### `async toBase58check(arr)`
+##### `toBase58checkSync(arr)`
+##### `async fromBase58check(str, format = 'uint8')`
+##### `fromBase58checkSync(str, format = 'uint8')`
+##### `makeBase58check(hashAlgo, hashAlgoSync)`
+
 ### `@exodus/bytes/wif.js`
 
+##### `async fromWifString(string, version)`
+##### `fromWifStringSync(string, version)`
+##### `async toWifString({ version, privateKey, compressed })`
+##### `toWifStringSync({ version, privateKey, compressed })`
+
+### `@exodus/bytes/encoding.js`
+
+Implements the [Encoding standard](https://encoding.spec.whatwg.org/):
+[TextDecoder](https://encoding.spec.whatwg.org/#interface-textdecoder),
+[TextEncoder](https://encoding.spec.whatwg.org/#interface-textdecoder),
+some [hooks](https://encoding.spec.whatwg.org/#specification-hooks) (see below).
+
+```js
+import { TextDecoder, TextDecoder } from '@exodus/bytes/encoding.js'
+
+// Hooks for standards
+import { getBOMEncoding, legacyHookDecode, normalizeEncoding } from '@exodus/bytes/encoding.js'
+```
+
+#### `new TextDecoder(label = 'utf-8', { fatal = false, ignoreBOM = false })`
+
+[TextDecoder](https://encoding.spec.whatwg.org/#interface-textdecoder) implementation/polyfill.
+
+#### `new TextEncoder()`
+
+[TextEncoder](https://encoding.spec.whatwg.org/#interface-textdecoder) implementation/polyfill.
+
+#### `normalizeEncoding(label)`
+
+Implements [get an encoding from a string `label`](https://encoding.spec.whatwg.org/#concept-encoding-get).
+
+Converts an encoding [label](https://encoding.spec.whatwg.org/#names-and-labels) to its name,
+as an ASCII-lowercased string.
+
+If an encoding with that label does not exist, returns `null`.
+
+This is the same as [`decoder.encoding` getter](https://encoding.spec.whatwg.org/#dom-textdecoder-encoding),
+except that it does not throw for invalid labels and instead returns `null`, and is identical to
+the following code:
+```js
+try {
+  if (!label) return null // does not default to 'utf-8'
+  return new TextDecoder(label).encoding
+} catch {
+  return null
+}
+```
+
+All encoding names are also valid labels for corresponding encodings.
+
+#### `getBOMEncoding(input)`
+
+Implements [BOM sniff](https://encoding.spec.whatwg.org/#bom-sniff) legacy hook.
+
+Given a `TypedArray` or an `ArrayBuffer` instance `input`, returns either of:
+* `'utf-8'`, if `input` starts with UTF-8 byte order mark.
+* `'utf-16le'`, if `input` starts with UTF-16LE byte order mark.
+* `'utf-16be'`, if `input` starts with UTF-16BE byte order mark.
+* `null` otherwise.
+
+#### `legacyHookDecode(input, fallbackEncoding = 'utf-8')`
+
+Implements [decode](https://encoding.spec.whatwg.org/#decode) legacy hook.
+
+Given a `TypedArray` or an `ArrayBuffer` instance `input` and an optional `fallbackEncoding`
+normalized encoding name, sniffs encoding from BOM with `fallbackEncoding` fallback and then
+decodes the `input` using that encoding, skipping BOM if it was present.
+
+Notes:
+
+ * BOM-sniffed encoding takes precedence over `fallbackEncoding` option per spec.
+   Use with care.
+ * `fallbackEncoding` must be ASCII-lowercased encoding name,
+   e.g. a result of `normalizeEncoding(label)` call.
+ * Always operates in non-fatal [mode](https://encoding.spec.whatwg.org/#textdecoder-error-mode),
+   aka replacement. It can convert different byte sequences to equal strings.
+
+This method is similar to the following code, except that it doesn't support encoding labels and
+only expects lowercased encoding name:
+
+```js
+new TextDecoder(getBOMEncoding(input) ?? fallbackEncoding ?? 'utf-8').decode(input)
+```
+
+### `@exodus/bytes/encoding-lite.js`
+
+```js
+import { TextDecoder, TextDecoder } from '@exodus/bytes/encoding-lite.js'
+
+// Hooks for standards
+import { getBOMEncoding, legacyHookDecode, normalizeEncoding } from '@exodus/bytes/encoding-lite.js'
+```
+
+The exact same exports as `@exodus/bytes/encoding.js` are also exported as
+`@exodus/bytes/encoding-lite.js`, with the difference that the lite version does not load
+multi-byte `TextDecoder` encodings by default to reduce bundle size 10x.
+
+The only affected encodings are: `gbk`, `gb18030`, `big5`, `euc-jp`, `iso-2022-jp`, `shift_jis`
+and their [labels](https://encoding.spec.whatwg.org/#names-and-labels) when used with `TextDecoder`.
+
+Legacy single-byte encodingds are loaded by default in both cases.
+
+`TextEncoder` and hooks for standards (including `normalizeEncoding`) do not have any behavior
+differences in the lite version and support full range if inputs.
+
+To avoid inconsistencies, the exported classes and methods are exactly the same objects.
+
+```console
+> lite = require('@exodus/bytes/encoding-lite.js')
+[Module: null prototype] {
+  TextDecoder: [class TextDecoder],
+  TextEncoder: [class TextEncoder],
+  getBOMEncoding: [Function: getBOMEncoding],
+  legacyHookDecode: [Function: legacyHookDecode],
+  normalizeEncoding: [Function: normalizeEncoding]
+}
+> new lite.TextDecoder('big5').decode(Uint8Array.of(0x25))
+Uncaught:
+Error: Legacy multi-byte encodings are disabled in /encoding-lite.js, use /encoding.js for full encodings range support
+
+> full = require('@exodus/bytes/encoding.js')
+[Module: null prototype] {
+  TextDecoder: [class TextDecoder],
+  TextEncoder: [class TextEncoder],
+  getBOMEncoding: [Function: getBOMEncoding],
+  legacyHookDecode: [Function: legacyHookDecode],
+  normalizeEncoding: [Function: normalizeEncoding]
+}
+> full.TextDecoder === lite.TextDecoder
+true
+> new full.TextDecoder('big5').decode(Uint8Array.of(0x25))
+'%'
+> new lite.TextDecoder('big5').decode(Uint8Array.of(0x25))
+'%'
+```
+
 ## License
 
 [MIT](./LICENSE)

package/array.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="node" />
+
+// >= TypeScript 5.9 made Uint8Array templated with <> and defaulted to ArrayBufferLike
+// which would incorrectly accept SharedArrayBuffer instances.
+// < TypeScript 5.7 doesn't support templates for Uint8Array.
+// So this type is defined as a workaround to evaluate to Uint8Array<ArrayBuffer> on all versions of TypeScript.
+export type Uint8ArrayBuffer = ReturnType<typeof Uint8Array.from>;
+
+/**
+ * Output format for typed array conversions
+ */
+export type OutputFormat = 'uint8' | 'buffer';
+
+/**
+ * Creates a view of a TypedArray in the specified format
+ * Note: This does not copy data - returns a view on the same underlying buffer
+ * @param arr - The input TypedArray
+ * @param format - The desired output format ('uint8' or 'buffer')
+ * @returns A view on the same underlying buffer
+ */
+export function typedView(arr: ArrayBufferView, format: 'uint8'): Uint8Array;
+export function typedView(arr: ArrayBufferView, format: 'buffer'): Buffer;
+export function typedView(arr: ArrayBufferView, format: OutputFormat): Uint8Array | Buffer;
+

package/base58.js

@@ -3,10 +3,10 @@ import { assertUint8 } from './assert.js'
 import { nativeDecoder, nativeEncoder, isHermes } from './fallback/_utils.js'
 import { encodeAscii, decodeAscii } 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 alphabet58 = [...'123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz']
+const alphabetXRP = [...'rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz']
+const codes58 = new Uint8Array(alphabet58.map((x) => x.charCodeAt(0)))
+const codesXRP = new Uint8Array(alphabetXRP.map((x) => x.charCodeAt(0)))
 
 const _0n = BigInt(0)
 const _1n = BigInt(1)
@@ -16,17 +16,18 @@ const _58n = BigInt(58)
 const _0xffffffffn = BigInt(0xff_ff_ff_ff)
 
 let table // 15 * 82, diagonal, <1kb
-let fromMap
+const fromMaps = new Map()
 
 const E_CHAR = 'Invalid character in base58 input'
 
 const shouldUseBigIntFrom = isHermes // faster only on Hermes, numbers path beats it on normal engines
 
-export function toBase58(arr) {
+function toBase58core(arr, alphabet, codes) {
   assertUint8(arr)
   const length = arr.length
   if (length === 0) return ''
 
+  const ZERO = alphabet[0]
   let zeros = 0
   while (zeros < length && arr[zeros] === 0) zeros++
 
@@ -120,18 +121,20 @@ export function toBase58(arr) {
   return ZERO.repeat(zeros) + out
 }
 
-// TODO: test on 'z'.repeat(from 1 to smth)
-export function fromBase58(str, format = 'uint8') {
+function fromBase58core(str, alphabet, codes, 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)
 
+  const zeroC = codes[0]
   let zeros = 0
   while (zeros < length && str.charCodeAt(zeros) === zeroC) zeros++
 
+  let fromMap = fromMaps.get(alphabet)
   if (!fromMap) {
     fromMap = new Int8Array(256).fill(-1)
     for (let i = 0; i < 58; i++) fromMap[alphabet[i].charCodeAt(0)] = i
+    fromMaps.set(alphabet, fromMap)
   }
 
   const size = zeros + (((length - zeros + 1) * 3) >> 2) // 3/4 rounded up, larger than ~0.73 coef to fit everything
@@ -210,3 +213,8 @@ export function fromBase58(str, format = 'uint8') {
 
   return typedView(res.slice(at - zeros), format) // slice is faster for small sizes than subarray
 }
+
+export const toBase58 = (arr) => toBase58core(arr, alphabet58, codes58)
+export const fromBase58 = (str, format) => fromBase58core(str, alphabet58, codes58, format)
+export const toBase58xrp = (arr) => toBase58core(arr, alphabetXRP, codesXRP)
+export const fromBase58xrp = (str, format) => fromBase58core(str, alphabetXRP, codesXRP, format)

package/base64.d.ts

@@ -0,0 +1,76 @@
+/// <reference types="node" />
+
+import type { OutputFormat, Uint8ArrayBuffer } from './array.js';
+
+/**
+ * Options for base64 encoding
+ */
+export interface ToBase64Options {
+  /** Whether to include padding characters (default: true for base64, false for base64url) */
+  padding?: boolean;
+}
+
+/**
+ * Padding mode for base64 decoding
+ * - true: padding is required
+ * - false: padding is not allowed
+ * - 'both': padding is optional (default for base64)
+ */
+export type PaddingMode = boolean | 'both';
+
+/**
+ * Options for base64 decoding
+ */
+export interface FromBase64Options {
+  /** Output format (default: 'uint8') */
+  format?: OutputFormat;
+  /** Padding mode */
+  padding?: PaddingMode;
+}
+
+/**
+ * Encodes a Uint8Array to a base64 string (RFC 4648)
+ * @param arr - The input bytes
+ * @param options - Encoding options
+ * @returns The base64 encoded string
+ */
+export function toBase64(arr: Uint8ArrayBuffer, options?: ToBase64Options): string;
+
+/**
+ * Encodes a Uint8Array to a base64url string (RFC 4648)
+ * @param arr - The input bytes
+ * @param options - Encoding options (padding defaults to false)
+ * @returns The base64url encoded string
+ */
+export function toBase64url(arr: Uint8ArrayBuffer, options?: ToBase64Options): string;
+
+/**
+ * Decodes a base64 string to bytes
+ * Operates in strict mode for last chunk, does not allow whitespace
+ * @param str - The base64 encoded string
+ * @param options - Decoding options
+ * @returns The decoded bytes
+ */
+export function fromBase64(str: string, options?: FromBase64Options): Uint8ArrayBuffer;
+export function fromBase64(str: string, options: FromBase64Options & { format: 'buffer' }): Buffer;
+
+/**
+ * Decodes a base64url string to bytes
+ * Operates in strict mode for last chunk, does not allow whitespace
+ * @param str - The base64url encoded string
+ * @param options - Decoding options (padding defaults to false)
+ * @returns The decoded bytes
+ */
+export function fromBase64url(str: string, options?: FromBase64Options): Uint8ArrayBuffer;
+export function fromBase64url(str: string, options: FromBase64Options & { format: 'buffer' }): Buffer;
+
+/**
+ * Decodes either base64 or base64url string to bytes
+ * Automatically detects the variant based on characters present
+ * @param str - The base64 or base64url encoded string
+ * @param options - Decoding options
+ * @returns The decoded bytes
+ */
+export function fromBase64any(str: string, options?: FromBase64Options): Uint8ArrayBuffer;
+export function fromBase64any(str: string, options: FromBase64Options & { format: 'buffer' }): Buffer;
+

package/bigint.js

@@ -0,0 +1,14 @@
+import { toHex, fromHex } from '@exodus/bytes/hex.js'
+import { assert } from './fallback/_utils.js'
+
+const _0n = BigInt(0)
+
+export function fromBigInt(x, { length, format } = {}) {
+  assert(Number.isSafeInteger(length) && length > 0, 'Expected length arg to be a positive integer')
+  assert(typeof x === 'bigint' && x >= _0n, 'Expected a non-negative bigint')
+  const hex = x.toString(16)
+  assert(length * 2 >= hex.length, `Can not fit supplied number into ${length} bytes`)
+  return fromHex(hex.padStart(length * 2, '0'), format)
+}
+
+export const toBigInt = (a) => BigInt('0x' + (toHex(a) || '0'))

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'

package/fallback/_utils.js

@@ -1,17 +1,38 @@
 const { Buffer, TextEncoder, TextDecoder } = globalThis
 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
-const nativeBuffer = haveNativeBuffer ? Buffer : null
-const isHermes = Boolean(globalThis.HermesInternal)
+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
+
+let isNative = (x) => {
+  if (!x) return false
+  if (haveNativeBuffer) return true // we consider Node.js TextDecoder/TextEncoder native
+  const s = `${x}`
+  // See https://github.com/facebook/hermes/pull/1855#issuecomment-3659386410
+  return s.includes('[native code]') || s.includes(`[bytecode]`) // Static Hermes has [bytecode] for contrib, which includes TextEncoder/TextDecoder
+}
+
+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
 
 // 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
+let nativeDecoderLatin1impl = null
+if (nativeDecoder) {
+  // 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
@@ -35,6 +56,75 @@ function shouldSkipBuiltins() {
   return false // eslint-disable-line no-unreachable
 }
 
-const skipWeb = shouldSkipBuiltins()
+export const skipWeb = shouldSkipBuiltins()
 
-export { nativeEncoder, nativeDecoder, nativeDecoderLatin1, nativeBuffer, isHermes, skipWeb }
+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)
+}
+
+export function assert(condition, msg) {
+  if (!condition) throw new Error(msg)
+}