@exodus/bytes 1.12.0 → 1.14.0

package/README.md

@@ -30,7 +30,7 @@ Tested in CI with [@exodus/test](https://github.com/ExodusMovement/test#exoduste
 [![Hermes](https://img.shields.io/badge/Hermes-282C34?style=for-the-badge&logo=React)](https://hermesengine.dev)
 [![V8](https://img.shields.io/badge/V8-4285F4?style=for-the-badge&logo=V8&logoColor=white)](https://v8.dev/docs/d8)
 [![JavaScriptCore](https://img.shields.io/badge/JavaScriptCore-006CFF?style=for-the-badge)](https://docs.webkit.org/Deep%20Dive/JSC/JavaScriptCore.html)
-[![SpiderMonkey](https://img.shields.io/badge/SpiderMonkey-FFD681?style=for-the-badge)](https://spidermonkey.dev/)
+[![SpiderMonkey](https://img.shields.io/badge/SpiderMonkey-FFD681?style=for-the-badge)](https://spidermonkey.dev/)\
 [![QuickJS](https://img.shields.io/badge/QuickJS-E58200?style=for-the-badge)](https://github.com/quickjs-ng/quickjs)
 [![XS](https://img.shields.io/badge/XS-0B307A?style=for-the-badge)](https://github.com/Moddable-OpenSource/moddable)
 [![GraalJS](https://img.shields.io/badge/GraalJS-C74634?style=for-the-badge)](https://github.com/oracle/graaljs)
@@ -100,24 +100,47 @@ _These are only provided as a compatibility layer, prefer hardened APIs instead
 
 ### 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'
-import { TextDecoderStream, TextEncoderStream } from '@exodus/bytes/encoding-lite.js' // Requires Streams
-```
+Alternate exports exist that can help reduce bundle size, see comparison:
+
+| import | size |
+| - | - |
+| [@exodus/bytes/encoding-browser.js](#exodusbytesencoding-browserjs-) | <sub>![](https://img.shields.io/bundlejs/size/@exodus/bytes/encoding-browser.js?style=flat-square)</sub> |
+| [@exodus/bytes/encoding-lite.js](#exodusbytesencoding-litejs-) | <sub>![](https://img.shields.io/bundlejs/size/@exodus/bytes/encoding-lite.js?style=flat-square)</sub> |
+| [@exodus/bytes/encoding.js](#exodusbytesencodingjs-) | <sub>![](https://img.shields.io/bundlejs/size/@exodus/bytes/encoding.js?style=flat-square)</sub> |
+| `text-encoding` | <sub>![](https://img.shields.io/bundlejs/size/text-encoding?style=flat-square)</sub> |
+| `iconv-lite` | <sub>![](https://img.shields.io/bundlejs/size/iconv-lite/lib/index.js?style=flat-square)</sub> |
+| `whatwg-encoding` | <sub>![](https://img.shields.io/bundlejs/size/whatwg-encoding?style=flat-square)</sub> |
+
+Libraries are advised to use single-purpose hardened `@exodus/bytes/utf8.js` / `@exodus/bytes/utf16.js` APIs for Unicode.
+
+Applications (including React Native apps) are advised to load either `@exodus/bytes/encoding-lite.js` or `@exodus/bytes/encoding.js`
+(depending on whether legacy multi-byte support is needed) and use that as a global polyfill.
 
-This reduces the bundle size 9x:\
-from 90 KiB gzipped for `@exodus/bytes/encoding.js` to 10 KiB gzipped for `@exodus/bytes/encoding-lite.js`.\
-(For comparison, `text-encoding` module is 190 KiB gzipped, and `iconv-lite` is 194 KiB gzipped):
+#### `@exodus/bytes/encoding-lite.js`
 
-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.
+If you don't need support for legacy multi-byte encodings.
+
+Reduces the bundle size ~12x, while still keeping `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).
 
+This can be useful for example in React Native global TextDecoder polyfill,
+if you are sure that you don't need legacy multi-byte encodings support.
+
+#### `@exodus/bytes/encoding-browser.js`
+
+Resolves to a tiny import in browser bundles, preferring native `TextDecoder` / `TextEncoder`.
+
+For non-browsers (Node.js, React Native), loads a full implementation.
+
+> [!NOTE]
+> This is not the default behavior for `@exodus/bytes/encoding.js` because all major browser implementations have bugs,
+> which `@exodus/bytes/encoding.js` fixes. Only use if you are ok with that.
+
 ## API
 
-### @exodus/bytes/utf8.js
+### @exodus/bytes/utf8.js <sub>![](https://img.shields.io/bundlejs/size/@exodus/bytes/utf8.js?style=flat-square)<sub>
 
 UTF-8 encoding/decoding
 
@@ -183,7 +206,7 @@ Prefer using strict throwing methods for cryptography applications._
 This is similar to `new TextDecoder('utf-8', { ignoreBOM: true }).decode(arr)`,
 but works on all engines.
 
-### @exodus/bytes/utf16.js
+### @exodus/bytes/utf16.js <sub>![](https://img.shields.io/bundlejs/size/@exodus/bytes/utf16.js?style=flat-square)<sub>
 
 UTF-16 encoding/decoding
 
@@ -233,7 +256,7 @@ Prefer using strict throwing methods for cryptography applications._
 
 Throws on non-even byte length.
 
-### @exodus/bytes/single-byte.js
+### @exodus/bytes/single-byte.js <sub>![](https://img.shields.io/bundlejs/size/@exodus/bytes/single-byte.js?style=flat-square)</sub>
 
 Decode / encode the legacy single-byte encodings according to the
 [Encoding standard](https://encoding.spec.whatwg.org/)
@@ -354,7 +377,7 @@ Same as:
 const windows1252fromString = createSinglebyteEncoder('windows-1252', { mode: 'fatal' })
 ```
 
-### @exodus/bytes/multi-byte.js
+### @exodus/bytes/multi-byte.js <sub>![](https://img.shields.io/bundlejs/size/@exodus/bytes/multi-byte.js?style=flat-square)</sub>
 
 Decode / encode the legacy multi-byte encodings according to the
 [Encoding standard](https://encoding.spec.whatwg.org/)
@@ -396,7 +419,7 @@ Returns a function `encode(string)` that encodes a string to bytes.
 In `'fatal'` mode (default), will throw on non well-formed strings or any codepoints which could
 not be encoded in the target encoding.
 
-### @exodus/bytes/bigint.js
+### @exodus/bytes/bigint.js <sub>![](https://img.shields.io/bundlejs/size/@exodus/bytes/bigint.js?style=flat-square)</sub>
 
 Convert between BigInt and Uint8Array
 
@@ -418,7 +441,7 @@ Convert a Uint8Array or Buffer to a BigInt
 
 The bytes are interpreted as a big-endian unsigned integer.
 
-### @exodus/bytes/hex.js
+### @exodus/bytes/hex.js <sub>![](https://img.shields.io/bundlejs/size/@exodus/bytes/hex.js?style=flat-square)</sub>
 
 Implements Base16 from [RFC4648](https://datatracker.ietf.org/doc/html/rfc4648)
 (no differences from [RFC3548](https://datatracker.ietf.org/doc/html/rfc4648)).
@@ -437,7 +460,7 @@ Unlike `Buffer.from()`, throws on invalid input
 
 Encode a `Uint8Array` to a lowercase hex string
 
-### @exodus/bytes/base64.js
+### @exodus/bytes/base64.js <sub>![](https://img.shields.io/bundlejs/size/@exodus/bytes/base64.js?style=flat-square)</sub>
 
 Implements base64 and base64url from [RFC4648](https://datatracker.ietf.org/doc/html/rfc4648)
 (no differences from [RFC3548](https://datatracker.ietf.org/doc/html/rfc4648)).
@@ -474,7 +497,7 @@ Encode a `Uint8Array` to a base64 string (RFC 4648)
 
 Encode a `Uint8Array` to a base64url string (RFC 4648)
 
-### @exodus/bytes/base32.js
+### @exodus/bytes/base32.js <sub>![](https://img.shields.io/bundlejs/size/@exodus/bytes/base32.js?style=flat-square)</sub>
 
 Implements base32 and base32hex from [RFC4648](https://datatracker.ietf.org/doc/html/rfc4648)
 (no differences from [RFC3548](https://datatracker.ietf.org/doc/html/rfc4648)).
@@ -504,7 +527,7 @@ Encode a `Uint8Array` to a base32 string (RFC 4648)
 
 Encode a `Uint8Array` to a base32hex string (RFC 4648)
 
-### @exodus/bytes/bech32.js
+### @exodus/bytes/bech32.js <sub>![](https://img.shields.io/bundlejs/size/@exodus/bytes/bech32.js?style=flat-square)</sub>
 
 Implements bech32 and bech32m from
 [BIP-0173](https://github.com/bitcoin/bips/blob/master/bip-0173.mediawiki#specification)
@@ -538,7 +561,7 @@ Decode a bech32m string to bytes
 
 Encode bytes to a bech32m string
 
-### @exodus/bytes/base58.js
+### @exodus/bytes/base58.js <sub>![](https://img.shields.io/bundlejs/size/@exodus/bytes/base58.js?style=flat-square)</sub>
 
 Implements [base58](https://www.ietf.org/archive/id/draft-msporny-base58-03.txt) encoding.
 
@@ -573,7 +596,7 @@ Encode a `Uint8Array` to a base58 string using XRP alphabet
 
 Uses the XRP variant base58 alphabet
 
-### @exodus/bytes/base58check.js
+### @exodus/bytes/base58check.js <sub>![](https://img.shields.io/bundlejs/size/@exodus/bytes/base58check.js?style=flat-square)</sub>
 
 Implements [base58check](https://en.bitcoin.it/wiki/Base58Check_encoding) encoding.
 
@@ -613,7 +636,7 @@ Uses double SHA-256 for checksum calculation
 
 Create a base58check encoder/decoder with custom hash functions
 
-### @exodus/bytes/wif.js
+### @exodus/bytes/wif.js <sub>![](https://img.shields.io/bundlejs/size/@exodus/bytes/wif.js?style=flat-square)</sub>
 
 Wallet Import Format (WIF) encoding and decoding.
 
@@ -652,7 +675,7 @@ Encode WIF data to a WIF string
 
 Encode WIF data to a WIF string (synchronous)
 
-### @exodus/bytes/array.js
+### @exodus/bytes/array.js <sub>![](https://img.shields.io/bundlejs/size/@exodus/bytes/array.js?style=flat-square)</sub>
 
 TypedArray utils and conversions.
 
@@ -667,7 +690,7 @@ Create a view of a TypedArray in the specified format (`'uint8'` or `'buffer'`)
 > [!IMPORTANT]
 > Does not copy data, returns a view on the same underlying buffer
 
-### @exodus/bytes/encoding.js
+### @exodus/bytes/encoding.js <sub>![](https://img.shields.io/bundlejs/size/@exodus/bytes/encoding.js?style=flat-square)</sub>
 
 Implements the [Encoding standard](https://encoding.spec.whatwg.org/):
 [TextDecoder](https://encoding.spec.whatwg.org/#interface-textdecoder),
@@ -778,11 +801,11 @@ only expects lowercased encoding name:
 new TextDecoder(getBOMEncoding(input) ?? fallbackEncoding).decode(input)
 ```
 
-### @exodus/bytes/encoding-lite.js
+### @exodus/bytes/encoding-lite.js <sub>![](https://img.shields.io/bundlejs/size/@exodus/bytes/encoding-lite.js?style=flat-square)</sub>
 
 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.
+multi-byte `TextDecoder` encodings by default to reduce bundle size ~12x.
 
 ```js
 import { TextDecoder, TextEncoder } from '@exodus/bytes/encoding-lite.js'
@@ -837,7 +860,7 @@ true
 '%'
 ```
 
-### @exodus/bytes/encoding-browser.js
+### @exodus/bytes/encoding-browser.js <sub>![](https://img.shields.io/bundlejs/size/@exodus/bytes/encoding-browser.js?style=flat-square)<sub>
 
 Same as `@exodus/bytes/encoding.js`, but in browsers instead of polyfilling just uses whatever the
 browser provides, drastically reducing the bundle size (to less than 2 KiB gzipped).
@@ -858,7 +881,7 @@ do not provide sufficiently complete / non-buggy `TextDecoder` APIs.
 > but they are fixing them and the expected update window is short.\
 > If you want to circumvent browser bugs, use full `@exodus/bytes/encoding.js` import.
 
-### @exodus/bytes/whatwg.js
+### @exodus/bytes/whatwg.js <sub>![](https://img.shields.io/bundlejs/size/@exodus/bytes/whatwg.js?style=flat-square)</sub>
 
 WHATWG helpers
 

package/array.js

@@ -1,6 +1,6 @@
 import { assertTypedArray } from './assert.js'
 
-const { Buffer } = globalThis // Buffer is optional
+const Buffer = globalThis.Buffer // Buffer is optional
 
 export function typedView(arr, format) {
   assertTypedArray(arr)

package/base32.js

@@ -7,8 +7,6 @@ import * as js from './fallback/base32.js'
 
 // 8 chars per 5 bytes
 
-const { E_PADDING } = js
-
 export const toBase32 = (arr, { padding = false } = {}) => js.toBase32(arr, false, padding)
 export const toBase32hex = (arr, { padding = false } = {}) => js.toBase32(arr, true, padding)
 
@@ -30,7 +28,7 @@ function fromBase32common(str, isBase32Hex, padding, format, rest) {
   if (rest !== null) assertEmptyRest(rest)
 
   if (padding === true) {
-    if (str.length % 8 !== 0) throw new SyntaxError(E_PADDING)
+    if (str.length % 8 !== 0) throw new SyntaxError(js.E_PADDING)
   } else if (padding === false) {
     if (str.endsWith('=')) throw new SyntaxError('Did not expect padding in base32 input')
   } else if (padding !== 'both') {

package/base58.js

@@ -1,6 +1,6 @@
 import { typedView } from './array.js'
-import { assertUint8 } from './assert.js'
-import { nativeDecoder, nativeEncoder, isHermes, E_STRING } from './fallback/_utils.js'
+import { assertU8, E_STRING } from './fallback/_utils.js'
+import { nativeDecoder, nativeEncoder, isHermes } from './fallback/platform.js'
 import { encodeAscii, decodeAscii } from './fallback/latin1.js'
 
 const alphabet58 = [...'123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz']
@@ -23,7 +23,7 @@ const E_CHAR = 'Invalid character in base58 input'
 const shouldUseBigIntFrom = isHermes // faster only on Hermes, numbers path beats it on normal engines
 
 function toBase58core(arr, alphabet, codes) {
-  assertUint8(arr)
+  assertU8(arr)
   const length = arr.length
   if (length === 0) return ''
 

package/base58check.d.ts

@@ -81,8 +81,8 @@ export interface Base58CheckSync extends Base58CheckAsync {
  * @param hashAlgoSync - Optional sync hash function
  * @returns Base58Check encoder/decoder instance
  */
-export function makeBase58check(hashAlgo: HashFunction, hashAlgoSync?: HashFunctionSync): Base58CheckSync;
-export function makeBase58check(hashAlgo: HashFunction): Base58CheckAsync;
+export function makeBase58check(hashAlgo: HashFunction | HashFunctionSync, hashAlgoSync: HashFunctionSync): Base58CheckSync;
+export function makeBase58check(hashAlgo: HashFunction | HashFunctionSync, hashAlgoSync?: undefined): Base58CheckAsync;
 
 /**
  * Encode bytes to base58check string asynchronously

package/base58check.js

@@ -8,12 +8,11 @@ import { makeBase58check } from './fallback/base58check.js'
 
 const hash256sync = (x) => sha256(sha256(x))
 const hash256 = hash256sync // See note at the top
-const {
-  encode: toBase58check,
-  decode: fromBase58check,
-  encodeSync: toBase58checkSync,
-  decodeSync: fromBase58checkSync,
-} = makeBase58check(hash256, hash256sync)
+
+const b58c = /* @__PURE__ */ makeBase58check(hash256, hash256sync)
+export const toBase58check = /* @__PURE__ */ (() => b58c.encode)()
+export const fromBase58check = /* @__PURE__ */ (() => b58c.decode)()
+export const toBase58checkSync = /* @__PURE__ */ (() => b58c.encodeSync)()
+export const fromBase58checkSync = /* @__PURE__ */ (() => b58c.decodeSync)()
 
 export { makeBase58check } from './fallback/base58check.js'
-export { toBase58check, fromBase58check, toBase58checkSync, fromBase58checkSync }

package/base64.js

@@ -1,6 +1,7 @@
-import { assertUint8, assertEmptyRest } from './assert.js'
+import { assertEmptyRest } from './assert.js'
 import { typedView } from './array.js'
-import { isHermes, skipWeb, E_STRING } from './fallback/_utils.js'
+import { assertU8, E_STRING } from './fallback/_utils.js'
+import { isHermes } from './fallback/platform.js'
 import { decodeLatin1, encodeLatin1 } from './fallback/latin1.js'
 import * as js from './fallback/base64.js'
 
@@ -34,10 +35,10 @@ function maybePad(res, padding) {
 }
 
 const toUrl = (x) => x.replaceAll('+', '-').replaceAll('/', '_')
-const haveWeb = (x) => !skipWeb && web64 && x.toBase64 === web64
+const haveWeb = (x) => web64 && x.toBase64 === web64
 
 export function toBase64(x, { padding = true } = {}) {
-  assertUint8(x)
+  assertU8(x)
   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)
@@ -46,7 +47,7 @@ export function toBase64(x, { padding = true } = {}) {
 
 // NOTE: base64url omits padding by default
 export function toBase64url(x, { padding = false } = {}) {
-  assertUint8(x)
+  assertU8(x)
   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)
@@ -111,7 +112,7 @@ function noWhitespaceSeen(str, arr) {
 }
 
 let fromBase64impl
-if (!skipWeb && Uint8Array.fromBase64) {
+if (Uint8Array.fromBase64) {
   // NOTICE: this is actually slower than our JS impl in older JavaScriptCore and (slightly) in SpiderMonkey, but faster on V8 and new JavaScriptCore
   fromBase64impl = (str, isBase64url, padding) => {
     const alphabet = isBase64url ? 'base64url' : 'base64'

package/bech32.js

@@ -1,5 +1,5 @@
-import { assertUint8 } from './assert.js'
-import { nativeEncoder, E_STRING } from './fallback/_utils.js'
+import { assertU8, E_STRING } from './fallback/_utils.js'
+import { nativeEncoder } from './fallback/platform.js'
 import { decodeAscii, encodeAscii, encodeLatin1 } from './fallback/latin1.js'
 
 const alphabet = [...'qpzry9x8gf2tvdw0s3jn54khce6mua7l']
@@ -109,7 +109,7 @@ function pPrefix(prefix) {
 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)
+  assertU8(bytes)
   const bytesLength = bytes.length
   const wordsLength = Math.ceil((bytesLength * 8) / 5)
   if (!(prefix.length + 7 + wordsLength <= limit)) throw new TypeError(E_SIZE)

package/encoding-browser.browser.js

@@ -1,10 +1,4 @@
-import {
-  fromSource,
-  getBOMEncoding,
-  normalizeEncoding,
-  E_ENCODING,
-} from './fallback/encoding.api.js'
-import labels from './fallback/encoding.labels.js'
+import { getBOMEncoding } from './fallback/encoding.api.js'
 
 // Lite-weight version which re-exports existing implementations on browsers,
 // while still being aliased to the full impl in RN and Node.js
@@ -13,17 +7,49 @@ import labels from './fallback/encoding.labels.js'
 
 const { TextDecoder, TextEncoder, TextDecoderStream, TextEncoderStream } = globalThis
 
-export { normalizeEncoding, getBOMEncoding, labelToName } from './fallback/encoding.api.js'
+export { getBOMEncoding } from './fallback/encoding.api.js'
 export { TextDecoder, TextEncoder, TextDecoderStream, TextEncoderStream }
 
-// https://encoding.spec.whatwg.org/#decode
+export function normalizeEncoding(label) {
+  if (label === 'utf-8' || label === 'utf8' || label === 'UTF-8' || label === 'UTF8') return 'utf-8'
+  if (label === 'windows-1252' || label === 'ascii' || label === 'latin1') return 'windows-1252'
+  if (/[^\w\t\n\f\r .:-]/i.test(label)) return null
+  const l = `${label}`.trim().toLowerCase()
+  try {
+    return new TextDecoder(l).encoding
+  } catch {}
+
+  if (l === 'x-user-defined') return l
+  if (
+    l === 'replacement' ||
+    l === 'csiso2022kr' ||
+    l === 'hz-gb-2312' ||
+    l === 'iso-2022-cn' ||
+    l === 'iso-2022-cn-ext' ||
+    l === 'iso-2022-kr'
+  ) {
+    return 'replacement'
+  }
+
+  return null
+}
+
 export function legacyHookDecode(input, fallbackEncoding = 'utf-8') {
-  let u8 = fromSource(input)
-  const bomEncoding = getBOMEncoding(u8)
-  if (bomEncoding) u8 = u8.subarray(bomEncoding === 'utf-8' ? 3 : 2)
-  const enc = bomEncoding ?? normalizeEncoding(fallbackEncoding) // "the byte order mark is more authoritative than anything else"
-  if (enc === 'utf-8') return new TextDecoder('utf-8', { ignoreBOM: true }).decode(u8) // fast path
-  if (enc === 'replacement') return u8.byteLength > 0 ? '\uFFFD' : ''
-  if (!Object.hasOwn(labels, enc)) throw new RangeError(E_ENCODING)
-  return new TextDecoder(enc, { ignoreBOM: true }).decode(u8)
+  const enc = getBOMEncoding(input) ?? normalizeEncoding(fallbackEncoding)
+  if (enc === 'replacement') return input.byteLength > 0 ? '\uFFFD' : ''
+  return new TextDecoder(enc).decode(input)
+}
+
+export function labelToName(label) {
+  const enc = normalizeEncoding(label)
+  if (enc === 'utf-8') return 'UTF-8'
+  if (!enc) return enc
+  const p = enc.slice(0, 3)
+  if (p === 'utf' || p === 'iso' || p === 'koi' || p === 'euc' || p === 'ibm' || p === 'gbk') {
+    return enc.toUpperCase()
+  }
+
+  if (enc === 'big5') return 'Big5'
+  if (enc === 'shift_jis') return 'Shift_JIS'
+  return enc
 }

package/fallback/_utils.js

@@ -1,131 +1,15 @@
-const { Buffer, TextEncoder, TextDecoder } = globalThis
-const haveNativeBuffer = Buffer && !Buffer.TYPED_ARRAY_SUPPORT
-export const nativeBuffer = haveNativeBuffer ? Buffer : null
-export const isHermes = !!globalThis.HermesInternal
-export const isDeno = !!globalThis.Deno
-export const isLE = /* @__PURE__ */ (() => new Uint8Array(Uint16Array.of(258).buffer)[0] === 2)()
+export * from './platform.js'
 
-// We consider Node.js TextDecoder/TextEncoder native
-let isNative = (x) => x && (haveNativeBuffer || `${x}`.includes('[native code]'))
-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 getNativeLatin1 = () => {
-  // Not all barebone engines with TextDecoder support something except utf-8, detect
-  if (nativeDecoder) {
-    try {
-      return new TextDecoder('latin1', { ignoreBOM: true })
-    } catch {}
-  }
-
-  return null
-}
-
-export const nativeDecoderLatin1 = /* @__PURE__ */ getNativeLatin1()
-
-// 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
-  }
-
-  /* c8 ignore next */
-  return false // eslint-disable-line no-unreachable
-}
-
-export const skipWeb = /* @__PURE__ */ 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 (end - start > 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)
-}
+const Buffer = /* @__PURE__ */ (() => globalThis.Buffer)()
 
 export function assert(condition, msg) {
   if (!condition) throw new Error(msg)
 }
 
+export function assertU8(arg) {
+  if (!(arg instanceof Uint8Array)) throw new TypeError('Expected an Uint8Array')
+}
+
 // On arrays in heap (<= 64) it's cheaper to copy into a pooled buffer than lazy-create the ArrayBuffer storage
 export const toBuf = (x) =>
   x.byteLength <= 64 && x.BYTES_PER_ELEMENT === 1
@@ -133,3 +17,4 @@ export const toBuf = (x) =>
     : Buffer.from(x.buffer, x.byteOffset, x.byteLength)
 
 export const E_STRING = 'Input is not a string'
+export const E_STRICT_UNICODE = 'Input is not well-formed Unicode'

package/fallback/base32.js

@@ -1,5 +1,5 @@
-import { assertUint8 } from '../assert.js'
-import { nativeEncoder, nativeDecoder, isHermes } from './_utils.js'
+import { assertU8 } from './_utils.js'
+import { nativeEncoder, nativeDecoder, isHermes } from './platform.js'
 import { encodeAscii, decodeAscii } from './latin1.js'
 
 // See https://datatracker.ietf.org/doc/html/rfc4648
@@ -18,7 +18,7 @@ const useTemplates = isHermes // Faster on Hermes and JSC, but we use it only on
 
 // We construct output by concatenating chars, this seems to be fine enough on modern JS engines
 export function toBase32(arr, isBase32Hex, padding) {
-  assertUint8(arr)
+  assertU8(arr)
   const fullChunks = Math.floor(arr.length / 5)
   const fullChunksBytes = fullChunks * 5
   let o = ''

package/fallback/base58check.js

@@ -1,6 +1,6 @@
 import { typedView } from '@exodus/bytes/array.js'
 import { toBase58, fromBase58 } from '@exodus/bytes/base58.js'
-import { assertUint8 } from '../assert.js'
+import { assertU8 } from './_utils.js'
 
 const E_CHECKSUM = 'Invalid checksum'
 
@@ -28,7 +28,7 @@ function assertChecksum(c, r) {
 export const makeBase58check = (hashAlgo, hashAlgoSync) => {
   const apis = {
     async encode(arr) {
-      assertUint8(arr)
+      assertU8(arr)
       return encodeWithChecksum(arr, await hashAlgo(arr))
     },
     async decode(str, format = 'uint8') {
@@ -41,7 +41,7 @@ export const makeBase58check = (hashAlgo, hashAlgoSync) => {
   return {
     ...apis,
     encodeSync(arr) {
-      assertUint8(arr)
+      assertU8(arr)
       return encodeWithChecksum(arr, hashAlgoSync(arr))
     },
     decodeSync(str, format = 'uint8') {

package/fallback/base64.js

@@ -1,5 +1,4 @@
-import { assertUint8 } from '../assert.js'
-import { nativeEncoder, nativeDecoder } from './_utils.js'
+import { nativeEncoder, nativeDecoder } from './platform.js'
 import { encodeAscii, decodeAscii } from './latin1.js'
 
 // See https://datatracker.ietf.org/doc/html/rfc4648
@@ -15,8 +14,8 @@ 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
+// Expects a checked Uint8Array
 export function toBase64(arr, isURL, padding) {
-  assertUint8(arr)
   const fullChunks = (arr.length / 3) | 0
   const fullChunksBytes = fullChunks * 3
   let o = ''