@exodus/bytes 1.8.0 → 1.10.0

package/fallback/multi-byte.table.js

@@ -40,7 +40,7 @@ function loadBase64(str) {
   return y
 }
 
-function unwrap(res, t, pos, stringMode = false) {
+function unwrap(res, t, pos, highMode = false) {
   let code = 0
   for (let i = 0; i < t.length; i++) {
     let x = t[i]
@@ -55,25 +55,30 @@ function unwrap(res, t, pos, stringMode = false) {
           code += t[++i]
         }
 
-        if (stringMode) {
+        if (highMode) {
           for (let k = 0; k < x; k++, pos++, code++) {
-            res[pos] = code <= 0xff_ff ? code : String.fromCodePoint(code)
+            if (code <= 0xff_ff) {
+              res[pos] = code
+            } else {
+              const c = String.fromCodePoint(code)
+              res[pos] = (c.charCodeAt(0) << 16) | c.charCodeAt(1)
+            }
           }
         } else {
           for (let k = 0; k < x; k++, pos++, code++) res[pos] = code
         }
       }
     } else if (x[0] === '$' && Object.hasOwn(indices, x)) {
-      pos = unwrap(res, indices[x], pos, stringMode) // self-reference using shared chunks
-    } else if (stringMode) {
+      pos = unwrap(res, indices[x], pos, highMode) // self-reference using shared chunks
+    } else if (highMode) {
       const s = [...utf16toString(loadBase64(x), 'uint8-le')] // splits by codepoints
-      let char
+      let c
       for (let i = 0; i < s.length; ) {
-        char = s[i++]
-        res[pos++] = char.length === 1 ? char.charCodeAt(0) : char // strings only for high codepoints
+        c = s[i++]
+        res[pos++] = c.length === 1 ? c.charCodeAt(0) : (c.charCodeAt(0) << 16) | c.charCodeAt(1)
       }
 
-      code = char.codePointAt(0) + 1
+      code = c.codePointAt(0) + 1
     } else {
       const u16 = to16input(loadBase64(x), true) // data is little-endian
       res.set(u16, pos)
@@ -99,19 +104,22 @@ export function getTable(id) {
     let a = 0, b = 0 // prettier-ignore
     const idx = indices[id]
     while (idx.length > 0) res.push([(a += idx.shift()), (b += idx.shift())]) // destroying, we remove it later anyway
+  } else if (id.endsWith('-katakana')) {
+    let a = -1
+    res = new Uint16Array(indices[id].map((x) => (a += x + 1)))
   } else if (id === 'big5') {
     if (!Object.hasOwn(sizes, id)) throw new Error('Unknown encoding')
-    res = new Array(sizes[id]) // array of strings or undefined
+    res = new Uint32Array(sizes[id]) // array of strings or undefined
     unwrap(res, indices[id], 0, true)
     // Pointer code updates are embedded into the table
-    res[1133] = '\xCA\u0304'
-    res[1135] = '\xCA\u030C'
-    res[1164] = '\xEA\u0304'
-    res[1166] = '\xEA\u030C'
+    // These are skipped in encoder as encoder uses only pointers >= (0xA1 - 0x81) * 157
+    res[1133] = 0xca_03_04
+    res[1135] = 0xca_03_0c
+    res[1164] = 0xea_03_04
+    res[1166] = 0xea_03_0c
   } else {
     if (!Object.hasOwn(sizes, id)) throw new Error('Unknown encoding')
     res = new Uint16Array(sizes[id])
-    res.fill(0xff_fd)
     unwrap(res, indices[id], 0, false)
   }
 

package/fallback/single-byte.js

@@ -13,7 +13,7 @@ export const assertEncoding = (encoding) => {
 
 const r = 0xff_fd
 
-function getEncoding(encoding) {
+export function getEncoding(encoding) {
   assertEncoding(encoding)
   if (encoding === xUserDefined) return Array.from({ length: 128 }, (_, i) => 0xf7_80 + i)
   if (encoding === iso8i) encoding = 'iso-8859-8'

package/fallback/utf16.js

@@ -12,45 +12,48 @@ const to16 = (a) => new Uint16Array(a.buffer, a.byteOffset, a.byteLength / 2) //
 export function to16input(u8, le) {
   // Assume even number of bytes
   if (le === isLE) return to16(u8.byteOffset % 2 === 0 ? u8 : Uint8Array.from(u8))
+  return to16(swap16(Uint8Array.from(u8)))
+}
+
+export const decode = (u16, loose = false, checked = false) => {
+  if (checked || isWellFormed(u16)) return decodeUCS2(u16)
+  if (!loose) throw new TypeError(E_STRICT)
+  return decodeUCS2(toWellFormed(Uint16Array.from(u16))) // cloned for replacement
+}
+
+export function encode(str, loose = false, checked = false, swapped = false) {
+  const arr = new Uint16Array(str.length)
+  if (checked) return swapped ? encodeCheckedSwapped(str, arr) : encodeChecked(str, arr)
+  return swapped ? encodeUncheckedSwapped(str, arr, loose) : encodeUnchecked(str, arr, loose)
+}
 
-  const res = new Uint8Array(u8.length)
+/* eslint-disable @exodus/mutable/no-param-reassign-prop-only */
 
+// Assumes checked length % 2 === 0, otherwise does not swap tail
+function swap16(u8) {
   let i = 0
   for (const last3 = u8.length - 3; i < last3; i += 4) {
     const x0 = u8[i]
     const x1 = u8[i + 1]
     const x2 = u8[i + 2]
     const x3 = u8[i + 3]
-    res[i] = x1
-    res[i + 1] = x0
-    res[i + 2] = x3
-    res[i + 3] = x2
+    u8[i] = x1
+    u8[i + 1] = x0
+    u8[i + 2] = x3
+    u8[i + 3] = x2
   }
 
   for (const last = u8.length - 1; i < last; i += 2) {
     const x0 = u8[i]
     const x1 = u8[i + 1]
-    res[i] = x1
-    res[i + 1] = x0
+    u8[i] = x1
+    u8[i + 1] = x0
   }
 
-  return to16(res)
-}
-
-export const decode = (u16, loose = false, checked = false) => {
-  if (checked || isWellFormed(u16)) return decodeUCS2(u16)
-  if (!loose) throw new TypeError(E_STRICT)
-  return decodeUCS2(toWellFormed(Uint16Array.from(u16))) // cloned for replacement
-}
-
-export function encode(str, loose = false, checked = false, swapped = false) {
-  const arr = new Uint16Array(str.length)
-  if (checked) return swapped ? encodeCheckedSwapped(str, arr) : encodeChecked(str, arr)
-  return swapped ? encodeUncheckedSwapped(str, arr, loose) : encodeUnchecked(str, arr, loose)
+  return u8
 }
 
 // Splitting paths into small functions helps (at least on SpiderMonkey)
-/* eslint-disable @exodus/mutable/no-param-reassign-prop-only */
 
 const encodeChecked = (str, arr) => encodeCharcodes(str, arr) // Same as encodeLatin1, but with Uint16Array
 
@@ -121,6 +124,7 @@ function encodeUncheckedSwapped(str, arr, loose = false) {
   return arr
 }
 
+// Only needed on Hermes, everything else has native impl
 export function toWellFormed(u16) {
   const length = u16.length
   for (let i = 0; i < length; i++) {
@@ -143,10 +147,15 @@ export function toWellFormed(u16) {
   return u16
 }
 
+// Only needed on Hermes, everything else has native impl
 export function isWellFormed(u16) {
   const length = u16.length
   let i = 0
 
+  const m = 0x80_00_80_00
+  const l = 0xd8_00
+  const h = 0xe0_00
+
   // Speedup with u32, by skipping to the first surrogate
   // Only implemented for aligned input for now, but almost all input is aligned (pooled Buffer or 0 offset)
   if (length > 32 && u16.byteOffset % 4 === 0) {
@@ -158,21 +167,31 @@ export function isWellFormed(u16) {
       const b = u32[i + 1]
       const c = u32[i + 2]
       const d = u32[i + 3]
-      if (a & 0x80_00_80_00 || b & 0x80_00_80_00 || c & 0x80_00_80_00 || d & 0x80_00_80_00) break
+      if (a & m || b & m || c & m || d & m) break // bitwise OR does not make this faster on Hermes
     }
 
-    for (; i < u32length; i++) if (u32[i] & 0x80_00_80_00) break
+    for (; i < u32length; i++) if (u32[i] & m) break
     i *= 2
   }
 
+  // An extra loop gives ~30-40% speedup e.g. on English text without surrogates but with other symbols above 0x80_00
+  for (const last3 = length - 3; ; i += 4) {
+    if (i >= last3) break
+    const a = u16[i]
+    const b = u16[i + 1]
+    const c = u16[i + 2]
+    const d = u16[i + 3]
+    if ((a >= l && a < h) || (b >= l && b < h) || (c >= l && c < h) || (d >= l && d < h)) break
+  }
+
   for (; i < length; i++) {
     const code = u16[i]
-    if (code >= 0xd8_00 && code < 0xe0_00) {
+    if (code >= l && code < h) {
       // An unexpected trail or a lead at the very end of input
-      if (code > 0xdb_ff || i + 1 >= length) return false
+      if (code >= 0xdc_00 || i + 1 >= length) return false
       i++ // consume next
       const next = u16[i] // Process valid pairs immediately
-      if (next < 0xdc_00 || next >= 0xe0_00) return false
+      if (next < 0xdc_00 || next >= h) return false
     }
   }
 

package/fallback/utf8.js

@@ -191,7 +191,7 @@ export function encode(string, loose) {
 
     if (small) {
       // TODO: use resizable array buffers? will have to return a non-resizeable one
-      if (p !== i) throw new Error('Unreachable') // Here, p === i (only when small is still true)
+      if (p !== i) /* c8 ignore next */ throw new Error('Unreachable') // Here, p === i (only when small is still true)
       const bytesNew = new Uint8Array(p + (length - i) * 3) // maximium can be 3x of the string length in charcodes
       bytesNew.set(bytes)
       bytes = bytesNew

package/hex.d.ts

@@ -1,22 +1,35 @@
+/**
+ * Implements Base16 from [RFC4648](https://datatracker.ietf.org/doc/html/rfc4648)
+ * (no differences from [RFC3548](https://datatracker.ietf.org/doc/html/rfc4648)).
+ *
+ * ```js
+ * import { fromHex, toHex } from '@exodus/bytes/hex.js'
+ * ```
+ *
+ * @module @exodus/bytes/hex.js
+ */
+
 /// <reference types="node" />
 
 import type { OutputFormat, Uint8ArrayBuffer } from './array.js';
 
 /**
- * Encodes a Uint8Array to a lowercase hex string
+ * Encode a `Uint8Array` to a lowercase hex string
+ *
  * @param arr - The input bytes
  * @returns The hex encoded string
  */
-export function toHex(arr: Uint8ArrayBuffer): string;
+export function toHex(arr: Uint8Array): string;
 
 /**
- * Decodes a hex string to bytes
- * Unlike Buffer.from(), throws on invalid input
- * @param str - The hex encoded string (case-insensitive)
+ * Decode a hex string to bytes
+ *
+ * Unlike `Buffer.from()`, throws on invalid input
+ *
+ * @param string - The hex encoded string (case-insensitive)
  * @param format - Output format (default: 'uint8')
  * @returns The decoded bytes
  */
-export function fromHex(str: string, format?: 'uint8'): Uint8ArrayBuffer;
-export function fromHex(str: string, format: 'buffer'): Buffer;
-export function fromHex(str: string, format?: OutputFormat): Uint8ArrayBuffer | Buffer;
-
+export function fromHex(string: string, format?: 'uint8'): Uint8ArrayBuffer;
+export function fromHex(string: string, format: 'buffer'): Buffer;
+export function fromHex(string: string, format?: OutputFormat): Uint8ArrayBuffer | Buffer;

package/index.d.ts

@@ -0,0 +1,43 @@
+/**
+ * ### The `@exodus/bytes` package consists of submodules, there is no single export.
+ * Import specific submodules instead.
+ *
+ * See [README](https://github.com/ExodusOSS/bytes/blob/main/README.md).
+ *
+ * Example:
+ * ```js
+ * import { fromHex, toHex } from '@exodus/bytes/hex.js'
+ * import { fromBase64, toBase64, fromBase64url, toBase64url, fromBase64any } from '@exodus/bytes/base64.js'
+ * import { fromBase32, toBase32, fromBase32hex, toBase32hex } from '@exodus/bytes/base32.js'
+ * import { fromBase58, toBase58, fromBase58xrp, toBase58xrp } from '@exodus/bytes/base58.js'
+ * import { fromBech32, toBech32, fromBech32m, toBech32m, getPrefix } from '@exodus/bytes/bech32.js'
+ * import { fromBigInt, toBigInt } from '@exodus/bytes/bigint.js'
+ *
+ * import { utf8fromString, utf8toString, utf8fromStringLoose, utf8toStringLoose } from '@exodus/bytes/utf8.js'
+ * import { utf16fromString, utf16toString, utf16fromStringLoose, utf16toStringLoose } from '@exodus/bytes/utf16.js'
+ * import {
+ *   createSinglebyteDecoder, createSinglebyteEncoder,
+ *   windows1252toString, windows1252fromString,
+ *   latin1toString, latin1fromString } from '@exodus/bytes/single-byte.js'
+ * import { createMultibyteDecoder, createMultibyteEncoder } from '@exodus/bytes/multi-byte.js'
+ *
+ * import {
+ *   fromBase58check, toBase58check,
+ *   fromBase58checkSync, toBase58checkSync,
+ *   makeBase58check } from '@exodus/bytes/base58check.js'
+ * import { fromWifString, toWifString, fromWifStringSync, toWifStringSync } from '@exodus/bytes/wif.js'
+ *
+ * // All encodings from the WHATWG Encoding spec
+ * import { TextDecoder, TextEncoder, TextDecoderStream, TextEncoderStream } from '@exodus/bytes/encoding.js'
+ * import { getBOMEncoding, legacyHookDecode, labelToName, normalizeEncoding } from '@exodus/bytes/encoding.js'
+ *
+ * // Omits legacy multi-byte decoders to save bundle size
+ * import { TextDecoder, TextEncoder, TextDecoderStream, TextEncoderStream } from '@exodus/bytes/encoding-lite.js'
+ * import { getBOMEncoding, legacyHookDecode, labelToName, normalizeEncoding } from '@exodus/bytes/encoding-lite.js'
+ *
+ * // In browser bundles, uses built-in TextDecoder / TextEncoder to save bundle size
+ * import { TextDecoder, TextEncoder, TextDecoderStream, TextEncoderStream } from '@exodus/bytes/encoding-browser.js'
+ * import { getBOMEncoding, legacyHookDecode, labelToName, normalizeEncoding } from '@exodus/bytes/encoding-browser.js'
+ * ```
+ */
+declare module '@exodus/bytes' {}

package/index.js

@@ -0,0 +1,5 @@
+throw new Error(
+  `This package consists of submodules, there is no single export. Import specific submodules instead.
+See README: https://github.com/ExodusOSS/bytes/blob/main/README.md
+`
+)

package/multi-byte.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Decode / encode the legacy multi-byte encodings according to the
+ * [Encoding standard](https://encoding.spec.whatwg.org/)
+ * ([§10](https://encoding.spec.whatwg.org/#legacy-multi-byte-chinese-(simplified)-encodings),
+ * [§11](https://encoding.spec.whatwg.org/#legacy-multi-byte-chinese-(traditional)-encodings),
+ * [§12](https://encoding.spec.whatwg.org/#legacy-multi-byte-japanese-encodings),
+ * [§13](https://encoding.spec.whatwg.org/#legacy-multi-byte-korean-encodings)).
+ *
+ * ```js
+ * import { createMultibyteDecoder, createMultibyteEncoder } from '@exodus/bytes/multi-byte.js'
+ * ```
+ *
+ * Supports all legacy multi-byte encodings listed in the WHATWG Encoding standard:
+ * `gbk`, `gb18030`, `big5`, `euc-jp`, `iso-2022-jp`, `shift_jis`, `euc-kr`.
+ *
+ * @module @exodus/bytes/multi-byte.js
+ */
+
+/// <reference types="node" />
+
+import type { Uint8ArrayBuffer } from './array.js';
+
+/**
+ * Create a decoder for a supported legacy multi-byte `encoding`, given its lowercased name `encoding`.
+ *
+ * Returns a function `decode(arr, stream = false)` that decodes bytes to a string.
+ *
+ * The returned function will maintain internal state while `stream = true` is used, allowing it to
+ * handle incomplete multi-byte sequences across multiple calls.
+ * State is reset when `stream = false` or when the function is called without the `stream` parameter.
+ *
+ * @param encoding - The encoding name (e.g., 'gbk', 'gb18030', 'big5', 'euc-jp', 'iso-2022-jp', 'shift_jis', 'euc-kr')
+ * @param loose - If true, replaces unmapped bytes with replacement character instead of throwing (default: false)
+ * @returns A function that decodes bytes to string, with optional streaming support
+ */
+export function createMultibyteDecoder(
+  encoding: string,
+  loose?: boolean
+): (arr: Uint8Array, stream?: boolean) => string;
+
+/**
+ * Create an encoder for a supported legacy multi-byte `encoding`, given its lowercased name `encoding`.
+ *
+ * Returns a function `encode(string)` that encodes a string to bytes.
+ *
+ * In `'fatal'` mode (default), will throw on non well-formed strings or any codepoints which could
+ * not be encoded in the target encoding.
+ *
+ * @param encoding - The encoding name (e.g., 'gbk', 'gb18030', 'big5', 'euc-jp', 'iso-2022-jp', 'shift_jis', 'euc-kr')
+ * @param options - Encoding options
+ * @param options.mode - Encoding mode (default: 'fatal'). Currently, only 'fatal' mode is supported.
+ * @returns A function that encodes string to bytes
+ */
+export function createMultibyteEncoder(
+  encoding: string,
+  options?: { mode?: 'fatal' }
+): (string: string) => Uint8ArrayBuffer;

package/multi-byte.js

@@ -1,5 +1,5 @@
 import { assertUint8 } from './assert.js'
-import { multibyteDecoder } from './fallback/multi-byte.js'
+import { multibyteDecoder, multibyteEncoder } from './fallback/multi-byte.js'
 
 export function createMultibyteDecoder(encoding, loose = false) {
   const jsDecoder = multibyteDecoder(encoding, loose) // asserts
@@ -11,3 +11,9 @@ export function createMultibyteDecoder(encoding, loose = false) {
     return jsDecoder(arr, stream)
   }
 }
+
+export function createMultibyteEncoder(encoding, { mode = 'fatal' } = {}) {
+  // TODO: replacement, truncate (replacement will need varying length)
+  if (mode !== 'fatal') throw new Error('Unsupported mode')
+  return multibyteEncoder(encoding) // asserts
+}

package/multi-byte.node.js

@@ -1,6 +1,6 @@
 import { assertUint8 } from './assert.js'
 import { isDeno, toBuf } from './fallback/_utils.js'
-import { isAsciiSuperset, multibyteDecoder } from './fallback/multi-byte.js'
+import { isAsciiSuperset, multibyteDecoder, multibyteEncoder } from './fallback/multi-byte.js'
 import { isAscii } from 'node:buffer'
 
 export function createMultibyteDecoder(encoding, loose = false) {
@@ -21,3 +21,9 @@ export function createMultibyteDecoder(encoding, loose = false) {
     return jsDecoder(arr, stream)
   }
 }
+
+export function createMultibyteEncoder(encoding, { mode = 'fatal' } = {}) {
+  // TODO: replacement, truncate (replacement will need varying length)
+  if (mode !== 'fatal') throw new Error('Unsupported mode')
+  return multibyteEncoder(encoding) // asserts
+}

package/package.json

@@ -1,7 +1,23 @@
 {
   "name": "@exodus/bytes",
-  "version": "1.8.0",
+  "version": "1.10.0",
   "description": "Various operations on Uint8Array data",
+  "keywords": [
+    "encoding",
+    "uint8array",
+    "textdecoder",
+    "textencoder",
+    "utf8",
+    "utf16",
+    "hex",
+    "base64",
+    "base32",
+    "base58",
+    "base58check",
+    "bech32",
+    "bech32m",
+    "wif"
+  ],
   "scripts": {
     "lint": "eslint .",
     "test:javascriptcore": "npm run test:jsc --",
@@ -23,6 +39,7 @@
     "test:firefox:playwright": "exodus-test --engine=firefox:playwright",
     "test:servo:bundle": "exodus-test --engine=servo:bundle",
     "test": "exodus-test",
+    "size": "esbuild --minify --bundle",
     "jsvu": "jsvu",
     "playwright": "exodus-test --playwright",
     "benchmark": "exodus-test --concurrency=1 benchmarks/*.bench.js",
@@ -37,7 +54,7 @@
   "bugs": {
     "url": "https://github.com/ExodusOSS/bytes/issues"
   },
-  "homepage": "https://github.com/ExodusOSS/bytes#readme",
+  "homepage": "https://github.com/ExodusOSS/bytes",
   "engines": {
     "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
   },
@@ -48,6 +65,7 @@
     "/fallback/base58check.js",
     "/fallback/base64.js",
     "/fallback/encoding.js",
+    "/fallback/encoding.api.js",
     "/fallback/encoding.labels.js",
     "/fallback/encoding.util.js",
     "/fallback/hex.js",
@@ -64,13 +82,22 @@
     "/array.d.ts",
     "/assert.js",
     "/base32.js",
+    "/base32.d.ts",
     "/base58.js",
+    "/base58.d.ts",
     "/base58check.js",
+    "/base58check.d.ts",
     "/base58check.node.js",
     "/base64.js",
     "/base64.d.ts",
     "/bech32.js",
+    "/bech32.d.ts",
     "/bigint.js",
+    "/bigint.d.ts",
+    "/encoding-browser.js",
+    "/encoding-browser.browser.js",
+    "/encoding-browser.native.js",
+    "/encoding-browser.d.ts",
     "/encoding.js",
     "/encoding.d.ts",
     "/encoding-lite.js",
@@ -78,25 +105,45 @@
     "/hex.js",
     "/hex.d.ts",
     "/hex.node.js",
+    "/index.js",
+    "/index.d.ts",
     "/multi-byte.js",
+    "/multi-byte.d.ts",
     "/multi-byte.node.js",
     "/single-byte.js",
+    "/single-byte.d.ts",
     "/single-byte.node.js",
     "/utf16.js",
+    "/utf16.d.ts",
     "/utf16.node.js",
     "/utf8.js",
     "/utf8.d.ts",
     "/utf8.node.js",
-    "/wif.js"
+    "/wif.js",
+    "/wif.d.ts"
   ],
+  "main": "index.js",
+  "module": "index.js",
+  "types": "index.d.ts",
   "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    },
     "./array.js": {
       "types": "./array.d.ts",
       "default": "./array.js"
     },
-    "./base32.js": "./base32.js",
-    "./base58.js": "./base58.js",
+    "./base32.js": {
+      "types": "./base32.d.ts",
+      "default": "./base32.js"
+    },
+    "./base58.js": {
+      "types": "./base58.d.ts",
+      "default": "./base58.js"
+    },
     "./base58check.js": {
+      "types": "./base58check.d.ts",
       "node": "./base58check.node.js",
       "default": "./base58check.js"
     },
@@ -104,18 +151,26 @@
       "types": "./base64.d.ts",
       "default": "./base64.js"
     },
-    "./bech32.js": "./bech32.js",
-    "./bigint.js": "./bigint.js",
+    "./bech32.js": {
+      "types": "./bech32.d.ts",
+      "default": "./bech32.js"
+    },
+    "./bigint.js": {
+      "types": "./bigint.d.ts",
+      "default": "./bigint.js"
+    },
     "./hex.js": {
       "types": "./hex.d.ts",
       "node": "./hex.node.js",
       "default": "./hex.js"
     },
     "./multi-byte.js": {
+      "types": "./multi-byte.d.ts",
       "node": "./multi-byte.node.js",
       "default": "./multi-byte.js"
     },
     "./single-byte.js": {
+      "types": "./single-byte.d.ts",
       "node": "./single-byte.node.js",
       "default": "./single-byte.js"
     },
@@ -127,7 +182,15 @@
       "types": "./encoding-lite.d.ts",
       "default": "./encoding-lite.js"
     },
+    "./encoding-browser.js": {
+      "types": "./encoding-browser.d.ts",
+      "node": "./encoding-browser.js",
+      "react-native": "./encoding-browser.native.js",
+      "browser": "./encoding-browser.browser.js",
+      "default": "./encoding-browser.js"
+    },
     "./utf16.js": {
+      "types": "./utf16.d.ts",
       "node": "./utf16.node.js",
       "default": "./utf16.js"
     },
@@ -136,13 +199,19 @@
       "node": "./utf8.node.js",
       "default": "./utf8.js"
     },
-    "./wif.js": "./wif.js"
+    "./wif.js": {
+      "types": "./wif.d.ts",
+      "default": "./wif.js"
+    }
+  },
+  "react-native": {
+    "./encoding-browser.js": "./encoding-browser.native.js"
   },
   "peerDependencies": {
-    "@exodus/crypto": "^1.0.0-rc.4"
+    "@noble/hashes": "^1.8.0 || ^2.0.0"
   },
   "peerDependenciesMeta": {
-    "@exodus/crypto": {
+    "@noble/hashes": {
       "optional": true
     }
   },
@@ -153,6 +222,7 @@
     "@exodus/prettier": "^1.0.0",
     "@exodus/test": "^1.0.0-rc.109",
     "@noble/hashes": "^2.0.1",
+    "@oslojs/encoding": "^1.1.0",
     "@petamoriken/float16": "^3.9.3",
     "@scure/base": "^1.2.6",
     "@stablelib/base64": "^2.0.1",
@@ -167,9 +237,11 @@
     "bs58check": "^4.0.0",
     "bstring": "^0.3.9",
     "buffer": "^6.0.3",
+    "c8": "^10.1.3",
     "decode-utf8": "^1.0.1",
     "electron": "36.5.0",
     "encode-utf8": "^2.0.0",
+    "esbuild": "^0.27.2",
     "eslint": "^8.44.0",
     "fast-base64-decode": "^2.0.0",
     "fast-base64-encode": "^1.0.0",
@@ -177,6 +249,7 @@
     "hi-base32": "^0.5.1",
     "iconv-lite": "^0.7.0",
     "jsvu": "^3.0.3",
+    "punycode": "^2.3.1",
     "text-encoding": "^0.7.0",
     "typescript": "^5.9.3",
     "uint8array-tools": "^0.0.9",