@exodus/bytes 1.14.1 → 1.15.1

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'
@@ -75,6 +74,7 @@ export function fromBase64url(str, options) {
 
 // By default accepts both padded and non-padded variants, base64 or base64url
 export function fromBase64any(str, { format = 'uint8', padding = 'both', ...rest } = {}) {
+  if (typeof str !== 'string') throw new TypeError(E_STRING)
   const isBase64url = !str.includes('+') && !str.includes('/') // likely to fail fast, as most input is non-url, also double scan is faster than regex
   return fromBase64common(str, isBase64url, padding, format, rest)
 }
@@ -96,7 +96,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 +114,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 +136,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 +173,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

@@ -7,7 +7,8 @@ export function assert(condition, msg) {
 }
 
 export function assertU8(arg) {
-  if (!(arg instanceof Uint8Array)) throw new TypeError('Expected an Uint8Array')
+  if (arg && arg instanceof Uint8Array) return
+  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
@@ -18,3 +19,42 @@ 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 arr.buffer.byteLength === arr.byteLength
+        ? arr.buffer
+        : arr.buffer.slice(arr.byteOffset, arr.byteOffset + arr.byteLength)
+    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/hex.js

@@ -73,7 +73,7 @@ export function fromHex(str) {
       }
     }
 
-    const codes = encodeAscii(str, E_HEX)
+    const codes = encodeAscii(str, E_HEX) // aligned
     const codes16 = new Uint16Array(codes.buffer, codes.byteOffset, codes.byteLength / 2)
     let i = 0
     for (const last3 = length - 3; i < last3; i += 4) {

package/fallback/latin1.js

@@ -140,6 +140,7 @@ export const encodeAscii = useEncodeInto
   : nativeBuffer
     ? (str, ERR) => {
         // TextEncoder is slow on Node.js 24 / 25 (was ok on 22)
+        // Node.js Buffer.from always returns 8-byte aligned allocations, this is safe for e.g. conversion to Uint32Array
         const codes = nativeBuffer.from(str, 'utf8') // ascii/latin1 coerces, we need to check
         if (codes.length !== str.length) throw new SyntaxError(ERR) // non-ascii
         return new Uint8Array(codes.buffer, codes.byteOffset, codes.byteLength)

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.1",
   "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
  */