@exodus/bytes 1.11.0 → 1.13.0

package/fallback/utf16.js

@@ -1,14 +1,81 @@
 import { decodeUCS2, encodeCharcodes } from './latin1.js'
-import { isLE } from './_utils.js'
+import { assertU8, E_STRING, E_STRICT_UNICODE } from './_utils.js'
+import { nativeDecoder, isLE } from './platform.js'
 
 export const E_STRICT = 'Input is not well-formed utf16'
-export const E_STRICT_UNICODE = 'Input is not well-formed Unicode'
+const isWellFormedStr = String.prototype.isWellFormed
+const toWellFormedStr = /* @__PURE__ */ (() => String.prototype.toWellFormed)()
 
 const replacementCodepoint = 0xff_fd
 const replacementCodepointSwapped = 0xfd_ff
 
 const to16 = (a) => new Uint16Array(a.buffer, a.byteOffset, a.byteLength / 2) // Requires checked length and alignment!
 
+export function encodeApi(str, loose, format) {
+  if (typeof str !== 'string') throw new TypeError(E_STRING)
+  if (format !== 'uint16' && format !== 'uint8-le' && format !== 'uint8-be') {
+    throw new TypeError('Unknown format')
+  }
+
+  // On v8 and SpiderMonkey, check via isWellFormed is faster than js
+  // On JSC, check during loop is faster than isWellFormed
+  // If isWellFormed is available, we skip check during decoding and recheck after
+  // If isWellFormed is unavailable, we check in js during decoding
+  if (!loose && isWellFormedStr && !isWellFormedStr.call(str)) throw new TypeError(E_STRICT_UNICODE)
+  const shouldSwap = (isLE && format === 'uint8-be') || (!isLE && format === 'uint8-le')
+  const u16 = encode(str, loose, !loose && isWellFormedStr, shouldSwap)
+
+  // Bytes are already swapped and format is already checked, we need to just cast the view
+  return format === 'uint16' ? u16 : new Uint8Array(u16.buffer, u16.byteOffset, u16.byteLength)
+}
+
+const fatalLE = nativeDecoder ? new TextDecoder('utf-16le', { ignoreBOM: true, fatal: true }) : null
+const looseLE = nativeDecoder ? new TextDecoder('utf-16le', { ignoreBOM: true }) : null
+const fatalBE = nativeDecoder ? new TextDecoder('utf-16be', { ignoreBOM: true, fatal: true }) : null
+const looseBE = nativeDecoder ? new TextDecoder('utf-16be', { ignoreBOM: true }) : null
+
+export function decodeApiDecoders(input, loose, format) {
+  if (format === 'uint16') {
+    if (!(input instanceof Uint16Array)) throw new TypeError('Expected an Uint16Array')
+  } else if (format === 'uint8-le' || format === 'uint8-be') {
+    assertU8(input)
+    if (input.byteLength % 2 !== 0) throw new TypeError('Expected even number of bytes')
+  } else {
+    throw new TypeError('Unknown format')
+  }
+
+  const le = format === 'uint8-le' || (format === 'uint16' && isLE)
+  return (le ? (loose ? looseLE : fatalLE) : loose ? looseBE : fatalBE).decode(input)
+}
+
+export function decodeApiJS(input, loose, format) {
+  let u16
+  switch (format) {
+    case 'uint16':
+      if (!(input instanceof Uint16Array)) throw new TypeError('Expected an Uint16Array')
+      u16 = input
+      break
+    case 'uint8-le':
+      assertU8(input)
+      if (input.byteLength % 2 !== 0) throw new TypeError('Expected even number of bytes')
+      u16 = to16input(input, true)
+      break
+    case 'uint8-be':
+      assertU8(input)
+      if (input.byteLength % 2 !== 0) throw new TypeError('Expected even number of bytes')
+      u16 = to16input(input, false)
+      break
+    default:
+      throw new TypeError('Unknown format')
+  }
+
+  const str = decode(u16, loose, (!loose && isWellFormedStr) || (loose && toWellFormedStr))
+  if (!loose && isWellFormedStr && !isWellFormedStr.call(str)) throw new TypeError(E_STRICT)
+  if (loose && toWellFormedStr) return toWellFormedStr.call(str)
+
+  return str
+}
+
 export function to16input(u8, le) {
   // Assume even number of bytes
   if (le === isLE) return to16(u8.byteOffset % 2 === 0 ? u8 : Uint8Array.from(u8))

package/fallback/utf8.auto.browser.js

@@ -0,0 +1,2 @@
+export const decodeFast = null
+export const encode = null

package/fallback/utf8.auto.js

@@ -0,0 +1 @@
+export { decodeFast, encode } from './utf8.js'

package/fallback/utf8.auto.native.js

@@ -0,0 +1 @@
+export { decodeFast, encode } from './utf8.js'

package/fallback/utf8.js

@@ -1,9 +1,31 @@
-import { encodeAsciiPrefix } from './latin1.js'
+import { E_STRICT_UNICODE } from './_utils.js'
+import { isHermes } from './platform.js'
+import { asciiPrefix, decodeLatin1, encodeAsciiPrefix } from './latin1.js'
 
 export const E_STRICT = 'Input is not well-formed utf8'
-export const E_STRICT_UNICODE = 'Input is not well-formed Unicode'
 
 const replacementPoint = 0xff_fd
+const shouldUseEscapePath = isHermes // faster only on Hermes, js path beats it on normal engines
+const { decodeURIComponent, escape } = globalThis
+
+export function decodeFast(arr, loose) {
+  // Fast path for ASCII prefix, this is faster than all alternatives below
+  const prefix = decodeLatin1(arr, 0, asciiPrefix(arr)) // No native decoder to use, so decodeAscii is useless here
+  if (prefix.length === arr.length) return prefix
+
+  // This codepath gives a ~3x perf boost on Hermes
+  if (shouldUseEscapePath && escape && decodeURIComponent) {
+    const o = escape(decodeLatin1(arr, prefix.length, arr.length))
+    try {
+      return prefix + decodeURIComponent(o) // Latin1 to utf8
+    } catch {
+      if (!loose) throw new TypeError(E_STRICT)
+      // Ok, we have to use manual implementation for loose decoder
+    }
+  }
+
+  return prefix + decode(arr, loose, prefix.length)
+}
 
 // https://encoding.spec.whatwg.org/#utf-8-decoder
 // We are most likely in loose mode, for non-loose escape & decodeURIComponent solved everything
@@ -27,7 +49,7 @@ export function decode(arr, loose, start = 0) {
     const byte = arr[i]
     if (byte < 0x80) {
       tmp[ti++] = byte
-      // ascii fast path is in ../utf8.js, this is called only on non-ascii input
+      // ascii fast path is in decodeFast(), this is called only on non-ascii input
       // so we don't unroll this anymore
     } else if (byte < 0xc2) {
       if (!loose) throw new TypeError(E_STRICT)

package/hex.js

@@ -1,19 +1,17 @@
-import { assertUint8 } from './assert.js'
 import { typedView } from './array.js'
-import { skipWeb } from './fallback/_utils.js'
+import { assertU8 } from './fallback/_utils.js'
 import * as js from './fallback/hex.js'
 
 const { toHex: webHex } = Uint8Array.prototype // Modern engines have this
 
 export function toHex(arr) {
-  assertUint8(arr)
+  assertU8(arr)
   if (arr.length === 0) return ''
-  if (!skipWeb && webHex && arr.toHex === webHex) return arr.toHex()
+  if (webHex && arr.toHex === webHex) return arr.toHex()
   return js.toHex(arr)
 }
 
 // Unlike Buffer.from(), throws on invalid input
-export const fromHex =
-  !skipWeb && Uint8Array.fromHex
-    ? (str, format = 'uint8') => typedView(Uint8Array.fromHex(str), format)
-    : (str, format = 'uint8') => typedView(js.fromHex(str), format)
+export const fromHex = Uint8Array.fromHex
+  ? (str, format = 'uint8') => typedView(Uint8Array.fromHex(str), format)
+  : (str, format = 'uint8') => typedView(js.fromHex(str), format)

package/hex.node.js

@@ -1,6 +1,5 @@
-import { assertUint8 } from './assert.js'
 import { typedView } from './array.js'
-import { E_STRING } from './fallback/_utils.js'
+import { assertU8, E_STRING } from './fallback/_utils.js'
 import { E_HEX } from './fallback/hex.js'
 
 if (Buffer.TYPED_ARRAY_SUPPORT) throw new Error('Unexpected Buffer polyfill')
@@ -9,7 +8,7 @@ const { toHex: webHex } = Uint8Array.prototype // Modern engines have this
 const denoBug = Buffer.from('ag', 'hex').length > 0
 
 export function toHex(arr) {
-  assertUint8(arr)
+  assertU8(arr)
   if (arr.length === 0) return ''
   if (webHex && arr.toHex === webHex) return arr.toHex()
   if (arr.constructor === Buffer && Buffer.isBuffer(arr)) return arr.hexSlice(0, arr.byteLength)

package/multi-byte.js

@@ -1,11 +1,11 @@
-import { assertUint8 } from './assert.js'
+import { assertU8 } from './fallback/_utils.js'
 import { multibyteDecoder, multibyteEncoder } from './fallback/multi-byte.js'
 
 export function createMultibyteDecoder(encoding, loose = false) {
   const jsDecoder = multibyteDecoder(encoding, loose) // asserts
   let streaming = false
   return (arr, stream = false) => {
-    assertUint8(arr)
+    assertU8(arr)
     if (!streaming && arr.byteLength === 0) return ''
     streaming = stream
     return jsDecoder(arr, stream)

package/multi-byte.node.js

@@ -1,5 +1,5 @@
-import { assertUint8 } from './assert.js'
-import { isDeno, toBuf } from './fallback/_utils.js'
+import { assertU8, toBuf } from './fallback/_utils.js'
+import { isDeno } from './fallback/platform.js'
 import { isAsciiSuperset, multibyteDecoder, multibyteEncoder } from './fallback/multi-byte.js'
 import { isAscii } from 'node:buffer'
 
@@ -8,7 +8,7 @@ export function createMultibyteDecoder(encoding, loose = false) {
   let streaming = false
   const asciiSuperset = isAsciiSuperset(encoding)
   return (arr, stream = false) => {
-    assertUint8(arr)
+    assertU8(arr)
     if (!streaming) {
       if (arr.byteLength === 0) return ''
       if (asciiSuperset && isAscii(arr)) {

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@exodus/bytes",
-  "version": "1.11.0",
+  "version": "1.13.0",
   "description": "Various operations on Uint8Array data",
   "keywords": [
     "encoding",
-    "uint8array",
-    "textdecoder",
-    "textencoder",
+    "Uint8Array",
+    "TextDecoder",
+    "TextEncoder",
     "utf8",
     "utf16",
     "hex",
@@ -27,10 +27,14 @@
     "test:spidermonkey": "exodus-test --engine=spidermonkey:bundle",
     "test:hermes": "exodus-test --engine=hermes:bundle",
     "test:quickjs": "exodus-test --engine=quickjs:bundle",
-    "test:xs": "EXODUS_TEST_IGNORE='tests/whatwg.browser.test.js' exodus-test --engine=xs:bundle",
+    "test:xs": "exodus-test --engine=xs:bundle",
     "test:engine262": "exodus-test --engine=engine262:bundle",
+    "test:graaljs": "exodus-test --engine=graaljs:bundle",
+    "test:escargot": "exodus-test --engine=escargot:bundle",
+    "test:boa": "exodus-test --engine=boa:bundle",
     "test:deno": "exodus-test --engine=deno:pure",
     "test:bun": "exodus-test --engine=bun:pure",
+    "test:workerd": "exodus-test --engine=workerd:bundle",
     "test:electron:bundle": "exodus-test --engine=electron:bundle",
     "test:electron:as-node": "exodus-test --engine=electron-as-node:test",
     "test:chrome:puppeteer": "exodus-test --engine=chrome:puppeteer",
@@ -72,6 +76,9 @@
     "/fallback/hex.js",
     "/fallback/latin1.js",
     "/fallback/percent.js",
+    "/fallback/platform.js",
+    "/fallback/platform.browser.js",
+    "/fallback/platform.native.js",
     "/fallback/multi-byte.encodings.cjs",
     "/fallback/multi-byte.encodings.json",
     "/fallback/multi-byte.js",
@@ -80,6 +87,9 @@
     "/fallback/single-byte.js",
     "/fallback/utf16.js",
     "/fallback/utf8.js",
+    "/fallback/utf8.auto.js",
+    "/fallback/utf8.auto.browser.js",
+    "/fallback/utf8.auto.native.js",
     "/array.js",
     "/array.d.ts",
     "/assert.js",
@@ -117,6 +127,8 @@
     "/single-byte.node.js",
     "/utf16.js",
     "/utf16.d.ts",
+    "/utf16.browser.js",
+    "/utf16.native.js",
     "/utf16.node.js",
     "/utf8.js",
     "/utf8.d.ts",
@@ -196,6 +208,8 @@
     "./utf16.js": {
       "types": "./utf16.d.ts",
       "node": "./utf16.node.js",
+      "react-native": "./utf16.native.js",
+      "browser": "./utf16.browser.js",
       "default": "./utf16.js"
     },
     "./utf8.js": {
@@ -212,8 +226,16 @@
       "default": "./wif.js"
     }
   },
+  "browser": {
+    "./utf16.js": "./utf16.browser.js",
+    "./fallback/platform.js": "./fallback/platform.browser.js",
+    "./fallback/utf8.auto.js": "./fallback/utf8.auto.browser.js"
+  },
   "react-native": {
-    "./encoding-browser.js": "./encoding-browser.native.js"
+    "./encoding-browser.js": "./encoding-browser.native.js",
+    "./utf16.js": "./utf16.native.js",
+    "./fallback/platform.js": "./fallback/platform.native.js",
+    "./fallback/utf8.auto.js": "./fallback/utf8.auto.native.js"
   },
   "peerDependencies": {
     "@noble/hashes": "^1.8.0 || ^2.0.0"
@@ -228,7 +250,7 @@
     "@exodus/crypto": "^1.0.0-rc.30",
     "@exodus/eslint-config": "^5.24.0",
     "@exodus/prettier": "^1.0.0",
-    "@exodus/test": "^1.0.0-rc.109",
+    "@exodus/test": "1.0.0-rc.115",
     "@hexagon/base64": "^2.0.4",
     "@noble/hashes": "^2.0.1",
     "@oslojs/encoding": "^1.1.0",
@@ -250,7 +272,7 @@
     "decode-utf8": "^1.0.1",
     "electron": "36.5.0",
     "encode-utf8": "^2.0.0",
-    "esbuild": "^0.27.2",
+    "esbuild": "^0.27.3",
     "eslint": "^8.44.0",
     "fast-base64-decode": "^2.0.0",
     "fast-base64-encode": "^1.0.0",
@@ -265,7 +287,8 @@
     "uint8array-tools": "^0.0.9",
     "utf8": "^3.0.0",
     "web-streams-polyfill": "^4.2.0",
-    "wif": "^5.0.0"
+    "wif": "^5.0.0",
+    "workerd": "^1.20260206.0"
   },
   "prettier": "@exodus/prettier",
   "packageManager": "pnpm@10.12.1+sha256.889bac470ec93ccc3764488a19d6ba8f9c648ad5e50a9a6e4be3768a5de387a3"

package/single-byte.js

@@ -1,5 +1,5 @@
-import { assertUint8 } from './assert.js'
-import { canDecoders, nativeEncoder, skipWeb, E_STRING } from './fallback/_utils.js'
+import { assertU8, E_STRING } from './fallback/_utils.js'
+import { nativeDecoderLatin1, nativeEncoder } from './fallback/platform.js'
 import { encodeAscii, encodeAsciiPrefix, encodeLatin1 } from './fallback/latin1.js'
 import { assertEncoding, encodingDecoder, encodeMap, E_STRICT } from './fallback/single-byte.js'
 
@@ -39,12 +39,12 @@ export function createSinglebyteDecoder(encoding, loose = false) {
   if (typeof loose !== 'boolean') throw new TypeError('loose option should be boolean')
   assertEncoding(encoding)
 
-  if (canDecoders && shouldUseNative(encoding)) {
+  if (nativeDecoderLatin1 && shouldUseNative(encoding)) {
     // In try, as not all encodings might be implemented in all engines which have native TextDecoder
     try {
       const decoder = new TextDecoder(encoding, { fatal: !loose })
       return (arr) => {
-        assertUint8(arr)
+        assertU8(arr)
         if (arr.byteLength === 0) return ''
         return decoder.decode(arr)
       }
@@ -53,7 +53,7 @@ export function createSinglebyteDecoder(encoding, loose = false) {
 
   const jsDecoder = encodingDecoder(encoding)
   return (arr) => {
-    assertUint8(arr)
+    assertU8(arr)
     if (arr.byteLength === 0) return ''
     return jsDecoder(arr, loose)
   }
@@ -88,7 +88,7 @@ function encode(s, m) {
 }
 
 // fromBase64+btoa path is faster on everything where fromBase64 is fast
-const useLatin1btoa = Uint8Array.fromBase64 && btoa && !skipWeb
+const useLatin1btoa = Uint8Array.fromBase64 && btoa
 
 export function createSinglebyteEncoder(encoding, { mode = 'fatal' } = {}) {
   // TODO: replacement, truncate (replacement will need varying length)

package/single-byte.node.js

@@ -1,6 +1,6 @@
-import { assertUint8 } from './assert.js'
 import { isAscii } from 'node:buffer'
-import { isDeno, isLE, toBuf, E_STRING } from './fallback/_utils.js'
+import { assertU8, toBuf, E_STRING } from './fallback/_utils.js'
+import { isDeno, isLE } from './fallback/platform.js'
 import { asciiPrefix } from './fallback/latin1.js'
 import { encodingMapper, encodingDecoder, encodeMap, E_STRICT } from './fallback/single-byte.js'
 
@@ -26,7 +26,7 @@ export function createSinglebyteDecoder(encoding, loose = false) {
   if (isDeno) {
     const jsDecoder = encodingDecoder(encoding) // asserts
     return (arr) => {
-      assertUint8(arr)
+      assertU8(arr)
       if (arr.byteLength === 0) return ''
       if (isAscii(arr)) return toBuf(arr).toString()
       return jsDecoder(arr, loose) // somewhy faster on Deno anyway, TODO: optimize?
@@ -37,7 +37,7 @@ export function createSinglebyteDecoder(encoding, loose = false) {
   const latin1path = encoding === 'windows-1252'
   const { incomplete, mapper } = encodingMapper(encoding) // asserts
   return (arr) => {
-    assertUint8(arr)
+    assertU8(arr)
     if (arr.byteLength === 0) return ''
     if (isLatin1 || isAscii(arr)) return toBuf(arr).latin1Slice() // .latin1Slice is faster than .asciiSlice
 

package/utf16.browser.js

@@ -0,0 +1,8 @@
+// We trust browsers to always have correct TextDecoder for utf-16le/utf-16be with ignoreBOM without streaming
+
+import { encodeApi, decodeApiDecoders } from './fallback/utf16.js'
+
+export const utf16fromString = (str, format = 'uint16') => encodeApi(str, false, format)
+export const utf16fromStringLoose = (str, format = 'uint16') => encodeApi(str, true, format)
+export const utf16toString = (arr, format = 'uint16') => decodeApiDecoders(arr, false, format)
+export const utf16toStringLoose = (arr, format = 'uint16') => decodeApiDecoders(arr, true, format)

package/utf16.js

@@ -1,75 +1 @@
-import * as js from './fallback/utf16.js'
-import { canDecoders, isLE, E_STRING } from './fallback/_utils.js'
-
-const { TextDecoder } = globalThis // Buffer is optional
-const ignoreBOM = true
-const decoderFatalLE = canDecoders ? new TextDecoder('utf-16le', { ignoreBOM, fatal: true }) : null
-const decoderLooseLE = canDecoders ? new TextDecoder('utf-16le', { ignoreBOM }) : null
-const decoderFatalBE = canDecoders ? new TextDecoder('utf-16be', { ignoreBOM, fatal: true }) : null
-const decoderLooseBE = canDecoders ? new TextDecoder('utf-16be', { ignoreBOM }) : null
-const decoderFatal16 = isLE ? decoderFatalLE : decoderFatalBE
-const decoderLoose16 = isLE ? decoderLooseLE : decoderLooseBE
-const { isWellFormed, toWellFormed } = String.prototype
-
-const { E_STRICT, E_STRICT_UNICODE } = js
-
-// Unlike utf8, operates on Uint16Arrays by default
-
-const to8 = (a) => new Uint8Array(a.buffer, a.byteOffset, a.byteLength)
-
-function encode(str, loose = false, format = 'uint16') {
-  if (typeof str !== 'string') throw new TypeError(E_STRING)
-  if (format !== 'uint16' && format !== 'uint8-le' && format !== 'uint8-be') {
-    throw new TypeError('Unknown format')
-  }
-
-  const shouldSwap = (isLE && format === 'uint8-be') || (!isLE && format === 'uint8-le')
-
-  // On v8 and SpiderMonkey, check via isWellFormed is faster than js
-  // On JSC, check during loop is faster than isWellFormed
-  // If isWellFormed is available, we skip check during decoding and recheck after
-  // If isWellFormed is unavailable, we check in js during decoding
-  if (!loose && isWellFormed && !isWellFormed.call(str)) throw new TypeError(E_STRICT_UNICODE)
-  const u16 = js.encode(str, loose, !loose && isWellFormed, shouldSwap)
-
-  if (format === 'uint8-le' || format === 'uint8-be') return to8(u16) // Already swapped
-  if (format === 'uint16') return u16
-  /* c8 ignore next */
-  throw new Error('Unreachable')
-}
-
-function decode(input, loose = false, format = 'uint16') {
-  let u16
-  switch (format) {
-    case 'uint16':
-      if (!(input instanceof Uint16Array)) throw new TypeError('Expected an Uint16Array')
-      if (canDecoders) return loose ? decoderLoose16.decode(input) : decoderFatal16.decode(input)
-      u16 = input
-      break
-    case 'uint8-le':
-      if (!(input instanceof Uint8Array)) throw new TypeError('Expected an Uint8Array')
-      if (input.byteLength % 2 !== 0) throw new TypeError('Expected even number of bytes')
-      if (canDecoders) return loose ? decoderLooseLE.decode(input) : decoderFatalLE.decode(input)
-      u16 = js.to16input(input, true)
-      break
-    case 'uint8-be':
-      if (!(input instanceof Uint8Array)) throw new TypeError('Expected an Uint8Array')
-      if (input.byteLength % 2 !== 0) throw new TypeError('Expected even number of bytes')
-      if (canDecoders) return loose ? decoderLooseBE.decode(input) : decoderFatalBE.decode(input)
-      u16 = js.to16input(input, false)
-      break
-    default:
-      throw new TypeError('Unknown format')
-  }
-
-  const str = js.decode(u16, loose, (!loose && isWellFormed) || (loose && toWellFormed))
-  if (!loose && isWellFormed && !isWellFormed.call(str)) throw new TypeError(E_STRICT)
-  if (loose && toWellFormed) return toWellFormed.call(str)
-
-  return str
-}
-
-export const utf16fromString = (str, format = 'uint16') => encode(str, false, format)
-export const utf16fromStringLoose = (str, format = 'uint16') => encode(str, true, format)
-export const utf16toString = (arr, format = 'uint16') => decode(arr, false, format)
-export const utf16toStringLoose = (arr, format = 'uint16') => decode(arr, true, format)
+export * from './utf16.native.js'

package/utf16.native.js

@@ -0,0 +1,22 @@
+import { encodeApi, decodeApiDecoders, decodeApiJS } from './fallback/utf16.js'
+import { nativeDecoder } from './fallback/platform.native.js'
+
+function checkDecoders() {
+  // Not all barebone engines with TextDecoder support something except utf-8
+  // Also workerd specifically has a broken utf-16le implementation
+  if (!nativeDecoder) return false
+  try {
+    const a = new TextDecoder('utf-16le').decode(Uint8Array.of(1, 2, 3, 0xd8))
+    const b = new TextDecoder('utf-16be').decode(Uint8Array.of(2, 1, 0xd8, 3))
+    return a === b && a === '\u0201\uFFFD'
+  } catch {}
+
+  return false
+}
+
+const decode = checkDecoders() ? decodeApiDecoders : decodeApiJS
+
+export const utf16fromString = (str, format = 'uint16') => encodeApi(str, false, format)
+export const utf16fromStringLoose = (str, format = 'uint16') => encodeApi(str, true, format)
+export const utf16toString = (arr, format = 'uint16') => decode(arr, false, format)
+export const utf16toStringLoose = (arr, format = 'uint16') => decode(arr, true, format)

package/utf16.node.js

@@ -1,5 +1,6 @@
-import { isDeno, isLE, E_STRING } from './fallback/_utils.js'
-import { E_STRICT, E_STRICT_UNICODE } from './fallback/utf16.js'
+import { assertU8, E_STRING, E_STRICT_UNICODE } from './fallback/_utils.js'
+import { isDeno, isLE } from './fallback/platform.js'
+import { E_STRICT, decodeApiDecoders } from './fallback/utf16.js'
 
 if (Buffer.TYPED_ARRAY_SUPPORT) throw new Error('Unexpected Buffer polyfill')
 
@@ -48,7 +49,7 @@ function decodeNode(input, loose = false, format = 'uint16') {
     if (!(input instanceof Uint16Array)) throw new TypeError('Expected an Uint16Array')
     ble = swapped(input, !isLE)
   } else if (format === 'uint8-le' || format === 'uint8-be') {
-    if (!(input instanceof Uint8Array)) throw new TypeError('Expected an Uint8Array')
+    assertU8(input)
     if (input.byteLength % 2 !== 0) throw new TypeError('Expected even number of bytes')
     ble = swapped(input, format === 'uint8-be')
   } else {
@@ -61,23 +62,7 @@ function decodeNode(input, loose = false, format = 'uint16') {
   throw new TypeError(E_STRICT)
 }
 
-function decodeDecoder(input, loose = false, format = 'uint16') {
-  let encoding
-  if (format === 'uint16') {
-    if (!(input instanceof Uint16Array)) throw new TypeError('Expected an Uint16Array')
-    encoding = isLE ? 'utf-16le' : 'utf-16be'
-  } else if (format === 'uint8-le' || format === 'uint8-be') {
-    if (!(input instanceof Uint8Array)) throw new TypeError('Expected an Uint8Array')
-    if (input.byteLength % 2 !== 0) throw new TypeError('Expected even number of bytes')
-    encoding = format === 'uint8-le' ? 'utf-16le' : 'utf-16be'
-  } else {
-    throw new TypeError('Unknown format')
-  }
-
-  return new TextDecoder(encoding, { ignoreBOM: true, fatal: !loose }).decode(input) // TODO: cache decoder?
-}
-
-const decode = isDeno ? decodeDecoder : decodeNode
+const decode = isDeno ? decodeApiDecoders : decodeNode
 
 export const utf16fromString = (str, format = 'uint16') => encode(str, false, format)
 export const utf16fromStringLoose = (str, format = 'uint16') => encode(str, true, format)

package/utf8.js

@@ -1,10 +1,8 @@
-import { assertUint8 } from './assert.js'
 import { typedView } from './array.js'
-import { isHermes, nativeDecoder, nativeEncoder, E_STRING } from './fallback/_utils.js'
-import { asciiPrefix, decodeLatin1 } from './fallback/latin1.js'
-import * as js from './fallback/utf8.js'
+import { assertU8, E_STRING, E_STRICT_UNICODE } from './fallback/_utils.js'
+import { nativeDecoder, nativeEncoder } from './fallback/platform.js'
+import * as js from './fallback/utf8.auto.js'
 
-const { TextDecoder, decodeURIComponent, escape } = globalThis // Buffer is optional
 // ignoreBOM: true means that BOM will be left as-is, i.e. will be present in the output
 // We don't want to strip anything unexpectedly
 const decoderLoose = nativeDecoder
@@ -13,10 +11,6 @@ const decoderFatal = nativeDecoder
   : null
 const { isWellFormed } = String.prototype
 
-const { E_STRICT, E_STRICT_UNICODE } = js
-
-const shouldUseEscapePath = isHermes // faster only on Hermes, js path beats it on normal engines
-
 function deLoose(str, loose, res) {
   if (loose || str.length === res.length) return res // length is equal only for ascii, which is automatically fine
   if (isWellFormed) {
@@ -35,7 +29,7 @@ function deLoose(str, loose, res) {
     start = pos + 1
     if (res[pos + 1] === 0xbf && res[pos + 2] === 0xbd) {
       // Found a replacement char in output, need to recheck if we encoded the input correctly
-      if (!nativeDecoder && str.length < 1e7) {
+      if (js.decodeFast && !nativeDecoder && str.length < 1e7) {
         // This is ~2x faster than decode in Hermes
         try {
           if (encodeURI(str) !== null) return res // guard against optimizing out
@@ -51,32 +45,19 @@ function deLoose(str, loose, res) {
 function encode(str, loose = false) {
   if (typeof str !== 'string') throw new TypeError(E_STRING)
   if (str.length === 0) return new Uint8Array() // faster than Uint8Array.of
-  if (nativeEncoder) return deLoose(str, loose, nativeEncoder.encode(str))
+  if (nativeEncoder || !js.encode) return deLoose(str, loose, nativeEncoder.encode(str))
   // No reason to use unescape + encodeURIComponent: it's slower than JS on normal engines, and modern Hermes already has TextEncoder
   return js.encode(str, loose)
 }
 
 function decode(arr, loose = false) {
-  assertUint8(arr)
+  assertU8(arr)
   if (arr.byteLength === 0) return ''
-  if (nativeDecoder) return loose ? decoderLoose.decode(arr) : decoderFatal.decode(arr) // Node.js and browsers
-
-  // Fast path for ASCII prefix, this is faster than all alternatives below
-  const prefix = decodeLatin1(arr, 0, asciiPrefix(arr)) // No native decoder to use, so decodeAscii is useless here
-  if (prefix.length === arr.length) return prefix
-
-  // This codepath gives a ~3x perf boost on Hermes
-  if (shouldUseEscapePath && escape && decodeURIComponent) {
-    const o = escape(decodeLatin1(arr, prefix.length, arr.length))
-    try {
-      return prefix + decodeURIComponent(o) // Latin1 to utf8
-    } catch {
-      if (!loose) throw new TypeError(E_STRICT)
-      // Ok, we have to use manual implementation for loose decoder
-    }
+  if (nativeDecoder || !js.decodeFast) {
+    return loose ? decoderLoose.decode(arr) : decoderFatal.decode(arr) // Node.js and browsers
   }
 
-  return prefix + js.decode(arr, loose, prefix.length)
+  return js.decodeFast(arr, loose)
 }
 
 export const utf8fromString = (str, format = 'uint8') => typedView(encode(str, false), format)

package/utf8.node.js

@@ -1,7 +1,6 @@
-import { assertUint8 } from './assert.js'
 import { typedView } from './array.js'
-import { E_STRING } from './fallback/_utils.js'
-import { E_STRICT, E_STRICT_UNICODE } from './fallback/utf8.js'
+import { assertU8, E_STRING, E_STRICT_UNICODE } from './fallback/_utils.js'
+import { E_STRICT } from './fallback/utf8.js'
 import { isAscii } from 'node:buffer'
 
 if (Buffer.TYPED_ARRAY_SUPPORT) throw new Error('Unexpected Buffer polyfill')
@@ -40,7 +39,7 @@ function encode(str, loose = false) {
 }
 
 function decode(arr, loose = false) {
-  assertUint8(arr)
+  assertU8(arr)
   const byteLength = arr.byteLength
   if (byteLength === 0) return ''
   if (byteLength > 0x6_00 && !(isDeno && loose) && isAscii(arr)) {