@exodus/bytes 1.14.1 → 1.15.0

package/base64.js

@@ -1,6 +1,5 @@
 import { assertEmptyRest } from './assert.js'
-import { typedView } from './array.js'
-import { assertU8, E_STRING } from './fallback/_utils.js'
+import { assertU8, fromUint8, fromBuffer, 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'
@@ -96,7 +95,7 @@ function fromBase64common(str, isBase64url, padding, format, rest) {
     throw new TypeError('Invalid padding option')
   }
 
-  return typedView(fromBase64impl(str, isBase64url, padding), format)
+  return fromBase64impl(str, isBase64url, padding, format)
 }
 
 // ASCII whitespace is U+0009 TAB, U+000A LF, U+000C FF, U+000D CR, or U+0020 SPACE
@@ -114,7 +113,7 @@ function noWhitespaceSeen(str, arr) {
 let fromBase64impl
 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) => {
+  fromBase64impl = (str, isBase64url, padding, format) => {
     const alphabet = isBase64url ? 'base64url' : 'base64'
 
     let arr
@@ -136,20 +135,22 @@ if (Uint8Array.fromBase64) {
     // We don't allow whitespace in input, but that can be rechecked based on output length
     // All other chars are checked natively
     if (!noWhitespaceSeen(str, arr)) throw new SyntaxError(E_CHAR)
-    return arr
+    return fromUint8(arr, format)
   }
 } else if (haveNativeBuffer) {
-  fromBase64impl = (str, isBase64url, padding) => {
-    const arr = Buffer.from(str, 'base64')
+  fromBase64impl = (str, isBase64url, padding, format) => {
+    const size = Buffer.byteLength(str, 'base64')
+    const arr = Buffer.allocUnsafeSlow(size) // non-pooled
+    if (arr.base64Write(str) !== size) throw new SyntaxError(E_PADDING)
     // Rechecking by re-encoding is cheaper than regexes on Node.js
     const got = isBase64url ? maybeUnpad(str, padding === false) : maybePad(str, padding !== true)
     const valid = isBase64url ? arr.base64urlSlice(0, arr.length) : arr.base64Slice(0, arr.length)
     if (got !== valid) throw new SyntaxError(E_PADDING)
-    return arr // fully checked
+    return fromBuffer(arr, format) // fully checked
   }
 } else if (shouldUseAtob) {
   // atob is faster than manual parsing on Hermes
-  fromBase64impl = (str, isBase64url, padding) => {
+  fromBase64impl = (str, isBase64url, padding, format) => {
     let arr
     if (isBase64url) {
       if (/[\t\n\f\r +/]/.test(str)) throw new SyntaxError(E_CHAR) // atob verifies other invalid input
@@ -171,8 +172,9 @@ if (Uint8Array.fromBase64) {
       if (expected !== end) throw new SyntaxError(E_LAST)
     }
 
-    return arr
+    return fromUint8(arr, format)
   }
 } else {
-  fromBase64impl = (str, isBase64url, padding) => js.fromBase64(str, isBase64url) // validated in js
+  fromBase64impl = (str, isBase64url, padding, format) =>
+    fromUint8(js.fromBase64(str, isBase64url), format) // validated in js
 }

package/bigint.d.ts

@@ -34,8 +34,9 @@ export interface FromBigIntOptions {
  * @returns The converted bytes in big-endian format
  */
 export function fromBigInt(bigint: bigint, options: { length: number; format?: 'uint8' }): Uint8ArrayBuffer;
+export function fromBigInt(bigint: bigint, options: { length: number; format: 'arraybuffer' }): ArrayBuffer;
 export function fromBigInt(bigint: bigint, options: { length: number; format: 'buffer' }): Buffer;
-export function fromBigInt(bigint: bigint, options: FromBigIntOptions): Uint8ArrayBuffer | Buffer;
+export function fromBigInt(bigint: bigint, options: FromBigIntOptions): Uint8ArrayBuffer | ArrayBuffer | Buffer;
 
 /**
  * Convert a Uint8Array or Buffer to a BigInt

package/encoding-browser.d.ts

@@ -2,6 +2,8 @@
  * 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).
  *
+ * Does not provide `isomorphicDecode` and `isomorphicEncode` exports.
+ *
  * ```js
  * import { TextDecoder, TextEncoder } from '@exodus/bytes/encoding-browser.js'
  * import { TextDecoderStream, TextEncoderStream } from '@exodus/bytes/encoding-browser.js' // Requires Streams
@@ -21,4 +23,13 @@
  * @module @exodus/bytes/encoding-browser.js
  */
 
-export * from './encoding.js'
+export {
+  TextDecoder,
+  TextEncoder,
+  TextDecoderStream,
+  TextEncoderStream,
+  normalizeEncoding,
+  getBOMEncoding,
+  labelToName,
+  legacyHookDecode,
+} from './encoding.js'

package/encoding-browser.js

@@ -1 +1 @@
-export * from './encoding.js'
+export * from './encoding-browser.native.js'

package/encoding-browser.native.js

@@ -1 +1,10 @@
-export * from './encoding.js'
+export {
+  TextDecoder,
+  TextEncoder,
+  TextDecoderStream,
+  TextEncoderStream,
+  normalizeEncoding,
+  getBOMEncoding,
+  labelToName,
+  legacyHookDecode,
+} from './encoding.js'

package/encoding-lite.d.ts

@@ -1,11 +1,12 @@
 /**
  * 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'
  * import { TextDecoderStream, TextEncoderStream } from '@exodus/bytes/encoding-lite.js' // Requires Streams
+ * import { isomorphicDecode, isomorphicEncode } from '@exodus/bytes/encoding-lite.js'
  *
  * // Hooks for standards
  * import { getBOMEncoding, legacyHookDecode, labelToName, normalizeEncoding } from '@exodus/bytes/encoding-lite.js'

package/encoding-lite.js

@@ -7,4 +7,6 @@ export {
   getBOMEncoding,
   labelToName,
   legacyHookDecode,
+  isomorphicDecode,
+  isomorphicEncode,
 } from './fallback/encoding.js'

package/encoding.d.ts

@@ -9,6 +9,7 @@
  * ```js
  * import { TextDecoder, TextEncoder } from '@exodus/bytes/encoding.js'
  * import { TextDecoderStream, TextEncoderStream } from '@exodus/bytes/encoding.js' // Requires Streams
+ * import { isomorphicDecode, isomorphicEncode } from '@exodus/bytes/encoding.js'
  *
  * // Hooks for standards
  * import { getBOMEncoding, legacyHookDecode, labelToName, normalizeEncoding } from '@exodus/bytes/encoding.js'
@@ -90,6 +91,34 @@ export function legacyHookDecode(
   fallbackEncoding?: string
 ): string;
 
+/**
+ * Implements [isomorphic decode](https://infra.spec.whatwg.org/#isomorphic-decode).
+ *
+ * Given a `TypedArray` or an `ArrayBuffer` instance `input`, creates a string of the same length
+ * as input byteLength, using bytes from input as codepoints.
+ *
+ * E.g. for `Uint8Array` input, this is similar to `String.fromCodePoint(...input)`.
+ *
+ * Wider `TypedArray` inputs, e.g. `Uint16Array`, are interpreted as underlying _bytes_.
+ *
+ * @param input - The bytes to decode
+ * @returns The decoded string
+ */
+export function isomorphicDecode(input: ArrayBufferLike | ArrayBufferView): string;
+
+/**
+ * Implements [isomorphic encode](https://infra.spec.whatwg.org/#isomorphic-encode).
+ *
+ * Given a string, creates an `Uint8Array` of the same length with the string codepoints as byte values.
+ *
+ * Accepts only [isomorphic string](https://infra.spec.whatwg.org/#isomorphic-string) input
+ * and asserts that, throwing on any strings containing codepoints higher than `U+00FF`.
+ *
+ * @param input - The bytes to decode
+ * @returns An Uint8Array containing the input bytes.
+ */
+export function isomorphicEncode(str: string): Uint8Array;
+
 /**
  * Implements [get an encoding from a string `label`](https://encoding.spec.whatwg.org/#concept-encoding-get).
  *

package/encoding.js

@@ -13,4 +13,6 @@ export {
   getBOMEncoding,
   labelToName,
   legacyHookDecode,
+  isomorphicDecode,
+  isomorphicEncode,
 } from './fallback/encoding.js'

package/fallback/_utils.js

@@ -18,3 +18,40 @@ export const toBuf = (x) =>
 
 export const E_STRING = 'Input is not a string'
 export const E_STRICT_UNICODE = 'Input is not well-formed Unicode'
+
+// Input is never pooled
+export function fromUint8(arr, format) {
+  switch (format) {
+    case 'uint8':
+      if (arr.constructor !== Uint8Array) throw new Error('Unexpected')
+      return arr
+    case 'arraybuffer':
+      if (arr.byteLength !== arr.buffer.byteLength) throw new Error('Unexpected')
+      return arr.buffer
+    case 'buffer':
+      if (arr.length <= 64) return Buffer.from(arr)
+      return Buffer.from(arr.buffer, arr.byteOffset, arr.byteLength)
+  }
+
+  throw new TypeError('Unexpected format')
+}
+
+// Input can be pooled
+export function fromBuffer(arr, format) {
+  switch (format) {
+    case 'uint8':
+      // byteOffset check is slightly faster and covers most pooling, so it comes first
+      if (arr.length <= 64 || arr.byteOffset !== 0 || arr.byteLength !== arr.buffer.byteLength) {
+        return new Uint8Array(arr)
+      }
+
+      return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength)
+    case 'arraybuffer':
+      return fromBuffer(arr, 'uint8').buffer
+    case 'buffer':
+      if (arr.constructor !== Buffer) throw new Error('Unexpected')
+      return arr
+  }
+
+  throw new TypeError('Unexpected format')
+}

package/fallback/base32.js

@@ -4,10 +4,12 @@ import { encodeAscii, decodeAscii } from './latin1.js'
 
 // See https://datatracker.ietf.org/doc/html/rfc4648
 
-const BASE32 = [...'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'] // RFC 4648, #6
-const BASE32HEX = [...'0123456789ABCDEFGHIJKLMNOPQRSTUV'] // RFC 4648, #7
-const BASE32_HELPERS = {}
-const BASE32HEX_HELPERS = {}
+const BASE32_HELPERS = [{}, {}, {}]
+const BASE32_ALPHABETS = [
+  [...'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'], // RFC 4648, #6
+  [...'0123456789ABCDEFGHIJKLMNOPQRSTUV'], // RFC 4648, #7
+  [...'0123456789ABCDEFGHJKMNPQRSTVWXYZ'], // Crockford, base (see extra below in fromMap)
+]
 
 export const E_CHAR = 'Invalid character in base32 input'
 export const E_PADDING = 'Invalid base32 padding'
@@ -17,15 +19,15 @@ export const E_LAST = 'Invalid last chunk'
 const useTemplates = isHermes // Faster on Hermes and JSC, but we use it only on Hermes
 
 // We construct output by concatenating chars, this seems to be fine enough on modern JS engines
-export function toBase32(arr, isBase32Hex, padding) {
+export function toBase32(arr, mode, padding) {
   assertU8(arr)
   const fullChunks = Math.floor(arr.length / 5)
   const fullChunksBytes = fullChunks * 5
   let o = ''
   let i = 0
 
-  const alphabet = isBase32Hex ? BASE32HEX : BASE32
-  const helpers = isBase32Hex ? BASE32HEX_HELPERS : BASE32_HELPERS
+  const alphabet = BASE32_ALPHABETS[mode]
+  const helpers = BASE32_HELPERS[mode]
   if (!helpers.pairs) {
     helpers.pairs = []
     if (nativeDecoder) {
@@ -125,7 +127,7 @@ export function toBase32(arr, isBase32Hex, padding) {
 // TODO: can this be optimized? This only affects non-Hermes barebone engines though
 const mapSize = nativeEncoder ? 128 : 65_536 // we have to store 64 KiB map or recheck everything if we can't decode to byte array
 
-export function fromBase32(str, isBase32Hex) {
+export function fromBase32(str, mode) {
   let inputLength = str.length
   while (str[inputLength - 1] === '=') inputLength--
   const paddingLength = str.length - inputLength
@@ -136,14 +138,21 @@ export function fromBase32(str, isBase32Hex) {
     throw new SyntaxError(E_PADDING)
   }
 
-  const alphabet = isBase32Hex ? BASE32HEX : BASE32
-  const helpers = isBase32Hex ? BASE32HEX_HELPERS : BASE32_HELPERS
+  const alphabet = BASE32_ALPHABETS[mode]
+  const helpers = BASE32_HELPERS[mode]
 
   if (!helpers.fromMap) {
     helpers.fromMap = new Int8Array(mapSize).fill(-1) // no regex input validation here, so we map all other bytes to -1 and recheck sign
+    const m = helpers.fromMap
     alphabet.forEach((c, i) => {
-      helpers.fromMap[c.charCodeAt(0)] = helpers.fromMap[c.toLowerCase().charCodeAt(0)] = i
+      m[c.charCodeAt(0)] = m[c.toLowerCase().charCodeAt(0)] = i
     })
+
+    if (mode === 2) {
+      // Extra Crockford mapping
+      m[73] = m[76] = m[105] = m[108] = m[49] // ILil -> 1
+      m[79] = m[111] = m[48] // Oo -> 0
+    }
   }
 
   const m = helpers.fromMap

package/fallback/base58check.js

@@ -1,6 +1,5 @@
-import { typedView } from '@exodus/bytes/array.js'
 import { toBase58, fromBase58 } from '@exodus/bytes/base58.js'
-import { assertU8 } from './_utils.js'
+import { assertU8, fromUint8 } from './_utils.js'
 
 const E_CHECKSUM = 'Invalid checksum'
 
@@ -10,7 +9,7 @@ function encodeWithChecksum(arr, checksum) {
   // arr type in already validated in input
   const res = new Uint8Array(arr.length + 4)
   res.set(arr, 0)
-  res.set(checksum.subarray(0, 4), arr.length)
+  res.set(checksum.slice(0, 4), arr.length)
   return toBase58(res)
 }
 
@@ -18,7 +17,7 @@ function decodeWithChecksum(str) {
   const arr = fromBase58(str) // checks input
   const payloadSize = arr.length - 4
   if (payloadSize < 0) throw new Error(E_CHECKSUM)
-  return [arr.subarray(0, payloadSize), arr.subarray(payloadSize)]
+  return [arr.slice(0, payloadSize), arr.slice(payloadSize)]
 }
 
 function assertChecksum(c, r) {
@@ -34,7 +33,7 @@ export const makeBase58check = (hashAlgo, hashAlgoSync) => {
     async decode(str, format = 'uint8') {
       const [payload, checksum] = decodeWithChecksum(str)
       assertChecksum(checksum, await hashAlgo(payload))
-      return typedView(payload, format)
+      return fromUint8(payload, format)
     },
   }
   if (!hashAlgoSync) return apis
@@ -47,7 +46,7 @@ export const makeBase58check = (hashAlgo, hashAlgoSync) => {
     decodeSync(str, format = 'uint8') {
       const [payload, checksum] = decodeWithChecksum(str)
       assertChecksum(checksum, hashAlgoSync(payload))
-      return typedView(payload, format)
+      return fromUint8(payload, format)
     },
   }
 }

package/fallback/encoding.js

@@ -3,7 +3,11 @@
 
 import { utf16toString, utf16toStringLoose } from '@exodus/bytes/utf16.js'
 import { utf8fromStringLoose, utf8toString, utf8toStringLoose } from '@exodus/bytes/utf8.js'
-import { createSinglebyteDecoder } from '@exodus/bytes/single-byte.js'
+import {
+  createSinglebyteDecoder,
+  latin1toString,
+  latin1fromString,
+} from '@exodus/bytes/single-byte.js'
 import labels from './encoding.labels.js'
 import { fromSource, getBOMEncoding } from './encoding.api.js'
 import { unfinishedBytes, mergePrefix } from './encoding.util.js'
@@ -210,9 +214,7 @@ export class TextEncoder {
 
   encode(str = '') {
     if (typeof str !== 'string') str = `${str}`
-    const res = utf8fromStringLoose(str)
-    // match new Uint8Array (per spec), which is non-pooled
-    return res.byteOffset === 0 && res.length === res.buffer.byteLength ? res : res.slice(0)
+    return utf8fromStringLoose(str) // non-pooled
   }
 
   encodeInto(str, target) {
@@ -357,3 +359,11 @@ export function legacyHookDecode(input, fallbackEncoding = 'utf-8') {
 
   return createSinglebyteDecoder(enc, true)(u8)
 }
+
+export function isomorphicDecode(input) {
+  return latin1toString(fromSource(input))
+}
+
+export function isomorphicEncode(str) {
+  return latin1fromString(str)
+}

package/fallback/encoding.util.js

@@ -36,27 +36,28 @@ export function unfinishedBytes(u, len, enc) {
 // otherwise returns a prefix with no unfinished bytes
 export function mergePrefix(u, chunk, enc) {
   if (u.length === 0) return chunk
+  const cl = chunk.length
   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 + chunk.length)
+    const a = new Uint8Array(cl + u.length)
     a.set(chunk)
-    a.set(u, chunk.length)
+    a.set(u, cl)
     return a
   }
 
   // Slice off a small portion of u into prefix chunk so we can decode them separately without extending array size
-  const t = new Uint8Array(chunk.length + 3) // We have 1-3 bytes and need 1-3 more bytes
+  const t = new Uint8Array(cl + 3) // We have 1-3 bytes and need 1-3 more bytes
   t.set(chunk)
-  t.set(u.subarray(0, 3), chunk.length)
+  t.set(u.subarray(0, 3), cl)
 
   // 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 (above)
   for (let i = 1; i <= 3; i++) {
-    const unfinished = unfinishedBytes(t, chunk.length + i, enc) // 0-3
+    const unfinished = unfinishedBytes(t, cl + i, enc) // 0-3
     if (unfinished <= i) {
       // Always reachable at 3, but we still need 'unfinished' value for it
       const add = i - unfinished // 0-3
-      return add > 0 ? t.subarray(0, chunk.length + add) : chunk
+      return add > 0 ? t.subarray(0, cl + add) : chunk
     }
   }
 

package/fallback/multi-byte.js

@@ -1,5 +1,6 @@
 import { E_STRING } from './_utils.js'
-import { asciiPrefix, decodeAscii, decodeLatin1, decodeUCS2, encodeAscii } from './latin1.js'
+import { nativeEncoder } from './platform.js'
+import { asciiPrefix, decodeAscii, decodeLatin1, decodeUCS2 } from './latin1.js'
 import { getTable } from './multi-byte.table.js'
 
 export const E_STRICT = 'Input is not well-formed for this encoding'
@@ -776,10 +777,9 @@ export function multibyteEncoder(enc, onError) {
   if (iso2022jp && !katakana) katakana = getTable('iso-2022-jp-katakana')
   return (str) => {
     if (typeof str !== 'string') throw new TypeError(E_STRING)
-    if (ascii && !NON_LATIN.test(str)) {
-      try {
-        return encodeAscii(str, E_STRICT)
-      } catch {}
+    if (ascii && nativeEncoder && !NON_LATIN.test(str)) {
+      const u8 = nativeEncoder.encode(str)
+      if (u8.length === str.length) return u8
     }
 
     const length = str.length
@@ -957,6 +957,6 @@ export function multibyteEncoder(enc, onError) {
       }
     }
 
-    return i === u8.length ? u8 : u8.subarray(0, i)
+    return i === u8.length ? u8 : u8.slice(0, i)
   }
 }

package/hex.d.ts

@@ -31,5 +31,6 @@ export function toHex(arr: Uint8Array): string;
  * @returns The decoded bytes
  */
 export function fromHex(string: string, format?: 'uint8'): Uint8ArrayBuffer;
+export function fromHex(string: string, format: 'arraybuffer'): ArrayBuffer;
 export function fromHex(string: string, format: 'buffer'): Buffer;
-export function fromHex(string: string, format?: OutputFormat): Uint8ArrayBuffer | Buffer;
+export function fromHex(string: string, format?: OutputFormat): Uint8ArrayBuffer | ArrayBuffer | Buffer;

package/hex.js

@@ -1,5 +1,4 @@
-import { typedView } from './array.js'
-import { assertU8 } from './fallback/_utils.js'
+import { assertU8, fromUint8 } from './fallback/_utils.js'
 import * as js from './fallback/hex.js'
 
 const { toHex: webHex } = Uint8Array.prototype // Modern engines have this
@@ -13,5 +12,5 @@ export function toHex(arr) {
 
 // Unlike Buffer.from(), throws on invalid input
 export const fromHex = Uint8Array.fromHex
-  ? (str, format = 'uint8') => typedView(Uint8Array.fromHex(str), format)
-  : (str, format = 'uint8') => typedView(js.fromHex(str), format)
+  ? (str, format = 'uint8') => fromUint8(Uint8Array.fromHex(str), format)
+  : (str, format = 'uint8') => fromUint8(js.fromHex(str), format)

package/hex.node.js

@@ -1,5 +1,4 @@
-import { typedView } from './array.js'
-import { assertU8, E_STRING } from './fallback/_utils.js'
+import { assertU8, fromBuffer, fromUint8, E_STRING } from './fallback/_utils.js'
 import { E_HEX } from './fallback/hex.js'
 
 if (Buffer.TYPED_ARRAY_SUPPORT) throw new Error('Unexpected Buffer polyfill')
@@ -17,12 +16,22 @@ export function toHex(arr) {
 
 // Unlike Buffer.from(), throws on invalid input
 export const fromHex = Uint8Array.fromHex
-  ? (str, format = 'uint8') => typedView(Uint8Array.fromHex(str), format)
+  ? (str, format = 'uint8') => fromUint8(Uint8Array.fromHex(str), format)
   : (str, format = 'uint8') => {
       if (typeof str !== 'string') throw new TypeError(E_STRING)
       if (str.length % 2 !== 0) throw new SyntaxError(E_HEX)
       if (denoBug && /[^\dA-Fa-f]/.test(str)) throw new SyntaxError(E_HEX)
-      const buf = Buffer.from(str, 'hex') // will stop on first non-hex character, so we can just validate length
-      if (buf.length * 2 !== str.length) throw new SyntaxError(E_HEX)
-      return typedView(buf, format)
+
+      // 64 bytes or less, in heap
+      if (str.length <= 128) {
+        const buf = Buffer.from(str, 'hex')
+        if (buf.length * 2 !== str.length) throw new SyntaxError(E_HEX)
+        return fromBuffer(buf, format)
+      }
+
+      const length = str.length / 2
+      const buf = format === 'buffer' ? Buffer.allocUnsafe(length) : Buffer.allocUnsafeSlow(length) // avoid pooling
+      const count = buf.hexWrite(str, 0, length)
+      if (count !== length) throw new SyntaxError(E_HEX) // will stop on first non-hex character, so we can just validate length
+      return fromBuffer(buf, format)
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/bytes",
-  "version": "1.14.1",
+  "version": "1.15.0",
   "description": "Various operations on Uint8Array data",
   "keywords": [
     "encoding",
@@ -273,7 +273,7 @@
     "buffer": "^6.0.3",
     "c8": "^10.1.3",
     "decode-utf8": "^1.0.1",
-    "electron": "36.5.0",
+    "electron": "39.4.0",
     "encode-utf8": "^2.0.0",
     "esbuild": "^0.27.3",
     "eslint": "^8.44.0",
@@ -291,7 +291,7 @@
     "utf8": "^3.0.0",
     "web-streams-polyfill": "^4.2.0",
     "wif": "^5.0.0",
-    "workerd": "^1.20260210.0"
+    "workerd": "^1.20260301.1"
   },
   "prettier": "@exodus/prettier",
   "packageManager": "pnpm@10.12.1+sha256.889bac470ec93ccc3764488a19d6ba8f9c648ad5e50a9a6e4be3768a5de387a3"

package/single-byte.d.ts

@@ -108,6 +108,10 @@ export function createSinglebyteEncoder(
  * > This is different from `new TextDecoder('iso-8859-1')` and `new TextDecoder('latin1')`, as those
  * > alias to `new TextDecoder('windows-1252')`.
  *
+ * Prefer using `isomorphicDecode()` from `@exodus/bytes/encoding.js` or `@exodus/bytes/encoding-lite.js`,
+ * which is identical to this but allows more input types.
+ *
+ * @deprecated Use `import { isomorphicDecode } from '@exodus/bytes/encoding-lite.js'`
  * @param arr - The bytes to decode
  * @returns The decoded string
  */
@@ -123,6 +127,9 @@ export function latin1toString(arr: Uint8Array): string;
  * const latin1fromString = createSinglebyteEncoder('iso-8859-1', { mode: 'fatal' })
  * ```
  *
+ * Prefer using `isomorphicEncode()` from `@exodus/bytes/encoding.js` or `@exodus/bytes/encoding-lite.js`.
+ *
+ * @deprecated Use `import { isomorphicEncode } from '@exodus/bytes/encoding-lite.js'`
  * @param string - The string to encode
  * @returns The encoded bytes
  */

package/single-byte.js

@@ -1,6 +1,6 @@
 import { assertU8, E_STRING } from './fallback/_utils.js'
 import { nativeDecoderLatin1, nativeEncoder } from './fallback/platform.js'
-import { encodeAscii, encodeAsciiPrefix, encodeLatin1 } from './fallback/latin1.js'
+import { encodeAsciiPrefix, encodeLatin1 } from './fallback/latin1.js'
 import { assertEncoding, encodingDecoder, encodeMap, E_STRICT } from './fallback/single-byte.js'
 
 const { TextDecoder, btoa } = globalThis
@@ -90,37 +90,38 @@ function encode(s, m) {
 // fromBase64+btoa path is faster on everything where fromBase64 is fast
 const useLatin1btoa = Uint8Array.fromBase64 && btoa
 
+export function latin1fromString(s) {
+  if (typeof s !== 'string') throw new TypeError(E_STRING)
+  // max limit is to not produce base64 strings that are too long
+  if (useLatin1btoa && s.length >= 1024 && s.length < 1e8) {
+    try {
+      return Uint8Array.fromBase64(btoa(s)) // fails on non-latin1
+    } catch {
+      throw new TypeError(E_STRICT)
+    }
+  }
+
+  if (NON_LATIN.test(s)) throw new TypeError(E_STRICT)
+  return encodeLatin1(s)
+}
+
 export function createSinglebyteEncoder(encoding, { mode = 'fatal' } = {}) {
   // TODO: replacement, truncate (replacement will need varying length)
   if (mode !== 'fatal') throw new Error('Unsupported mode')
+  if (encoding === 'iso-8859-1') return latin1fromString
   const m = encodeMap(encoding) // asserts
-  const isLatin1 = encoding === 'iso-8859-1'
 
   // No single-byte encoder produces surrogate pairs, so any surrogate is invalid
   // This needs special treatment only to decide how many replacement chars to output, one or two
   // Not much use in running isWellFormed, most likely cause of error is unmapped chars, not surrogate pairs
   return (s) => {
     if (typeof s !== 'string') throw new TypeError(E_STRING)
-    if (isLatin1) {
-      // max limit is to not produce base64 strings that are too long
-      if (useLatin1btoa && s.length >= 1024 && s.length < 1e8) {
-        try {
-          return Uint8Array.fromBase64(btoa(s)) // fails on non-latin1
-        } catch {
-          throw new TypeError(E_STRICT)
-        }
-      }
-
-      if (NON_LATIN.test(s)) throw new TypeError(E_STRICT)
-      return encodeLatin1(s)
-    }
 
     // Instead of an ASCII regex check, encode optimistically - this is faster
     // Check for 8-bit string with a regex though, this is instant on 8-bit strings so doesn't hurt the ASCII fast path
     if (nativeEncoder && !NON_LATIN.test(s)) {
-      try {
-        return encodeAscii(s, E_STRICT)
-      } catch {}
+      const u8 = nativeEncoder.encode(s)
+      if (u8.length === s.length) return u8
     }
 
     const res = encode(s, m)
@@ -130,6 +131,5 @@ export function createSinglebyteEncoder(encoding, { mode = 'fatal' } = {}) {
 }
 
 export const latin1toString = /* @__PURE__ */ createSinglebyteDecoder('iso-8859-1')
-export const latin1fromString = /* @__PURE__ */ createSinglebyteEncoder('iso-8859-1')
 export const windows1252toString = /* @__PURE__ */ createSinglebyteDecoder('windows-1252')
 export const windows1252fromString = /* @__PURE__ */ createSinglebyteEncoder('windows-1252')