@exodus/bytes 1.2.0 → 1.4.0

package/README.md

@@ -78,6 +78,13 @@ See [the list of encodings](https://encoding.spec.whatwg.org/#names-and-labels).
 
 ### `@exodus/bytes/utf8.js`
 
+```js
+import { utf8fromString, utf8toString } from '@exodus/bytes/utf8.js'
+
+// loose
+import { utf8fromStringLoose, utf8toStringLoose } from '@exodus/bytes/utf8.js'
+```
+
 ##### `utf8fromString(str, format = 'uint8')`
 ##### `utf8fromStringLoose(str, format = 'uint8')`
 ##### `utf8toString(arr)`
@@ -85,6 +92,13 @@ See [the list of encodings](https://encoding.spec.whatwg.org/#names-and-labels).
 
 ### `@exodus/bytes/utf16.js`
 
+```js
+import { utf16fromString, utf16toString } from '@exodus/bytes/utf16.js'
+
+// loose
+import { utf16fromStringLoose, utf16toStringLoose } from '@exodus/bytes/utf16.js'
+```
+
 ##### `utf16fromString(str, format = 'uint16')`
 ##### `utf16fromStringLoose(str, format = 'uint16')`
 ##### `utf16toString(arr, 'uint16')`
@@ -92,21 +106,26 @@ See [the list of encodings](https://encoding.spec.whatwg.org/#names-and-labels).
 
 ### `@exodus/bytes/single-byte.js`
 
-##### `createSinglebyteDecoder(encoding, loose = false)`
-
-Create a decoder for a supported one-byte `encoding`.
-
-Returns a function `decode(arr)` that decodes bytes to a string.
+```js
+import { createSinglebyteDecoder } from '@exodus/bytes/single-byte.js'
+import { windows1252toString } from '@exodus/bytes/single-byte.js'
+```
 
-### `@exodus/bytes/multi-byte.js`
+Decode the legacy single-byte encodings according to the [Encoding standard](https://encoding.spec.whatwg.org/)
+([§9](https://encoding.spec.whatwg.org/#legacy-single-byte-encodings) and
+[§14.5](https://encoding.spec.whatwg.org/#x-user-defined)).
 
-##### `createMultibyteDecoder(encoding, loose = false)`
+Supports all single-byte encodings listed in the standard:
+`ibm866`, `iso-8859-2`, `iso-8859-3`, `iso-8859-4`, `iso-8859-5`, `iso-8859-6`, `iso-8859-7`, `iso-8859-8`,
+`iso-8859-8-i`, `iso-8859-10`, `iso-8859-13`, `iso-8859-14`, `iso-8859-15`, `iso-8859-16`, `koi8-r`, `koi8-u`,
+`macintosh`, `windows-874`, `windows-1250`, `windows-1251`, `windows-1252`, `windows-1253`, `windows-1254`,
+`windows-1255`, `windows-1256`, `windows-1257`, `windows-1258`, `x-mac-cyrillic` and `x-user-defined`.
 
-Create a decoder for a supported legacy multi-byte `encoding`.
+##### `createSinglebyteDecoder(encoding, loose = false)`
 
-Returns a function `decode(arr, stream = false)` that decodes bytes to a string.
+Create a decoder for a supported one-byte `encoding`, given it's lowercased name `encoding`.
 
-That function will have state while `stream = true` is used.
+Returns a function `decode(arr)` that decodes bytes to a string.
 
 ##### `windows1252toString(arr)`
 
@@ -116,59 +135,132 @@ Also supports `ascii` and `latin-1` as those are strict subsets of `windows-1252
 
 There is no loose variant for this encoding, all bytes can be decoded.
 
-Same as `windows1252toString = createSinglebyteDecoder('windows-1252')`.
+Same as:
+```js
+const windows1252toString = createSinglebyteDecoder('windows-1252')
+```
+
+### `@exodus/bytes/multi-byte.js`
+
+```js
+import { createMultibyteDecoder } from '@exodus/bytes/multi-byte.js'
+```
+
+Decode 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)).
+
+Supports all legacy multi-byte encodings listed in the standard:
+`gbk`, `gb18030`, `big5`, `euc-jp`, `iso-2022-jp`, `shift_jis`, `euc-kr`.
+
+##### `createMultibyteDecoder(encoding, loose = false)`
+
+Create a decoder for a supported legacy multi-byte `encoding`, given it's lowercased name `encoding`.
+
+Returns a function `decode(arr, stream = false)` that decodes bytes to a string.
+
+That function will have state while `stream = true` is used.
 
 ### `@exodus/bytes/bigint.js`
 
+```js
+import { fromBigInt, toBigInt } from '@exodus/bytes/bigint.js'
+```
+
 ##### `fromBigInt(bigint, { length, format = 'uint8' })`
 ##### `toBigInt(arr)`
 
 ### `@exodus/bytes/hex.js`
 
-##### `toHex(arr)`
+```js
+import { fromHex, toHex } from '@exodus/bytes/hex.js'
+```
+
 ##### `fromHex(string)`
+##### `toHex(arr)`
 
 ### `@exodus/bytes/base64.js`
 
-##### `toBase64(arr, { padding = true })`
-##### `toBase64url(arr, { padding = false })`
+```js
+import { fromBase64, toBase64 } from '@exodus/bytes/base64.js'
+import { fromBase64url, toBase64url } from '@exodus/bytes/base64.js'
+import { fromBase64any } from '@exodus/bytes/base64.js'
+```
+
 ##### `fromBase64(str, { format = 'uint8', padding = 'both' })`
 ##### `fromBase64url(str, { format = 'uint8', padding = false })`
 ##### `fromBase64any(str, { format = 'uint8', padding = 'both' })`
+##### `toBase64(arr, { padding = true })`
+##### `toBase64url(arr, { padding = false })`
 
 ### `@exodus/bytes/base32.js`
 
-##### `toBase32(arr, { padding = false })`
-##### `toBase32hex(arr, { padding = false })`
+```js
+import { fromBase32, toBase32 } from '@exodus/bytes/base32.js'
+import { fromBase32hex, toBase32hex } from '@exodus/bytes/base32.js'
+```
+
 ##### `fromBase32(str, { format = 'uint8', padding = 'both' })`
 ##### `fromBase32hex(str, { format = 'uint8', padding = 'both' })`
+##### `toBase32(arr, { padding = false })`
+##### `toBase32hex(arr, { padding = false })`
 
 ### `@exodus/bytes/bech32.js`
 
+```js
+import { fromBech32, toBech32 } from '@exodus/bytes/bech32.js'
+import { fromBech32m, toBech32m } from '@exodus/bytes/base32.js'
+import { getPrefix } from '@exodus/bytes/base32.js'
+```
+
 ##### `getPrefix(str, limit = 90)`
-##### `toBech32(prefix, bytes, limit = 90)`
+
 ##### `fromBech32(str, limit = 90)`
-##### `toBech32m(prefix, bytes, limit = 90)`
+##### `toBech32(prefix, bytes, limit = 90)`
+
 ##### `fromBech32m(str, limit = 90)`
+##### `toBech32m(prefix, bytes, limit = 90)`
 
 ### `@exodus/bytes/base58.js`
 
-##### `toBase58(arr)`
+```js
+import { fromBase58, toBase58 } from '@exodus/bytes/base58.js'
+import { fromBase58xrp, toBase58xrp } from '@exodus/bytes/base58.js'
+```
+
 ##### `fromBase58(str, format = 'uint8')`
+##### `toBase58(arr)`
 
-##### `toBase58xrp(arr)`
 ##### `fromBase58xrp(str, format = 'uint8')`
+##### `toBase58xrp(arr)`
 
 ### `@exodus/bytes/base58check.js`
 
-##### `async toBase58check(arr)`
-##### `toBase58checkSync(arr)`
+```js
+import { fromBase58check, toBase58check } from '@exodus/bytes/base58check.js'
+import { fromBase58checkSync, toBase58checkSync } from '@exodus/bytes/base58check.js'
+import { makeBase58check } from '@exodus/bytes/base58check.js'
+```
+
+On non-Node.js, requires peer dependency [@exodus/crypto](https://www.npmjs.com/package/@exodus/crypto) to be installed.
+
 ##### `async fromBase58check(str, format = 'uint8')`
+##### `async toBase58check(arr)`
 ##### `fromBase58checkSync(str, format = 'uint8')`
+##### `toBase58checkSync(arr)`
 ##### `makeBase58check(hashAlgo, hashAlgoSync)`
 
 ### `@exodus/bytes/wif.js`
 
+```js
+import { fromWifString, toWifString } from '@exodus/bytes/wif.js'
+import { fromWifStringSync, toWifStringSync } from '@exodus/bytes/wif.js'
+```
+
+On non-Node.js, requires peer dependency [@exodus/crypto](https://www.npmjs.com/package/@exodus/crypto) to be installed.
+
 ##### `async fromWifString(string, version)`
 ##### `fromWifStringSync(string, version)`
 ##### `async toWifString({ version, privateKey, compressed })`
@@ -176,18 +268,18 @@ Same as `windows1252toString = createSinglebyteDecoder('windows-1252')`.
 
 ### `@exodus/bytes/encoding.js`
 
-Implements the [Encoding standard](https://encoding.spec.whatwg.org/):
-[TextDecoder](https://encoding.spec.whatwg.org/#interface-textdecoder),
-[TextEncoder](https://encoding.spec.whatwg.org/#interface-textdecoder),
-some [hooks](https://encoding.spec.whatwg.org/#specification-hooks) (see below).
-
 ```js
-import { TextDecoder, TextDecoder } from '@exodus/bytes/encoding.js'
+import { TextDecoder, TextEncoder } from '@exodus/bytes/encoding.js'
 
 // Hooks for standards
-import { getBOMEncoding, legacyHookDecode, normalizeEncoding } from '@exodus/bytes/encoding.js'
+import { getBOMEncoding, legacyHookDecode, labelToName, normalizeEncoding } from '@exodus/bytes/encoding.js'
 ```
 
+Implements the [Encoding standard](https://encoding.spec.whatwg.org/):
+[TextDecoder](https://encoding.spec.whatwg.org/#interface-textdecoder),
+[TextEncoder](https://encoding.spec.whatwg.org/#interface-textdecoder),
+some [hooks](https://encoding.spec.whatwg.org/#specification-hooks) (see below).
+
 #### `new TextDecoder(label = 'utf-8', { fatal = false, ignoreBOM = false })`
 
 [TextDecoder](https://encoding.spec.whatwg.org/#interface-textdecoder) implementation/polyfill.
@@ -196,10 +288,19 @@ import { getBOMEncoding, legacyHookDecode, normalizeEncoding } from '@exodus/byt
 
 [TextEncoder](https://encoding.spec.whatwg.org/#interface-textdecoder) implementation/polyfill.
 
-#### `normalizeEncoding(label)`
+#### `labelToName(label)`
 
 Implements [get an encoding from a string `label`](https://encoding.spec.whatwg.org/#concept-encoding-get).
 
+Converts an encoding [label](https://encoding.spec.whatwg.org/#names-and-labels) to its name,
+as a case-sensitive string.
+
+If an encoding with that label does not exist, returns `null`.
+
+All encoding names are also valid labels for corresponding encodings.
+
+#### `normalizeEncoding(label)`
+
 Converts an encoding [label](https://encoding.spec.whatwg.org/#names-and-labels) to its name,
 as an ASCII-lowercased string.
 
@@ -211,6 +312,11 @@ except that it:
     [labels](https://encoding.spec.whatwg.org/#ref-for-replacement%E2%91%A1)
  2. Does not throw for invalid labels and instead returns `null`
 
+It is identical to:
+```js
+labelToName(label)?.toLowerCase() ?? null
+```
+
 All encoding names are also valid labels for corresponding encodings.
 
 #### `getBOMEncoding(input)`
@@ -249,10 +355,10 @@ new TextDecoder(getBOMEncoding(input) ?? fallbackEncoding).decode(input)
 ### `@exodus/bytes/encoding-lite.js`
 
 ```js
-import { TextDecoder, TextDecoder } from '@exodus/bytes/encoding-lite.js'
+import { TextDecoder, TextEncoder } from '@exodus/bytes/encoding-lite.js'
 
 // Hooks for standards
-import { getBOMEncoding, legacyHookDecode, normalizeEncoding } from '@exodus/bytes/encoding-lite.js'
+import { getBOMEncoding, legacyHookDecode, labelToName, normalizeEncoding } from '@exodus/bytes/encoding-lite.js'
 ```
 
 The exact same exports as `@exodus/bytes/encoding.js` are also exported as
@@ -264,7 +370,7 @@ and their [labels](https://encoding.spec.whatwg.org/#names-and-labels) when used
 
 Legacy single-byte encodingds are loaded by default in both cases.
 
-`TextEncoder` and hooks for standards (including `normalizeEncoding`) do not have any behavior
+`TextEncoder` and hooks for standards (including `labelToName` / `normalizeEncoding`) do not have any behavior
 differences in the lite version and support full range if inputs.
 
 To avoid inconsistencies, the exported classes and methods are exactly the same objects.
@@ -275,6 +381,7 @@ To avoid inconsistencies, the exported classes and methods are exactly the same
   TextDecoder: [class TextDecoder],
   TextEncoder: [class TextEncoder],
   getBOMEncoding: [Function: getBOMEncoding],
+  labelToName: [Function: labelToName],
   legacyHookDecode: [Function: legacyHookDecode],
   normalizeEncoding: [Function: normalizeEncoding]
 }
@@ -287,6 +394,7 @@ Error: Legacy multi-byte encodings are disabled in /encoding-lite.js, use /encod
   TextDecoder: [class TextDecoder],
   TextEncoder: [class TextEncoder],
   getBOMEncoding: [Function: getBOMEncoding],
+  labelToName: [Function: labelToName],
   legacyHookDecode: [Function: legacyHookDecode],
   normalizeEncoding: [Function: normalizeEncoding]
 }

package/base58check.js

@@ -1,63 +1,12 @@
-import { typedView } from './array.js'
-import { assertUint8 } from './assert.js'
-import { toBase58, fromBase58 } from './base58.js'
 import { hashSync } from '@exodus/crypto/hash' // eslint-disable-line @exodus/import/no-deprecated
+import { makeBase58check } from './fallback/base58check.js'
 
 // Note: while API is async, we use hashSync for now until we improve webcrypto perf for hash256
 // Inputs to base58 are typically very small, and that makes a difference
 
-const E_CHECKSUM = 'Invalid checksum'
-
-// checksum length is 4, i.e. only the first 4 bytes of the hash are used
-
-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)
-  return toBase58(res)
-}
-
-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)]
-}
-
-function assertChecksum(c, r) {
-  if ((c[0] ^ r[0]) | (c[1] ^ r[1]) | (c[2] ^ r[2]) | (c[3] ^ r[3])) throw new Error(E_CHECKSUM)
-}
-
-export const makeBase58check = (hashAlgo, hashAlgoSync) => {
-  const apis = {
-    async encode(arr) {
-      assertUint8(arr)
-      return encodeWithChecksum(arr, await hashAlgo(arr))
-    },
-    async decode(str, format = 'uint8') {
-      const [payload, checksum] = decodeWithChecksum(str)
-      assertChecksum(checksum, await hashAlgo(payload))
-      return typedView(payload, format)
-    },
-  }
-  if (!hashAlgoSync) return apis
-  return {
-    ...apis,
-    encodeSync(arr) {
-      assertUint8(arr)
-      return encodeWithChecksum(arr, hashAlgoSync(arr))
-    },
-    decodeSync(str, format = 'uint8') {
-      const [payload, checksum] = decodeWithChecksum(str)
-      assertChecksum(checksum, hashAlgoSync(payload))
-      return typedView(payload, format)
-    },
-  }
-}
-
 // eslint-disable-next-line @exodus/import/no-deprecated
-const hash256sync = (x) => hashSync('sha256', hashSync('sha256', x, 'uint8'), 'uint8')
+const sha256 = (x) => hashSync('sha256', x, 'uint8')
+const hash256sync = (x) => sha256(sha256(x))
 const hash256 = hash256sync // See note at the top
 const {
   encode: toBase58check,
@@ -66,4 +15,5 @@ const {
   decodeSync: fromBase58checkSync,
 } = makeBase58check(hash256, hash256sync)
 
+export { makeBase58check } from './fallback/base58check.js'
 export { toBase58check, fromBase58check, toBase58checkSync, fromBase58checkSync }

package/base58check.node.js

@@ -0,0 +1,14 @@
+import { hash } from 'node:crypto'
+import { makeBase58check } from './fallback/base58check.js'
+
+const sha256 = (x) => hash('sha256', x, 'buffer')
+const hash256 = (x) => sha256(sha256(x))
+const {
+  encode: toBase58check,
+  decode: fromBase58check,
+  encodeSync: toBase58checkSync,
+  decodeSync: fromBase58checkSync,
+} = makeBase58check(hash256, hash256)
+
+export { makeBase58check } from './fallback/base58check.js'
+export { toBase58check, fromBase58check, toBase58checkSync, fromBase58checkSync }

package/encoding-lite.js

@@ -3,5 +3,6 @@ export {
   TextEncoder,
   normalizeEncoding,
   getBOMEncoding,
+  labelToName,
   legacyHookDecode,
 } from './fallback/encoding.js'

package/encoding.js

@@ -8,5 +8,6 @@ export {
   TextEncoder,
   normalizeEncoding,
   getBOMEncoding,
+  labelToName,
   legacyHookDecode,
 } from './fallback/encoding.js'

package/fallback/_utils.js

@@ -106,7 +106,7 @@ function decodePartTemplates(a, start, end, m) {
 
 const decodePart = isHermes ? decodePartTemplates : decodePartAddition
 export function decode2string(arr, start, end, m) {
-  if (start - end > 30_000) {
+  if (end - start > 30_000) {
     // Limit concatenation to avoid excessive GC
     // Thresholds checked on Hermes for toHex
     const concat = []

package/fallback/base58check.js

@@ -0,0 +1,53 @@
+import { typedView } from '@exodus/bytes/array.js'
+import { toBase58, fromBase58 } from '@exodus/bytes/base58.js'
+import { assertUint8 } from '../assert.js'
+
+const E_CHECKSUM = 'Invalid checksum'
+
+// checksum length is 4, i.e. only the first 4 bytes of the hash are used
+
+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)
+  return toBase58(res)
+}
+
+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)]
+}
+
+function assertChecksum(c, r) {
+  if ((c[0] ^ r[0]) | (c[1] ^ r[1]) | (c[2] ^ r[2]) | (c[3] ^ r[3])) throw new Error(E_CHECKSUM)
+}
+
+export const makeBase58check = (hashAlgo, hashAlgoSync) => {
+  const apis = {
+    async encode(arr) {
+      assertUint8(arr)
+      return encodeWithChecksum(arr, await hashAlgo(arr))
+    },
+    async decode(str, format = 'uint8') {
+      const [payload, checksum] = decodeWithChecksum(str)
+      assertChecksum(checksum, await hashAlgo(payload))
+      return typedView(payload, format)
+    },
+  }
+  if (!hashAlgoSync) return apis
+  return {
+    ...apis,
+    encodeSync(arr) {
+      assertUint8(arr)
+      return encodeWithChecksum(arr, hashAlgoSync(arr))
+    },
+    decodeSync(str, format = 'uint8') {
+      const [payload, checksum] = decodeWithChecksum(str)
+      assertChecksum(checksum, hashAlgoSync(payload))
+      return typedView(payload, format)
+    },
+  }
+}

package/fallback/encoding.js

@@ -47,11 +47,18 @@ export function normalizeEncoding(label) {
 
 const define = (obj, key, value) => Object.defineProperty(obj, key, { value, writable: false })
 
+function isAnyArrayBuffer(x) {
+  if (x instanceof ArrayBuffer) return true
+  if (globalThis.SharedArrayBuffer && x instanceof SharedArrayBuffer) return true
+  if (!x || typeof x.byteLength !== 'number') return false
+  const s = Object.prototype.toString.call(x)
+  return s === '[object ArrayBuffer]' || s === '[object SharedArrayBuffer]'
+}
+
 const fromSource = (x) => {
   if (x instanceof Uint8Array) return x
-  if (x instanceof ArrayBuffer) return new Uint8Array(x)
   if (ArrayBuffer.isView(x)) return new Uint8Array(x.buffer, x.byteOffset, x.byteLength)
-  if (globalThis.SharedArrayBuffer && x instanceof SharedArrayBuffer) return new Uint8Array(x)
+  if (isAnyArrayBuffer(x)) return new Uint8Array(x)
   throw new TypeError('Argument must be a SharedArrayBuffer, ArrayBuffer or ArrayBufferView')
 }
 
@@ -288,3 +295,17 @@ export function legacyHookDecode(input, fallbackEncoding = 'utf-8') {
 
   return createSinglebyteDecoder(enc, true)(u8)
 }
+
+const uppercasePrefixes = new Set(['utf', 'iso', 'koi', 'euc', 'ibm', 'gbk'])
+
+// Unlike normalizeEncoding, case-sensitive
+// https://encoding.spec.whatwg.org/#names-and-labels
+export function labelToName(label) {
+  const enc = normalizeEncoding(label)
+  if (enc === 'utf-8') return 'UTF-8' // fast path
+  if (!enc) return enc
+  if (uppercasePrefixes.has(enc.slice(0, 3))) return enc.toUpperCase()
+  if (enc === 'big5') return 'Big5'
+  if (enc === 'shift_jis') return 'Shift_JIS'
+  return enc
+}

package/fallback/multi-byte.js

@@ -13,7 +13,7 @@ export const E_STRICT = 'Input is not well-formed for this encoding'
 const REP = 0xff_fd
 const mappers = {
   // https://encoding.spec.whatwg.org/#euc-kr-decoder
-  'euc-kr': () => {
+  'euc-kr': (err) => {
     const euc = getTable('euc-kr')
     let lead = 0
 
@@ -24,25 +24,24 @@ const mappers = {
         lead = 0
         if (cp !== undefined && cp !== REP) return cp
         if (b < 128) pushback.push(b)
-        return -2
+        return err()
       }
 
       if (b < 128) return b
-      if (b < 0x81 || b === 0xff) return -2
+      if (b < 0x81 || b === 0xff) return err()
       lead = b
-      return -1
     }
 
     const eof = () => {
       if (!lead) return null
       lead = 0
-      return -2
+      return err()
     }
 
     return { bytes, eof, pushback }
   },
   // https://encoding.spec.whatwg.org/#euc-jp-decoder
-  'euc-jp': () => {
+  'euc-jp': (err) => {
     const jis0208 = getTable('jis0208')
     const jis0212 = getTable('jis0212')
     let j12 = false
@@ -58,7 +57,7 @@ const mappers = {
       if (lead === 0x8f && b >= 0xa1 && b <= 0xfe) {
         j12 = true
         lead = b
-        return -1
+        return
       }
 
       if (lead) {
@@ -71,27 +70,26 @@ const mappers = {
         j12 = false
         if (cp !== undefined && cp !== REP) return cp
         if (b < 128) pushback.push(b)
-        return -2
+        return err()
       }
 
       if (b < 128) return b
-      if ((b < 0xa1 && b !== 0x8e && b !== 0x8f) || b === 0xff) return -2
+      if ((b < 0xa1 && b !== 0x8e && b !== 0x8f) || b === 0xff) return err()
       lead = b
-      return -1
     }
 
     // eslint-disable-next-line sonarjs/no-identical-functions
     const eof = () => {
       if (!lead) return null
       lead = 0
-      return -2
+      return err()
     }
 
     return { bytes, eof, pushback }
   },
   // https://encoding.spec.whatwg.org/#iso-2022-jp-decoder
   // Per-letter of the spec, don't shortcut on state changes on EOF. Some code is regrouped but preserving the logic
-  'iso-2022-jp': () => {
+  'iso-2022-jp': (err) => {
     const jis0208 = getTable('jis0208')
     const EOF = -1
     let dState = 1
@@ -105,7 +103,7 @@ const mappers = {
         if (b === EOF) return null
         if (b === 0x1b) {
           dState = 6 // escape start
-          return -1
+          return
         }
       }
 
@@ -120,49 +118,46 @@ const mappers = {
           }
 
           if (b <= 0x7f && b !== 0x0e && b !== 0x0f) return b
-          return -2
+          return err()
         case 3:
           // Katakana
           out = false
           if (b >= 0x21 && b <= 0x5f) return 0xff_40 + b
-          return -2
+          return err()
         case 4:
           // Leading byte
           out = false
-          if ((b >= 0x21) & (b <= 0x7e)) {
-            lead = b
-            dState = 5
-            return -1
-          }
-
-          return -2
+          if (b < 0x21 || b > 0x7e) return err()
+          lead = b
+          dState = 5
+          return
         case 5:
           // Trailing byte
           out = false
           if (b === 0x1b) {
             dState = 6 // escape start
-            return -2
+            return err()
           }
 
           dState = 4
           if (b >= 0x21 && b <= 0x7e) {
             const cp = jis0208[(lead - 0x21) * 94 + b - 0x21]
-            return cp !== undefined && cp !== REP ? cp : -2
+            if (cp !== undefined && cp !== REP) return cp
           }
 
-          return -2
+          return err()
         case 6:
           // Escape start
           if (b === 0x24 || b === 0x28) {
             lead = b
             dState = 7
-            return -1
+            return
           }
 
           out = false
           dState = oState
           if (b !== EOF) pushback.push(b)
-          return -2
+          return err()
         case 7: {
           // Escape
           const l = lead
@@ -185,14 +180,14 @@ const mappers = {
             dState = oState = s
             const output = out
             out = true
-            return output ? -2 : -1
+            return output ? err() : undefined
           }
 
           out = false
           dState = oState
           if (b !== EOF) pushback.push(b)
           pushback.push(l)
-          return -2
+          return err()
         }
       }
     }
@@ -202,7 +197,7 @@ const mappers = {
     return { bytes, eof, pushback }
   },
   // https://encoding.spec.whatwg.org/#shift_jis-decoder
-  shift_jis: () => {
+  shift_jis: (err) => {
     const jis0208 = getTable('jis0208')
     let lead = 0
 
@@ -219,29 +214,28 @@ const mappers = {
         }
 
         if (b < 128) pushback.push(b)
-        return -2
+        return err()
       }
 
       if (b <= 0x80) return b // 0x80 is allowed
       if (b >= 0xa1 && b <= 0xdf) return 0xff_61 - 0xa1 + b
-      if (b < 0x81 || (b > 0x9f && b < 0xe0) || b > 0xfc) return -2
+      if (b < 0x81 || (b > 0x9f && b < 0xe0) || b > 0xfc) return err()
       lead = b
-      return -1
     }
 
     // eslint-disable-next-line sonarjs/no-identical-functions
     const eof = () => {
       if (!lead) return null
       lead = 0 // this clears state completely on EOF
-      return -2
+      return err()
     }
 
     return { bytes, eof, pushback }
   },
   // https://encoding.spec.whatwg.org/#gbk-decoder
-  gbk: () => mappers.gb18030(), // 10.1.1. GBK’s decoder is gb18030’s decoder
+  gbk: (err) => mappers.gb18030(err), // 10.1.1. GBK’s decoder is gb18030’s decoder
   // https://encoding.spec.whatwg.org/#gb18030-decoder
-  gb18030: () => {
+  gb18030: (err) => {
     const gb18030 = getTable('gb18030')
     const gb18030r = getTable('gb18030-ranges')
     let g1 = 0, g2 = 0, g3 = 0 // prettier-ignore
@@ -264,30 +258,30 @@ const mappers = {
         if (b < 0x30 || b > 0x39) {
           pushback.push(b, g3, g2)
           g1 = g2 = g3 = 0
-          return -2
+          return err()
         }
 
         const cp = index((g1 - 0x81) * 12_600 + (g2 - 0x30) * 1260 + (g3 - 0x81) * 10 + b - 0x30)
         g1 = g2 = g3 = 0
         if (cp !== undefined) return cp // Can validly return replacement
-        return -2
+        return err()
       }
 
       if (g2) {
         if (b >= 0x81 && b <= 0xfe) {
           g3 = b
-          return -1
+          return
         }
 
         pushback.push(b, g2)
         g1 = g2 = 0
-        return -2
+        return err()
       }
 
       if (g1) {
         if (b >= 0x30 && b <= 0x39) {
           g2 = b
-          return -1
+          return
         }
 
         let cp
@@ -298,20 +292,19 @@ const mappers = {
         g1 = 0
         if (cp !== undefined && cp !== REP) return cp
         if (b < 128) pushback.push(b)
-        return -2
+        return err()
       }
 
       if (b < 128) return b
       if (b === 0x80) return 0x20_ac
-      if (b === 0xff) return -2
+      if (b === 0xff) return err()
       g1 = b
-      return -1
     }
 
     const eof = () => {
       if (!g1 && !g2 && !g3) return null
       g1 = g2 = g3 = 0
-      return -2
+      return err()
     }
 
     return { bytes, eof, pushback }
@@ -329,7 +322,7 @@ export function multibyteDecoder(enc, loose = false) {
   const asciiSuperset = isAsciiSuperset(enc)
   return (arr, stream = false) => {
     const onErr = loose
-      ? () => '\uFFFD'
+      ? () => REP
       : () => {
           mapper.pushback.length = 0 // the queue is cleared on returning an error
           // The correct way per spec seems to be not destoying the decoder state in stream mode, even when fatal
@@ -346,7 +339,7 @@ export function multibyteDecoder(enc, loose = false) {
       if (res.length === arr.length) return res // ascii
     }
 
-    if (!mapper) mapper = mappers[enc]()
+    if (!mapper) mapper = mappers[enc](onErr)
     const { bytes, eof, pushback } = mapper
     let i = res.length
 
@@ -354,11 +347,8 @@ export function multibyteDecoder(enc, loose = false) {
     // Same as the full loop, but without EOF handling
     while (i < length || pushback.length > 0) {
       const c = bytes(pushback.length > 0 ? pushback.pop() : arr[i++])
-      if (c >= 0) {
-        res += String.fromCodePoint(c) // gb18030 returns codepoints above 0xFFFF from ranges
-      } else if (c === -2) {
-        res += onErr()
-      }
+      if (c === undefined) continue // consuming
+      res += String.fromCodePoint(c) // gb18030 returns codepoints above 0xFFFF from ranges
     }
 
     // Then, dump EOF. This needs the same loop as the characters can be pushed back
@@ -368,12 +358,8 @@ export function multibyteDecoder(enc, loose = false) {
         const isEOF = i === length && pushback.length === 0
         const c = isEOF ? eof() : bytes(pushback.length > 0 ? pushback.pop() : arr[i++])
         if (isEOF && c === null) break // clean exit
-        if (c === -1) continue // consuming
-        if (c === -2) {
-          res += onErr()
-        } else {
-          res += String.fromCodePoint(c) // gb18030 returns codepoints above 0xFFFF from ranges
-        }
+        if (c === undefined) continue // consuming
+        res += String.fromCodePoint(c) // gb18030 returns codepoints above 0xFFFF from ranges
       }
     }
 
@@ -392,12 +378,10 @@ function big5decoder(loose) {
   // Input is assumed to be typechecked already
   let lead = 0
   let big5
-  const pushback = []
   return (arr, stream = false) => {
     const onErr = loose
       ? () => '\uFFFD'
       : () => {
-          pushback.length = 0 // the queue is cleared on returning an error
           // Lead is always already cleared before throwing
           throw new TypeError(E_STRICT)
         }
@@ -410,8 +394,8 @@ function big5decoder(loose) {
     }
 
     if (!big5) big5 = getTable('big5')
-    for (let i = res.length; i < length || pushback.length > 0; ) {
-      const b = pushback.length > 0 ? pushback.pop() : arr[i++]
+    for (let i = res.length; i < length; i++) {
+      const b = arr[i]
       if (lead) {
         let cp
         if ((b >= 0x40 && b <= 0x7e) || (b >= 0xa1 && b !== 0xff)) {
@@ -423,7 +407,8 @@ function big5decoder(loose) {
           res += cp // strings
         } else {
           res += onErr()
-          if (b < 128) pushback.push(b)
+          // same as pushing it back: lead is cleared, pushed back can't contain more than 1 byte
+          if (b < 128) res += String.fromCharCode(b)
         }
       } else if (b < 128) {
         res += String.fromCharCode(b)
@@ -434,13 +419,10 @@ function big5decoder(loose) {
       }
     }
 
-    if (!stream) {
+    if (!stream && lead) {
       // Destroy decoder state
-      pushback.length = 0
-      if (lead) {
-        lead = 0
-        res += onErr()
-      }
+      lead = 0
+      res += onErr()
     }
 
     return res

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/bytes",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "Various operations on Uint8Array data",
   "scripts": {
     "lint": "eslint .",
@@ -45,6 +45,7 @@
   "files": [
     "/fallback/_utils.js",
     "/fallback/base32.js",
+    "/fallback/base58check.js",
     "/fallback/base64.js",
     "/fallback/encoding.js",
     "/fallback/encoding.labels.js",
@@ -65,6 +66,7 @@
     "/base32.js",
     "/base58.js",
     "/base58check.js",
+    "/base58check.node.js",
     "/base64.js",
     "/base64.d.ts",
     "/bech32.js",
@@ -92,7 +94,10 @@
     },
     "./base32.js": "./base32.js",
     "./base58.js": "./base58.js",
-    "./base58check.js": "./base58check.js",
+    "./base58check.js": {
+      "node": "./base58check.node.js",
+      "default": "./base58check.js"
+    },
     "./base64.js": {
       "types": "./base64.d.ts",
       "default": "./base64.js"

package/utf16.js

@@ -9,7 +9,7 @@ const decoderFatalBE = canDecoders ? new TextDecoder('utf-16be', { ignoreBOM, fa
 const decoderLooseBE = canDecoders ? new TextDecoder('utf-16be', { ignoreBOM }) : null
 const decoderFatal16 = isLE ? decoderFatalLE : decoderFatalBE
 const decoderLoose16 = isLE ? decoderLooseLE : decoderFatalBE
-const { isWellFormed } = String.prototype
+const { isWellFormed, toWellFormed } = String.prototype
 
 const { E_STRICT, E_STRICT_UNICODE } = js
 
@@ -61,8 +61,9 @@ function decode(input, loose = false, format = 'uint16') {
       throw new TypeError('Unknown format')
   }
 
-  const str = js.decode(u16, loose, !loose && isWellFormed)
+  const str = js.decode(u16, loose, (!loose && isWellFormed) || (loose && toWellFormed))
   if (!loose && isWellFormed && !isWellFormed.call(str)) throw new TypeError(E_STRICT)
+  if (loose && toWellFormed) return toWellFormed.call(str)
 
   return str
 }

package/utf16.node.js

@@ -1,9 +1,9 @@
-import { nativeDecoder, isDeno, isLE } from './fallback/_utils.js'
+import { 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 { isWellFormed, toWellFormed } = String.prototype
 const to8 = (a) => new Uint8Array(a.buffer, a.byteOffset, a.byteLength)
 
 // Unlike utf8, operates on Uint16Arrays by default
@@ -14,9 +14,10 @@ function encode(str, loose = false, format = 'uint16') {
     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)
+  if (loose) {
+    str = toWellFormed.call(str) // Buffer doesn't do this with utf16 encoding
+  } else if (!isWellFormed.call(str)) {
+    throw new TypeError(E_STRICT_UNICODE)
   }
 
   const ble = Buffer.from(str, 'utf-16le')
@@ -51,9 +52,9 @@ function decodeNode(input, loose = false, format = 'uint16') {
   }
 
   const str = ble.ucs2Slice(0, ble.byteLength)
+  if (loose) return toWellFormed.call(str)
   if (isWellFormed.call(str)) return str
-  if (!loose) throw new TypeError(E_STRICT)
-  return nativeDecoder.decode(Buffer.from(str)) // fixup (see above)
+  throw new TypeError(E_STRICT)
 }
 
 function decodeDecoder(input, loose = false, format = 'uint16') {

package/wif.js

@@ -1,4 +1,4 @@
-import { toBase58checkSync, fromBase58checkSync } from './base58check.js'
+import { toBase58checkSync, fromBase58checkSync } from '@exodus/bytes/base58check.js'
 import { assertUint8 } from './assert.js'
 
 // Mostly matches npmjs.com/wif, but with extra checks + using our base58check