@exodus/bytes 1.0.0-rc.5 → 1.0.0-rc.7

package/hex.js

@@ -2,30 +2,16 @@ import { assertUint8 } from './assert.js'
 import { typedView } from './array.js'
 import * as js from './fallback/hex.js'
 
-const { Buffer } = globalThis // Buffer is optional, only used when native
-const haveNativeBuffer = Buffer && !Buffer.TYPED_ARRAY_SUPPORT
 const { toHex: webHex } = Uint8Array.prototype // Modern engines have this
 
-const { E_HEX } = js
-
 export function toHex(arr) {
   assertUint8(arr)
   if (arr.length === 0) return ''
   if (webHex && arr.toHex === webHex) return arr.toHex()
-  if (!haveNativeBuffer) return js.toHex(arr)
-  if (arr.constructor === Buffer && Buffer.isBuffer(arr)) return arr.toString('hex')
-  return Buffer.from(arr.buffer, arr.byteOffset, arr.byteLength).toString('hex')
+  return js.toHex(arr)
 }
 
 // Unlike Buffer.from(), throws on invalid input
 export const fromHex = Uint8Array.fromHex
   ? (str, format = 'uint8') => typedView(Uint8Array.fromHex(str), format)
-  : haveNativeBuffer
-    ? (str, format = 'uint8') => {
-        if (typeof str !== 'string') throw new TypeError('Input is not a string')
-        if (str.length % 2 !== 0) 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)
-      }
-    : (str, format = 'uint8') => typedView(js.fromHex(str), format)
+  : (str, format = 'uint8') => typedView(js.fromHex(str), format)

package/hex.node.js

@@ -0,0 +1,26 @@
+import { assertUint8 } from './assert.js'
+import { typedView } from './array.js'
+import { E_HEX } from './fallback/hex.js'
+
+if (Buffer.TYPED_ARRAY_SUPPORT) throw new Error('Unexpected Buffer polyfill')
+
+const { toHex: webHex } = Uint8Array.prototype // Modern engines have this
+
+export function toHex(arr) {
+  assertUint8(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)
+  return Buffer.from(arr.buffer, arr.byteOffset, arr.byteLength).hexSlice(0, arr.byteLength)
+}
+
+// Unlike Buffer.from(), throws on invalid input
+export const fromHex = Uint8Array.fromHex
+  ? (str, format = 'uint8') => typedView(Uint8Array.fromHex(str), format)
+  : (str, format = 'uint8') => {
+      if (typeof str !== 'string') throw new TypeError('Input is not a string')
+      if (str.length % 2 !== 0) 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)
+    }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/bytes",
-  "version": "1.0.0-rc.5",
+  "version": "1.0.0-rc.7",
   "description": "Various operations on Uint8Array data",
   "scripts": {
     "lint": "eslint .",
@@ -39,6 +39,7 @@
   "type": "module",
   "files": [
     "/fallback/_utils.js",
+    "/fallback/latin1.js",
     "/fallback/base32.js",
     "/fallback/base64.js",
     "/fallback/hex.js",
@@ -49,7 +50,9 @@
     "/base58.js",
     "/base58check.js",
     "/base64.js",
+    "/hex.node.js",
     "/hex.js",
+    "/utf8.node.js",
     "/utf8.js"
   ],
   "exports": {
@@ -58,8 +61,18 @@
     "./base58.js": "./base58.js",
     "./base58check.js": "./base58check.js",
     "./base64.js": "./base64.js",
-    "./hex.js": "./hex.js",
-    "./utf8.js": "./utf8.js"
+    "./hex.js": {
+      "node": "./hex.node.js",
+      "default": "./hex.js"
+    },
+    "./utf16.js": {
+      "node": "./utf16.node.js",
+      "default": "./utf16.js"
+    },
+    "./utf8.js": {
+      "node": "./utf8.node.js",
+      "default": "./utf8.js"
+    }
   },
   "peerDependencies": {
     "@exodus/crypto": "^1.0.0-rc.4"
@@ -74,12 +87,12 @@
     "@exodus/crypto": "1.0.0-rc.29",
     "@exodus/eslint-config": "^5.24.0",
     "@exodus/prettier": "^1.0.0",
-    "@exodus/test": "^1.0.0-rc.107",
+    "@exodus/test": "^1.0.0-rc.108",
     "@noble/hashes": "^2.0.1",
     "@scure/base": "^1.2.6",
     "@stablelib/base64": "^2.0.1",
     "@stablelib/hex": "^2.0.1",
-    "@types/node": "^24.0.10",
+    "@types/node": "^22.13.0",
     "base-x": "^5.0.1",
     "base32.js": "^0.1.0",
     "base64-js": "^1.5.1",
@@ -91,9 +104,12 @@
     "eslint": "^8.44.0",
     "fast-base64-decode": "^2.0.0",
     "fast-base64-encode": "^1.0.0",
+    "hextreme": "^1.0.7",
     "hi-base32": "^0.5.1",
+    "iconv-lite": "^0.7.0",
     "jsvu": "^3.0.0",
-    "text-encoding": "^0.7.0"
+    "text-encoding": "^0.7.0",
+    "typescript": "^5.9.3"
   },
   "prettier": "@exodus/prettier",
   "packageManager": "pnpm@10.12.1+sha256.889bac470ec93ccc3764488a19d6ba8f9c648ad5e50a9a6e4be3768a5de387a3"

package/utf8.js

@@ -1,6 +1,7 @@
 import { assertUint8 } from './assert.js'
 import { typedView } from './array.js'
 import * as js from './fallback/utf8.js'
+import { asciiPrefix, decodeLatin1 } from './fallback/latin1.js'
 
 const { Buffer, TextEncoder, TextDecoder, decodeURIComponent, escape } = globalThis // Buffer is optional
 const haveNativeBuffer = Buffer && !Buffer.TYPED_ARRAY_SUPPORT
@@ -18,7 +19,7 @@ const { E_STRICT, E_STRICT_UNICODE } = js
 const shouldUseEscapePath = Boolean(globalThis.HermesInternal) // faster only on Hermes, js path beats it on normal engines
 
 function deLoose(str, loose, res) {
-  if (loose) return res
+  if (loose || str.length === res.length) return res // length is equal only for ascii, which is automatically fine
   if (isWellFormed) {
     // We have a fast native method
     if (isWellFormed.call(str)) return res
@@ -51,64 +52,27 @@ function encode(str, loose = false) {
   return js.encode(str, loose)
 }
 
-let escapes
-
-function toEscapesPart(arr, start, end) {
-  let o = ''
-  let i = start
-  const last3 = end - 3
-  // Unrolled loop is faster
-  while (i < last3) {
-    const a = arr[i++]
-    const b = arr[i++]
-    const c = arr[i++]
-    const d = arr[i++]
-    o += escapes[a]
-    o += escapes[b]
-    o += escapes[c]
-    o += escapes[d]
-  }
-
-  while (i < end) o += escapes[arr[i++]]
-  return o
-}
-
 function decode(arr, loose = false) {
   assertUint8(arr)
   if (haveDecoder) return loose ? decoderLoose.decode(arr) : decoderFatal.decode(arr) // Node.js and browsers
   // No reason to use native Buffer: it's not faster than TextDecoder, needs rechecks in non-loose mode, and Node.js has TextDecoder
 
-  // This codepath gives a ~2x perf boost on Hermes
-  if (shouldUseEscapePath && escape && decodeURIComponent) {
-    if (!escapes) escapes = Array.from({ length: 256 }, (_, i) => escape(String.fromCharCode(i)))
-    const length = arr.length
-    let o
-    if (length > 30_000) {
-      // Limit concatenation to avoid excessive GC
-      // TODO: recheck thresholds on Hermes (taken from hex)
-      const concat = []
-      for (let i = 0; i < length; ) {
-        const step = i + 500
-        const end = step > length ? length : step
-        concat.push(toEscapesPart(arr, i, end))
-        i = end
-      }
-
-      o = concat.join('')
-      concat.length = 0
-    } else {
-      o = toEscapesPart(arr, 0, length)
-    }
+  // Fast path for ASCII prefix, this is faster than all alternatives below
+  const prefix = decodeLatin1(arr, 0, asciiPrefix(arr))
+  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 decodeURIComponent(o) // asci to utf8, escape() is precalucated
+      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 js.decode(arr, loose)
+  return prefix + js.decode(arr, loose, prefix.length)
 }
 
 export const utf8fromString = (str, format = 'uint8') => typedView(encode(str, false), format)

package/utf8.node.js

@@ -0,0 +1,33 @@
+import { assertUint8 } from './assert.js'
+import { typedView } from './array.js'
+import { E_STRICT_UNICODE } from './fallback/utf8.js'
+import { isAscii } from 'node:buffer'
+
+if (Buffer.TYPED_ARRAY_SUPPORT) throw new Error('Unexpected Buffer polyfill')
+
+const decoderFatal = new TextDecoder('utf8', { ignoreBOM: true, fatal: true })
+const decoderLoose = new TextDecoder('utf8', { ignoreBOM: true })
+const { isWellFormed } = String.prototype
+
+function encode(str, loose = false) {
+  if (typeof str !== 'string') throw new TypeError('Input is not a string')
+  const res = Buffer.from(str)
+  if (loose || str.length === res.length || isWellFormed.call(str)) return res // length is equal only for ascii, which is automatically fine
+  throw new TypeError(E_STRICT_UNICODE)
+}
+
+function decode(arr, loose = false) {
+  assertUint8(arr)
+  if (isAscii(arr)) {
+    // On non-ascii strings, this loses ~10% * [relative position of the first non-ascii byte] (up to 10% total)
+    // On ascii strings, this wins 1.5x on loose = false and 1.3x on loose = true
+    return Buffer.from(arr.buffer, arr.byteOffset, arr.byteLength).latin1Slice(0, arr.byteLength) // .latin1Slice is faster than .asciiSlice
+  }
+
+  return loose ? decoderLoose.decode(arr) : decoderFatal.decode(arr)
+}
+
+export const utf8fromString = (str, format = 'uint8') => typedView(encode(str, false), format)
+export const utf8fromStringLoose = (str, format = 'uint8') => typedView(encode(str, true), format)
+export const utf8toString = (arr) => decode(arr, false)
+export const utf8toStringLoose = (arr) => decode(arr, true)