@exodus/bytes 1.0.0-rc.1 → 1.0.0-rc.11

package/package.json

@@ -1,16 +1,19 @@
 {
   "name": "@exodus/bytes",
-  "version": "1.0.0-rc.1",
+  "version": "1.0.0-rc.11",
   "description": "Various operations on Uint8Array data",
   "scripts": {
     "lint": "eslint .",
-    "test:v8": "npm run test:d8 --",
     "test:javascriptcore": "npm run test:jsc --",
-    "test:d8": "exodus-test --engine=d8:bundle",
+    "test:v8": "exodus-test --engine=v8:bundle",
     "test:jsc": "exodus-test --engine=jsc:bundle",
     "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 --engine=xs:bundle",
+    "test:engine262": "exodus-test --engine=engine262:bundle",
+    "test:deno": "exodus-test --engine=deno:pure",
+    "test:bun": "exodus-test --engine=bun:pure",
     "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",
@@ -18,6 +21,7 @@
     "test:webkit:playwright": "exodus-test --engine=webkit:playwright",
     "test:firefox:puppeteer": "exodus-test --engine=firefox:puppeteer",
     "test:firefox:playwright": "exodus-test --engine=firefox:playwright",
+    "test:servo:bundle": "exodus-test --engine=servo:bundle",
     "test": "exodus-test",
     "jsvu": "jsvu",
     "playwright": "exodus-test --playwright",
@@ -26,43 +30,131 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/ExodusMovement/bytes.git"
+    "url": "git+https://github.com/ExodusOSS/bytes.git"
   },
   "author": "Exodus Movement, Inc.",
   "license": "MIT",
   "bugs": {
-    "url": "https://github.com/ExodusMovement/bytes/issues"
+    "url": "https://github.com/ExodusOSS/bytes/issues"
   },
-  "homepage": "https://github.com/ExodusMovement/bytes#readme",
+  "homepage": "https://github.com/ExodusOSS/bytes#readme",
   "engines": {
     "node": "^20.19.0 || >=22.13.0"
   },
   "type": "module",
   "files": [
+    "/fallback/_utils.js",
+    "/fallback/base32.js",
+    "/fallback/base64.js",
+    "/fallback/encoding.js",
+    "/fallback/encoding.labels.js",
+    "/fallback/encoding.util.js",
+    "/fallback/hex.js",
+    "/fallback/latin1.js",
+    "/fallback/multi-byte.encodings.cjs",
+    "/fallback/multi-byte.encodings.json",
+    "/fallback/multi-byte.js",
+    "/fallback/multi-byte.table.js",
+    "/fallback/single-byte.encodings.js",
+    "/fallback/single-byte.js",
+    "/fallback/utf16.js",
+    "/fallback/utf8.js",
+    "/array.js",
     "/assert.js",
+    "/base32.js",
+    "/base58.js",
+    "/base58check.js",
     "/base64.js",
-    "/array.js",
-    "/hex.js"
+    "/bech32.js",
+    "/encoding.js",
+    "/encoding-lite.js",
+    "/hex.js",
+    "/hex.node.js",
+    "/multi-byte.js",
+    "/multi-byte.node.js",
+    "/single-byte.js",
+    "/single-byte.node.js",
+    "/utf16.js",
+    "/utf16.node.js",
+    "/utf8.js",
+    "/utf8.node.js",
+    "/wif.js"
   ],
   "exports": {
-    "./base64.js": "./base64.js",
     "./array.js": "./array.js",
-    "./hex.js": "./hex.js"
+    "./base32.js": "./base32.js",
+    "./base58.js": "./base58.js",
+    "./base58check.js": "./base58check.js",
+    "./base64.js": "./base64.js",
+    "./bech32.js": "./bech32.js",
+    "./hex.js": {
+      "node": "./hex.node.js",
+      "default": "./hex.js"
+    },
+    "./multi-byte.js": {
+      "node": "./multi-byte.node.js",
+      "default": "./multi-byte.js"
+    },
+    "./single-byte.js": {
+      "node": "./single-byte.node.js",
+      "default": "./single-byte.js"
+    },
+    "./encoding.js": "./encoding.js",
+    "./encoding-lite.js": "./encoding-lite.js",
+    "./utf16.js": {
+      "node": "./utf16.node.js",
+      "default": "./utf16.js"
+    },
+    "./utf8.js": {
+      "node": "./utf8.node.js",
+      "default": "./utf8.js"
+    },
+    "./wif.js": "./wif.js"
+  },
+  "peerDependencies": {
+    "@exodus/crypto": "^1.0.0-rc.4"
+  },
+  "peerDependenciesMeta": {
+    "@exodus/crypto": {
+      "optional": true
+    }
   },
-  "dependencies": {},
   "devDependencies": {
+    "@ethersproject/strings": "^5.8.0",
+    "@exodus/crypto": "^1.0.0-rc.30",
     "@exodus/eslint-config": "^5.24.0",
     "@exodus/prettier": "^1.0.0",
-    "@exodus/test": "^1.0.0-rc.105",
+    "@exodus/test": "^1.0.0-rc.109",
+    "@noble/hashes": "^2.0.1",
     "@scure/base": "^1.2.6",
-    "@types/node": "^24.0.10",
+    "@stablelib/base64": "^2.0.1",
+    "@stablelib/hex": "^2.0.1",
+    "@types/node": "^22.13.0",
     "base-x": "^5.0.1",
     "base32.js": "^0.1.0",
+    "base58-js": "^3.0.3",
     "base64-js": "^1.5.1",
+    "bech32": "^2.0.0",
+    "bs58": "^6.0.0",
+    "bs58check": "^4.0.0",
+    "bstring": "^0.3.9",
     "buffer": "^6.0.3",
+    "decode-utf8": "^1.0.1",
     "electron": "36.5.0",
+    "encode-utf8": "^2.0.0",
     "eslint": "^8.44.0",
-    "jsvu": "^3.0.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.3",
+    "text-encoding": "^0.7.0",
+    "typescript": "^5.9.3",
+    "uint8array-tools": "^0.0.9",
+    "utf8": "^3.0.0",
+    "whatwg-encoding": "^3.1.1",
+    "wif": "^5.0.0"
   },
   "prettier": "@exodus/prettier",
   "packageManager": "pnpm@10.12.1+sha256.889bac470ec93ccc3764488a19d6ba8f9c648ad5e50a9a6e4be3768a5de387a3"

package/single-byte.js

@@ -0,0 +1,55 @@
+import { assertUint8 } from './assert.js'
+import { canDecoders } from './fallback/_utils.js'
+import { assertEncoding, encodingDecoder } from './fallback/single-byte.js'
+
+const { TextDecoder } = globalThis
+
+let windows1252works
+
+function shouldUseNative(enc) {
+  // https://issues.chromium.org/issues/468458388
+  // Also might be incorrectly imlemented on platforms as Latin1 (e.g. in Node.js) or regress
+  // This is the most significant single-byte encoding, 'ascii' and 'latin1' alias to this
+  // Even after Chrome bug is fixed, this should serve as a quick correctness check that it's actually windows-1252
+  if (enc === 'windows-1252') {
+    if (windows1252works === undefined) {
+      windows1252works = false
+      try {
+        const u = new Uint8Array(9) // using 9 bytes is significant to catch the bug
+        u[8] = 128
+        windows1252works = new TextDecoder(enc).decode(u).codePointAt(8) === 0x20_ac
+      } catch {}
+    }
+
+    return windows1252works
+  }
+
+  // iso-8859-16 is somehow broken in WebKit, at least on CI
+  return enc !== 'iso-8859-16'
+}
+
+export function createSinglebyteDecoder(encoding, loose = false) {
+  if (encoding === 'iso-8859-8-i') encoding = 'iso-8859-8'
+  assertEncoding(encoding)
+
+  if (canDecoders && 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)
+        if (arr.byteLength === 0) return ''
+        return decoder.decode(arr)
+      }
+    } catch {}
+  }
+
+  const jsDecoder = encodingDecoder(encoding)
+  return (arr) => {
+    assertUint8(arr)
+    if (arr.byteLength === 0) return ''
+    return jsDecoder(arr, loose)
+  }
+}
+
+export const windows1252toString = createSinglebyteDecoder('windows-1252')

package/single-byte.node.js

@@ -0,0 +1,62 @@
+import { assertUint8 } from './assert.js'
+import { isAscii } from 'node:buffer'
+import { isDeno, isLE } from './fallback/_utils.js'
+import { asciiPrefix, decodeLatin1 } from './fallback/latin1.js'
+import { encodingMapper, encodingDecoder, E_STRICT } from './fallback/single-byte.js'
+
+const toBuf = (x) => Buffer.from(x.buffer, x.byteOffset, x.byteLength)
+
+function latin1Prefix(arr, start) {
+  let p = start | 0
+  const length = arr.length
+  for (const len3 = length - 3; p < len3; p += 4) {
+    if ((arr[p] & 0xe0) === 0x80) return p
+    if ((arr[p + 1] & 0xe0) === 0x80) return p + 1
+    if ((arr[p + 2] & 0xe0) === 0x80) return p + 2
+    if ((arr[p + 3] & 0xe0) === 0x80) return p + 3
+  }
+
+  for (; p < length; p++) {
+    if ((arr[p] & 0xe0) === 0x80) return p
+  }
+
+  return length
+}
+
+export function createSinglebyteDecoder(encoding, loose = false) {
+  if (encoding === 'iso-8859-8-i') encoding = 'iso-8859-8'
+  const latin1path = encoding === 'windows-1252' // TODO: are there more?
+  if (isDeno) {
+    const jsDecoder = encodingDecoder(encoding) // asserts
+    return (arr) => {
+      assertUint8(arr)
+      if (arr.byteLength === 0) return ''
+      if (isAscii(arr)) return toBuf(arr).toString()
+      return jsDecoder(arr, loose) // somewhy faster on Deno anyway, TODO: optimize?
+    }
+  }
+
+  const { incomplete, mapper } = encodingMapper(encoding) // asserts
+  return (arr) => {
+    assertUint8(arr)
+    if (arr.byteLength === 0) return ''
+    if (isAscii(arr)) return toBuf(arr).latin1Slice(0, arr.byteLength) // .latin1Slice is faster than .asciiSlice
+
+    // Node.js TextDecoder is broken, so we can't use it. It's also slow anyway
+
+    let prefixBytes = asciiPrefix(arr)
+    let prefix = ''
+    if (latin1path) prefixBytes = latin1Prefix(arr, prefixBytes)
+    if (prefixBytes > 64 || prefixBytes === arr.length) {
+      prefix = toBuf(arr).latin1Slice(0, prefixBytes) // .latin1Slice is faster than .asciiSlice
+      if (prefixBytes === arr.length) return prefix
+    }
+
+    const b = mapper(arr, prefix.length) // prefix.length can mismatch prefixBytes
+    const suffix = isLE ? toBuf(b).ucs2Slice(0, b.byteLength) : decodeLatin1(b, 0, b.length) // decodeLatin1 is actually capable of decoding 16-bit codepoints
+    if (!loose && incomplete && suffix.includes('\uFFFD')) throw new TypeError(E_STRICT)
+    return prefix + suffix
+  }
+}
+
+export const windows1252toString = createSinglebyteDecoder('windows-1252')

package/utf16.js

@@ -0,0 +1,73 @@
+import * as js from './fallback/utf16.js'
+import { canDecoders, isLE } 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 : decoderFatalBE
+const { isWellFormed } = 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('Input is not a 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
+  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)
+  if (!loose && isWellFormed && !isWellFormed.call(str)) throw new TypeError(E_STRICT)
+
+  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)

package/utf16.node.js

@@ -0,0 +1,79 @@
+import { nativeDecoder, isDeno, isLE } from './fallback/_utils.js'
+import { E_STRICT, E_STRICT_UNICODE } from './fallback/utf16.js'
+
+if (Buffer.TYPED_ARRAY_SUPPORT) throw new Error('Unexpected Buffer polyfill')
+
+const { isWellFormed } = String.prototype
+const to8 = (a) => new Uint8Array(a.buffer, a.byteOffset, a.byteLength)
+
+// Unlike utf8, operates on Uint16Arrays by default
+
+function encode(str, loose = false, format = 'uint16') {
+  if (typeof str !== 'string') throw new TypeError('Input is not a string')
+  if (format !== 'uint16' && format !== 'uint8-le' && format !== 'uint8-be') {
+    throw new TypeError('Unknown format')
+  }
+
+  if (!isWellFormed.call(str)) {
+    if (!loose) throw new TypeError(E_STRICT_UNICODE)
+    str = nativeDecoder.decode(Buffer.from(str)) // well, let's fix up (Buffer doesn't do this with utf16 encoding)
+  }
+
+  const ble = Buffer.from(str, 'utf-16le')
+
+  if (format === 'uint8-le') return to8(ble)
+  if (format === 'uint8-be') return to8(ble.swap16())
+  if (format === 'uint16') {
+    const b = ble.byteOffset % 2 === 0 ? ble : Buffer.from(ble) // it should be already aligned, but just in case
+    if (!isLE) b.swap16()
+    return new Uint16Array(b.buffer, b.byteOffset, b.byteLength / 2)
+  }
+
+  throw new Error('Unreachable')
+}
+
+const swapped = (x, swap) =>
+  swap ? Buffer.from(x).swap16() : Buffer.from(x.buffer, x.byteOffset, x.byteLength)
+
+// We skip TextDecoder on Node.js, as it's is somewhy significantly slower than Buffer for utf16
+function decodeNode(input, loose = false, format = 'uint16') {
+  let ble
+  if (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')
+    if (input.byteLength % 2 !== 0) throw new TypeError('Expected even number of bytes')
+    ble = swapped(input, format === 'uint8-be')
+  } else {
+    throw new TypeError('Unknown format')
+  }
+
+  const str = ble.ucs2Slice(0, ble.byteLength)
+  if (isWellFormed.call(str)) return str
+  if (!loose) throw new TypeError(E_STRICT)
+  return nativeDecoder.decode(Buffer.from(str)) // fixup (see above)
+}
+
+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
+
+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)

package/utf8.js

@@ -0,0 +1,80 @@
+import { assertUint8 } from './assert.js'
+import { typedView } from './array.js'
+import { isHermes, nativeDecoder, nativeEncoder } from './fallback/_utils.js'
+import { asciiPrefix, decodeLatin1 } from './fallback/latin1.js'
+import * as js from './fallback/utf8.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
+const decoderFatal = nativeDecoder
+  ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true })
+  : 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) {
+    // We have a fast native method
+    if (isWellFormed.call(str)) return res
+    throw new TypeError(E_STRICT_UNICODE)
+  }
+
+  // Recheck if the string was encoded correctly
+  let start = 0
+  const last = res.length - 2
+  // Search for EFBFBD
+  while (start < last) {
+    const pos = res.indexOf(0xef, start)
+    if (pos === -1) break
+    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 (str !== decode(res)) throw new TypeError(E_STRICT_UNICODE)
+      return res
+    }
+  }
+
+  return res
+}
+
+function encode(str, loose = false) {
+  if (typeof str !== 'string') throw new TypeError('Input is not a string')
+  if (str.length === 0) return new Uint8Array() // faster than Uint8Array.of
+  if (nativeEncoder) 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)
+  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))
+  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 + js.decode(arr, loose, prefix.length)
+}
+
+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)

package/utf8.node.js

@@ -0,0 +1,54 @@
+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('utf-8', { ignoreBOM: true, fatal: true })
+const decoderLoose = new TextDecoder('utf-8', { ignoreBOM: true })
+const { isWellFormed } = String.prototype
+const isDeno = Boolean(globalThis.Deno)
+
+function encode(str, loose = false) {
+  if (typeof str !== 'string') throw new TypeError('Input is not a string')
+  const strLength = str.length
+  if (strLength === 0) return new Uint8Array() // faster than Uint8Array.of
+  let res
+  if (strLength > 0x4_00 && !isDeno) {
+    // Faster for large strings
+    const byteLength = Buffer.byteLength(str)
+    res = Buffer.allocUnsafe(byteLength)
+    const ascii = byteLength === strLength
+    const written = ascii ? res.latin1Write(str) : res.utf8Write(str)
+    if (written !== byteLength) throw new Error('Failed to write all bytes') // safeguard just in case
+    if (ascii || loose) return res // no further checks needed
+  } else {
+    res = Buffer.from(str)
+    if (res.length === strLength || loose) return res
+  }
+
+  if (!isWellFormed.call(str)) throw new TypeError(E_STRICT_UNICODE)
+  return res
+}
+
+function decode(arr, loose = false) {
+  assertUint8(arr)
+  const byteLength = arr.byteLength
+  if (byteLength === 0) return ''
+  if (byteLength > 0x6_00 && !(isDeno && loose) && 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
+    // Only makes sense for large enough strings
+    const buf = Buffer.from(arr.buffer, arr.byteOffset, arr.byteLength)
+    if (isDeno) return buf.toString() // Deno suffers from .latin1Slice
+    return buf.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)

package/wif.js

@@ -0,0 +1,42 @@
+import { toBase58checkSync, fromBase58checkSync } from './base58check.js'
+import { assertUint8 } from './assert.js'
+
+// Mostly matches npmjs.com/wif, but with extra checks + using our base58check
+// Also no inconsistent behavior on Buffer/Uint8Array input
+
+function from(arr, expectedVersion) {
+  assertUint8(arr)
+  const version = arr[0]
+  if (expectedVersion !== undefined && version !== expectedVersion) {
+    throw new Error('Invalid network version')
+  }
+
+  // Makes a copy, regardless of input being a Buffer or a Uint8Array (unlike .slice)
+  const privateKey = Uint8Array.from(arr.subarray(1, 33))
+  if (arr.length === 33) return { version, privateKey, compressed: false }
+  if (arr.length !== 34) throw new Error('Invalid WIF length')
+  if (arr[33] !== 1) throw new Error('Invalid compression flag')
+  return { version, privateKey, compressed: true }
+}
+
+function to({ version: v, privateKey, compressed }) {
+  if (!Number.isSafeInteger(v) || v < 0 || v > 0xff) throw new Error('Missing or invalid version')
+  assertUint8(privateKey, { length: 32, name: 'privateKey' })
+  if (privateKey.length !== 32) throw new TypeError('Invalid privateKey length')
+  const out = new Uint8Array(compressed ? 34 : 33)
+  out[0] = v
+  out.set(privateKey, 1)
+  if (compressed) out[33] = 1
+  return out
+}
+
+// Async performance is worse here, so expose the same internal methods as sync for now
+// ./base58check is sync internally anyway for now, so doesn't matter until that is changed
+
+export const fromWifStringSync = (string, version) => from(fromBase58checkSync(string), version)
+// export const fromWifString = async (string, version) => from(await fromBase58check(string), version)
+export const fromWifString = async (string, version) => from(fromBase58checkSync(string), version)
+
+export const toWifStringSync = (wif) => toBase58checkSync(to(wif))
+// export const toWifString = async (wif) => toBase58check(to(wif))
+export const toWifString = async (wif) => toBase58checkSync(to(wif))