@exodus/bytes 1.0.0-rc.9 → 1.1.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

@@ -2,6 +2,8 @@
 
 `Uint8Array` conversion to and from `base64`, `base32`, `base58`, `hex`, `utf8`, `utf16`, `bech32` and `wif`
 
+And a [`TextEncoder` / `TextDecoder` polyfill](#textencoder--textdecoder-polyfill)
+
 ## Strict
 
 Performs proper input validation, ensures no garbage-in-garbage-out
@@ -32,6 +34,7 @@ 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.
 
@@ -54,6 +57,22 @@ _These are only provided as a compatibility layer, prefer hardened APIs instead
    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`
@@ -98,6 +117,11 @@ 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)`
@@ -131,6 +155,9 @@ Same as `windows1252toString = createSinglebyteDecoder('windows-1252')`.
 ##### `toBase58(arr)`
 ##### `fromBase58(str, format = 'uint8')`
 
+##### `toBase58xrp(arr)`
+##### `fromBase58xrp(str, format = 'uint8')`
+
 ### `@exodus/bytes/base58check.js`
 
 ##### `async toBase58check(arr)`
@@ -146,6 +173,130 @@ Same as `windows1252toString = createSinglebyteDecoder('windows-1252')`.
 ##### `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:
+ 1. Supports [`replacement` encoding](https://encoding.spec.whatwg.org/#replacement) and its
+    [labels](https://encoding.spec.whatwg.org/#ref-for-replacement%E2%91%A1)
+ 2. Does not throw for invalid labels and instead returns `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`
+encoding [label](https://encoding.spec.whatwg.org/#names-and-labels),
+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.
+ * 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).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

@@ -1,234 +1,12 @@
-// A limited subset of TextEncoder / TextDecoder API
-
-// We can't return native TextDecoder if it's present, as Node.js one is broken on windows-1252 and we fix that
-// We are also faster than Node.js built-in on both TextEncoder and TextDecoder
-
-/* eslint-disable @exodus/import/no-unresolved */
-
-import { utf16toString, utf16toStringLoose } from '@exodus/bytes/utf16.js'
-import { utf8fromStringLoose, utf8toString, utf8toStringLoose } from '@exodus/bytes/utf8.js'
-import { createMultibyteDecoder } from '@exodus/bytes/multi-byte.js'
-import { createSinglebyteDecoder } from '@exodus/bytes/single-byte.js'
-import { multibyteSupported } from './fallback/multi-byte.js'
-import labels from './fallback/encoding.labels.js'
-import { unfinishedBytes } from './fallback/encoding.util.js'
-
-const E_OPTIONS = 'The "options" argument must be of type object'
-const replacementChar = '\uFFFD'
-
-let labelsMap
-const normalizeEncoding = (enc) => {
-  // fast path
-  if (enc === 'utf-8' || enc === 'utf8') return 'utf-8'
-  if (enc === 'windows-1252' || enc === 'ascii' || enc === 'latin1') return 'windows-1252'
-  // full map
-  let low = `${enc}`.toLowerCase()
-  if (low !== low.trim()) low = low.replace(/^[\t\n\f\r ]+/, '').replace(/[\t\n\f\r ]+$/, '') // only ASCII whitespace
-  if (Object.hasOwn(labels, low) && low !== 'replacement') return low
-  if (!labelsMap) {
-    labelsMap = new Map()
-    for (const [label, aliases] of Object.entries(labels)) {
-      for (const alias of aliases) labelsMap.set(alias, label)
-    }
-  }
-
-  const mapped = labelsMap.get(low)
-  if (mapped && mapped !== 'replacement') return mapped
-  throw new RangeError('Unknown encoding')
-}
-
-const define = (obj, key, value) => Object.defineProperty(obj, key, { value, writable: false })
-
-const fromSource = (x) => {
-  if (x instanceof Uint8Array) return x
-  if (x instanceof ArrayBuffer) return new Uint8Array(x)
-  if (ArrayBuffer.isView(x)) return new Uint8Array(x.buffer, x.byteOffset, x.byteLength)
-  if (globalThis.SharedArrayBuffer && x instanceof globalThis.SharedArrayBuffer) {
-    return new Uint8Array(x.buffer, x.byteOffset, x.byteLength)
-  }
-
-  throw new TypeError('Argument must be a SharedArrayBuffer, ArrayBuffer or ArrayBufferView')
-}
-
-function unicodeDecoder(encoding, loose) {
-  if (encoding === 'utf-8') return loose ? utf8toStringLoose : utf8toString // likely
-  const form = encoding === 'utf-16le' ? 'uint8-le' : 'uint8-be'
-  return loose ? (u) => utf16toStringLoose(u, form) : (u) => utf16toString(u, form)
-}
-
-export class TextDecoder {
-  #decode
-  #unicode
-  #multibyte
-  #chunk
-  #canBOM
-
-  constructor(encoding = 'utf-8', options = {}) {
-    if (typeof options !== 'object') throw new TypeError(E_OPTIONS)
-    const enc = normalizeEncoding(encoding)
-    define(this, 'encoding', enc)
-    define(this, 'fatal', Boolean(options.fatal))
-    define(this, 'ignoreBOM', Boolean(options.ignoreBOM))
-    this.#unicode = enc === 'utf-8' || enc === 'utf-16le' || enc === 'utf-16be'
-    this.#multibyte = !this.#unicode && enc !== 'windows-1252' && multibyteSupported(enc)
-    this.#canBOM = this.#unicode && !this.ignoreBOM
-  }
-
-  get [Symbol.toStringTag]() {
-    return 'TextDecoder'
-  }
-
-  decode(input, options = {}) {
-    if (typeof options !== 'object') throw new TypeError(E_OPTIONS)
-    const stream = Boolean(options.stream)
-    let u = input === undefined ? new Uint8Array() : fromSource(input)
-
-    if (this.#unicode) {
-      let prefix
-      if (this.#chunk) {
-        if (u.length === 0) {
-          if (stream) return '' // no change
-          u = this.#chunk // process as final chunk to handle errors and state changes
-        } else if (u.length < 3) {
-          // No reason to bruteforce offsets, also it's possible this doesn't yet end the sequence
-          const a = new Uint8Array(u.length + this.#chunk.length)
-          a.set(this.#chunk)
-          a.set(u, this.#chunk.length)
-          u = a
-        } else {
-          // Slice off a small portion of u into prefix chunk so we can decode them separately without extending array size
-          const t = new Uint8Array(this.#chunk.length + 3) // We have 1-3 bytes and need 1-3 more bytes
-          t.set(this.#chunk)
-          t.set(u.subarray(0, 3), this.#chunk.length)
-
-          // Stop at the first offset where unfinished bytes reaches 0 or fits into u
-          // If that doesn't happen (u too short), just concat chunk and u completely
-          for (let i = 1; i <= 3; i++) {
-            const unfinished = unfinishedBytes(t, this.#chunk.length + i, this.encoding) // 0-3
-            if (unfinished <= i) {
-              // Always reachable at 3, but we still need 'unfinished' value for it
-              const add = i - unfinished // 0-3
-              prefix = add > 0 ? t.subarray(0, this.#chunk.length + add) : this.#chunk
-              if (add > 0) u = u.subarray(add)
-              break
-            }
-          }
-        }
-
-        this.#chunk = null
-      } else if (u.byteLength === 0) {
-        if (!stream) this.#canBOM = !this.ignoreBOM
-        return ''
-      }
-
-      // For non-stream utf-8 we don't have to do this as it matches utf8toStringLoose already
-      // For non-stream loose utf-16 we still have to do this as this API supports uneven byteLength unlike utf16toStringLoose
-      let suffix = ''
-      if (stream || (!this.fatal && this.encoding !== 'utf-8')) {
-        const trail = unfinishedBytes(u, u.byteLength, this.encoding)
-        if (trail > 0) {
-          if (stream) {
-            this.#chunk = Uint8Array.from(u.subarray(-trail)) // copy
-          } else {
-            // non-fatal mode as already checked
-            suffix = replacementChar
-          }
-
-          u = u.subarray(0, -trail)
-        }
-      }
-
-      if (this.#canBOM) {
-        const bom = this.#findBom(prefix ?? u)
-        if (bom) {
-          if (stream) this.#canBOM = false
-          if (prefix) {
-            prefix = prefix.subarray(bom)
-          } else {
-            u = u.subarray(bom)
-          }
-        }
-      }
-
-      if (!this.#decode) this.#decode = unicodeDecoder(this.encoding, !this.fatal)
-      try {
-        const res = (prefix ? this.#decode(prefix) : '') + this.#decode(u) + suffix
-        if (res.length > 0 && stream) this.#canBOM = false
-
-        if (!stream) this.#canBOM = !this.ignoreBOM
-        return res
-      } catch (err) {
-        this.#chunk = null // reset unfinished chunk on errors
-        throw err
-      }
-
-      // eslint-disable-next-line no-else-return
-    } else if (this.#multibyte) {
-      if (!this.#decode) this.#decode = createMultibyteDecoder(this.encoding, !this.fatal) // can contain state!
-      return this.#decode(u, stream)
-    } else {
-      if (!this.#decode) this.#decode = createSinglebyteDecoder(this.encoding, !this.fatal)
-      return this.#decode(u)
-    }
-  }
-
-  #findBom(u) {
-    switch (this.encoding) {
-      case 'utf-8':
-        return u.byteLength >= 3 && u[0] === 0xef && u[1] === 0xbb && u[2] === 0xbf ? 3 : 0
-      case 'utf-16le':
-        return u.byteLength >= 2 && u[0] === 0xff && u[1] === 0xfe ? 2 : 0
-      case 'utf-16be':
-        return u.byteLength >= 2 && u[0] === 0xfe && u[1] === 0xff ? 2 : 0
-    }
-
-    throw new Error('Unreachable')
-  }
-}
-
-export class TextEncoder {
-  constructor() {
-    define(this, 'encoding', 'utf-8')
-  }
-
-  get [Symbol.toStringTag]() {
-    return 'TextEncoder'
-  }
-
-  encode(str = '') {
-    if (typeof str !== 'string') str = `${str}`
-    const res = utf8fromStringLoose(str)
-    return res.byteOffset === 0 ? res : res.slice(0) // Ensure 0-offset. TODO: do we need this?
-  }
-
-  encodeInto(str, target) {
-    if (typeof str !== 'string') str = `${str}`
-    if (!(target instanceof Uint8Array)) throw new TypeError('Target must be an Uint8Array')
-    if (target.buffer.detached) return { read: 0, written: 0 } // Until https://github.com/whatwg/encoding/issues/324 is resolved
-
-    let u8 = utf8fromStringLoose(str) // TODO: perf?
-    let read
-    if (target.length >= u8.length) {
-      read = str.length
-    } else if (u8.length === str.length) {
-      if (u8.length > target.length) u8 = u8.subarray(0, target.length) // ascii can be truncated
-      read = u8.length
-    } else {
-      u8 = u8.subarray(0, target.length)
-      const unfinished = unfinishedBytes(u8, u8.length, 'utf-8')
-      if (unfinished > 0) u8 = u8.subarray(0, u8.length - unfinished)
-
-      // We can do this because loose str -> u8 -> str preserves length, unlike loose u8 -> str -> u8
-      // Each unpaired surrogate (1 charcode) is replaced with a single charcode
-      read = utf8toStringLoose(u8).length // FIXME: Converting back is very inefficient
-    }
-
-    try {
-      target.set(u8)
-    } catch {
-      return { read: 0, written: 0 } // see above, likely detached but no .detached property support
-    }
-
-    return { read, written: u8.length }
-  }
-}
+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'