@bsv/sdk 1.9.31 → 2.0.0-beta.0

package/docs/reference/messages.md

@@ -2,30 +2,6 @@
 
 Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Variables](#variables)
 
-## Security Considerations for Encrypted Messages
-
-The encrypted message protocol implemented in this SDK derives per-message
-encryption keys deterministically from the parties’ long-term keys and a
-caller-supplied invoice number (BRC-42 style derivation).
-
-This construction does **not** provide the guarantees of a standard
-authenticated key exchange (AKE). In particular:
-
-- **No forward secrecy**: Compromise of a long-term private key compromises
-  all past and future messages derived from it.
-- **No replay protection**: Messages encrypted under the same invoice number
-  and key pair can be replayed.
-- **Potential identity misbinding**: Public keys alone do not guarantee peer
-  identity without additional authentication or identity verification.
-
-This protocol is intended for lightweight, deterministic messaging between
-parties that already trust each other’s long-term public keys. It SHOULD NOT
-be used for high-security or high-value communications without additional
-protocol-layer protections.
-
-Applications requiring strong authentication, replay protection, or forward
-secrecy should use a formally analyzed protocol such as X3DH, Noise, or SIGMA.
-
 ## Interfaces
 
 ## Classes

package/docs/reference/primitives.md

@@ -4961,14 +4961,14 @@ Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](
 
 | | |
 | --- | --- |
-| [AES](#function-aes) | [pbkdf2](#function-pbkdf2) |
-| [AESGCM](#function-aesgcm) | [realHtonl](#function-realhtonl) |
-| [AESGCMDecrypt](#function-aesgcmdecrypt) | [red](#function-red) |
-| [assertValidHex](#function-assertvalidhex) | [swapBytes32](#function-swapbytes32) |
-| [base64ToArray](#function-base64toarray) | [toArray](#function-toarray) |
+| [AES](#function-aes) | [normalizeHex](#function-normalizehex) |
+| [AESGCM](#function-aesgcm) | [pbkdf2](#function-pbkdf2) |
+| [AESGCMDecrypt](#function-aesgcmdecrypt) | [realHtonl](#function-realhtonl) |
+| [assertValidHex](#function-assertvalidhex) | [red](#function-red) |
+| [base64ToArray](#function-base64toarray) | [swapBytes32](#function-swapbytes32) |
+| [constantTimeEquals](#function-constanttimeequals) | [toArray](#function-toarray) |
 | [ghash](#function-ghash) | [toBase64](#function-tobase64) |
 | [htonl](#function-htonl) | [verifyNotNull](#function-verifynotnull) |
-| [normalizeHex](#function-normalizehex) |  |
 
 Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Enums](#enums), [Variables](#variables)
 
@@ -5067,6 +5067,15 @@ export function base64ToArray(msg: string): number[]
 
 Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Enums](#enums), [Variables](#variables)
 
+---
+### Function: constantTimeEquals
+
+```ts
+export function constantTimeEquals(a: Uint8Array | number[], b: Uint8Array | number[]): boolean 
+```
+
+Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Enums](#enums), [Variables](#variables)
+
 ---
 ### Function: ghash
 
@@ -5736,7 +5745,7 @@ Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](
 ```ts
 incrementLeastSignificantThirtyTwoBits = function (block: Bytes): Bytes {
     const result = block.slice();
-    for (let i = 15; i !== 11; i--) {
+    for (let i = 15; i > 11; i--) {
         result[i] = (result[i] + 1) & 255;
         if (result[i] !== 0) {
             break;
@@ -6265,81 +6274,7 @@ Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](
 
 ```ts
 toUTF8 = (arr: number[]): string => {
-    let result = "";
-    const replacementChar = "\uFFFD";
-    for (let i = 0; i < arr.length; i++) {
-        const byte1 = arr[i];
-        if (byte1 <= 127) {
-            result += String.fromCharCode(byte1);
-            continue;
-        }
-        const emitReplacement = (): void => {
-            result += replacementChar;
-        };
-        if (byte1 >= 192 && byte1 <= 223) {
-            if (i + 1 >= arr.length) {
-                emitReplacement();
-                continue;
-            }
-            const byte2 = arr[i + 1];
-            if ((byte2 & 192) !== 128) {
-                emitReplacement();
-                i += 1;
-                continue;
-            }
-            const codePoint = ((byte1 & 31) << 6) | (byte2 & 63);
-            result += String.fromCharCode(codePoint);
-            i += 1;
-            continue;
-        }
-        if (byte1 >= 224 && byte1 <= 239) {
-            if (i + 2 >= arr.length) {
-                emitReplacement();
-                continue;
-            }
-            const byte2 = arr[i + 1];
-            const byte3 = arr[i + 2];
-            if ((byte2 & 192) !== 128 || (byte3 & 192) !== 128) {
-                emitReplacement();
-                i += 2;
-                continue;
-            }
-            const codePoint = ((byte1 & 15) << 12) |
-                ((byte2 & 63) << 6) |
-                (byte3 & 63);
-            result += String.fromCharCode(codePoint);
-            i += 2;
-            continue;
-        }
-        if (byte1 >= 240 && byte1 <= 247) {
-            if (i + 3 >= arr.length) {
-                emitReplacement();
-                continue;
-            }
-            const byte2 = arr[i + 1];
-            const byte3 = arr[i + 2];
-            const byte4 = arr[i + 3];
-            if ((byte2 & 192) !== 128 ||
-                (byte3 & 192) !== 128 ||
-                (byte4 & 192) !== 128) {
-                emitReplacement();
-                i += 3;
-                continue;
-            }
-            const codePoint = ((byte1 & 7) << 18) |
-                ((byte2 & 63) << 12) |
-                ((byte3 & 63) << 6) |
-                (byte4 & 63);
-            const offset = codePoint - 65536;
-            const highSurrogate = 55296 + (offset >> 10);
-            const lowSurrogate = 56320 + (offset & 1023);
-            result += String.fromCharCode(highSurrogate, lowSurrogate);
-            i += 3;
-            continue;
-        }
-        emitReplacement();
-    }
-    return result;
+    return new TextDecoder().decode(new Uint8Array(arr));
 }
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bsv/sdk",
-  "version": "1.9.31",
+  "version": "2.0.0-beta.0",
   "type": "module",
   "description": "BSV Blockchain Software Development Kit",
   "main": "dist/cjs/mod.js",
@@ -221,8 +221,7 @@
     "prepublish": "npm run build",
     "doc": "ts2md",
     "docs:serve": "mkdocs serve",
-    "docs:build": "mkdocs build",
-    "test:ci": "npm run build && jest --forceExit"
+    "docs:build": "mkdocs build"
   },
   "repository": {
     "type": "git",

package/src/auth/Peer.ts

@@ -525,7 +525,10 @@ export class Peer {
 
     // Create signature
     const { signature } = await this.wallet.createSignature({
-      data: Peer.base64ToBytes(message.initialNonce + sessionNonce),
+      data: [
+        ...Peer.base64ToBytes(message.initialNonce),
+        ...Peer.base64ToBytes(sessionNonce)
+      ],
       protocolID: [2, 'auth message signature'],
       keyID: `${message.initialNonce} ${sessionNonce}`,
       counterparty: message.identityKey

package/src/messages/EncryptedMessage.ts

@@ -14,25 +14,6 @@ const VERSION = '42421033'
  *
  * @returns The encrypted message
  */
-/**
- * SECURITY NOTE – NON-AUTHENTICATED KEY EXCHANGE
- *
- * This encrypted message protocol does NOT implement a formally authenticated
- * key exchange (AKE). Session keys are deterministically derived from long-term
- * identity keys and a sender-chosen invoice value.
- *
- * As a result, this protocol does NOT provide:
- *  - Forward secrecy
- *  - Replay protection
- *  - Explicit authentication of peer identity
- *
- * This scheme SHOULD NOT be used for high-value, long-lived, or sensitive
- * communications. It is intended for lightweight messaging where both parties
- * already possess each other's long-term public keys and accept these risks.
- *
- * Future versions may introduce a protocol upgrade based on a standard AKE
- * (e.g. X3DH, Noise, or SIGMA).
- */
 export const encrypt = (
   message: number[],
   sender: PrivateKey,

package/src/primitives/AESGCM.ts

@@ -1,31 +1,5 @@
-// @ts-nocheck
 
-// NOTE:
-// Table-based AES is intentionally retained for performance.
-// JavaScript runtimes (JIT, GC, speculative execution) cannot provide
-// strong constant-time guarantees, and arithmetic-only AES implementations
-// cause catastrophic performance degradation in practice.
-//
-// This implementation therefore prioritizes correctness, performance,
-// and compatibility over attempting misleading "constant-time" behavior.
-//
-// Applications requiring strict side-channel resistance SHOULD use
-// platform-native crypto APIs (e.g. WebCrypto) or audited native libraries.
-/**
- * SECURITY DISCLAIMER – AES-GCM IMPLEMENTATION
- *
- * This module provides a self-contained AES-GCM implementation intended for
- * functional correctness and portability with minimal dependencies.
- *
- * While efforts are made to reduce timing side-channel leakage (e.g. avoiding
- * secret-dependent branches in GHASH), JavaScript does not guarantee
- * constant-time execution. As such, this implementation should not be used in
- * environments where attackers can reliably measure fine-grained execution
- * timing (e.g. shared hosts, co-resident VMs, or untrusted browser contexts).
- *
- * For high-assurance cryptographic use cases, prefer platform-provided
- * WebCrypto APIs or well-audited constant-time libraries.
- */
+// @ts-nocheck
 const SBox = new Uint8Array([
   0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
   0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
@@ -44,7 +18,6 @@ const SBox = new Uint8Array([
   0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
   0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16
 ])
-
 const Rcon = [
   [0x00, 0x00, 0x00, 0x00], [0x01, 0x00, 0x00, 0x00], [0x02, 0x00, 0x00, 0x00], [0x04, 0x00, 0x00, 0x00],
   [0x08, 0x00, 0x00, 0x00], [0x10, 0x00, 0x00, 0x00], [0x20, 0x00, 0x00, 0x00], [0x40, 0x00, 0x00, 0x00],
@@ -59,20 +32,6 @@ for (let i = 0; i < 256; i++) {
   mul3[i] = m2 ^ i
 }
 
-function mixColumnsFast (state: number[][]): void {
-  for (let c = 0; c < 4; c++) {
-    const s0 = state[0][c]
-    const s1 = state[1][c]
-    const s2 = state[2][c]
-    const s3 = state[3][c]
-
-    state[0][c] = mul2[s0] ^ mul3[s1] ^ s2 ^ s3
-    state[1][c] = s0 ^ mul2[s1] ^ mul3[s2] ^ s3
-    state[2][c] = s0 ^ s1 ^ mul2[s2] ^ mul3[s3]
-    state[3][c] = mul3[s0] ^ s1 ^ s2 ^ mul2[s3]
-  }
-}
-
 function addRoundKey (
   state: number[][],
   roundKeyArray: number[][],
@@ -130,6 +89,20 @@ function shiftRows (state: number[][]): void {
   state[3][0] = tmp
 }
 
+function mixColumns (state: number[][]): void {
+  for (let c = 0; c < 4; c++) {
+    const s0 = state[0][c]
+    const s1 = state[1][c]
+    const s2 = state[2][c]
+    const s3 = state[3][c]
+
+    state[0][c] = mul2[s0] ^ mul3[s1] ^ s2 ^ s3
+    state[1][c] = s0 ^ mul2[s1] ^ mul3[s2] ^ s3
+    state[2][c] = s0 ^ s1 ^ mul2[s2] ^ mul3[s3]
+    state[3][c] = mul3[s0] ^ s1 ^ s2 ^ mul2[s3]
+  }
+}
+
 function keyExpansion (roundLimit: number, key: number[]): number[][] {
   const nK = key.length / 4
   const result: number[][] = []
@@ -197,7 +170,7 @@ export function AES (input: number[], key: number[]): number[] {
     shiftRows(state)
 
     if (round + 1 < roundLimit) {
-      mixColumnsFast(state)
+      mixColumns(state)
     }
 
     addRoundKey(state, w, round * 4)
@@ -285,6 +258,12 @@ export const exclusiveOR = function (block0: Bytes, block1: Bytes): Bytes {
   return result
 }
 
+const xorInto = function (target: Bytes, block: Bytes): void {
+  for (let i = 0; i < target.length; i++) {
+    target[i] ^= block[i] ?? 0
+  }
+}
+
 export const rightShift = function (block: Bytes): Bytes {
   let carry = 0
   let oldCarry = 0
@@ -302,48 +281,25 @@ export const rightShift = function (block: Bytes): Bytes {
   return block
 }
 
-/**
- * SECURITY NOTE – TIMING SIDE-CHANNEL MITIGATION
- *
- * This GHASH multiplication implementation avoids data-dependent conditional
- * branches by using mask-based operations instead. This reduces timing
- * side-channel leakage compared to a naive implementation that branches on
- * secret bits.
- *
- * IMPORTANT: JavaScript and TypedArray operations do NOT provide constant-time
- * execution guarantees. While this implementation mitigates obvious control-
- * flow timing leaks, it must not be considered constant-time in a strict
- * cryptographic sense and is not suitable for hostile shared-CPU or
- * multi-tenant environments.
- *
- * Applications requiring strict constant-time AES-GCM SHOULD use a dedicated,
- * audited cryptographic library (e.g. noble-ciphers, WebCrypto, or BearSSL
- * bindings).
- */
 export const multiply = function (block0: Bytes, block1: Bytes): Bytes {
   const v = block1.slice()
   const z = createZeroBlock(16)
 
   for (let i = 0; i < 16; i++) {
-    const b = block0[i]
     for (let j = 7; j >= 0; j--) {
-      // mask = 0xff if bit is set, 0x00 otherwise
-      const bit = (b >> j) & 1
-      const mask = -bit & 0xff
-      // z ^= v & mask
-      for (let k = 0; k < 16; k++) {
-        z[k] ^= v[k] & mask
+      if ((block0[i] & (1 << j)) !== 0) {
+        xorInto(z, v)
       }
-      // compute reduction mask
-      const lsb = v[15] & 1
-      const rmask = -lsb & 0xff
-      rightShift(v)
-      // v ^= R & rmask
-      for (let k = 0; k < 16; k++) {
-        v[k] ^= R[k] & rmask
+
+      if ((v[15] & 1) !== 0) {
+        rightShift(v)
+        xorInto(v, R)
+      } else {
+        rightShift(v)
       }
     }
   }
+
   return z
 }
 
@@ -351,12 +307,15 @@ export const incrementLeastSignificantThirtyTwoBits = function (
   block: Bytes
 ): Bytes {
   const result = block.slice()
+
   for (let i = 15; i > 11; i--) {
     result[i] = (result[i] + 1) & 0xff // wrap explicitly
+
     if (result[i] !== 0) {
       break
     }
   }
+
   return result
 }
 

package/src/primitives/PrivateKey.ts

@@ -355,33 +355,6 @@ export default class PrivateKey extends BigNumber {
     return key.mulCT(this)
   }
 
-  /**
-   * SECURITY NOTE – DETERMINISTIC CHILD KEY DERIVATION
-   *
-   * This method derives child private keys deterministically from the caller’s
-   * long-term private key, the counterparty’s public key, and a caller-supplied
-   * invoice number using HMAC over an ECDH shared secret (BRC-42 style derivation).
-   *
-   * This construction does NOT implement a formally authenticated key exchange
-   * (AKE) and does NOT provide the following security properties:
-   *
-   *  - Forward secrecy: Compromise of a long-term private key compromises all
-   *    past and future child keys derived from it.
-   *  - Replay protection: Child keys are deterministic for a given invoice
-   *    number and key pair; previously observed messages can be replayed.
-   *  - Explicit authentication / identity binding: Possession of a public key
-   *    alone does not guarantee the intended peer identity, enabling potential
-   *    identity misbinding attacks if higher-level identity verification is absent.
-   *
-   * This derivation is intended for lightweight, deterministic key hierarchies
-   * where both parties already possess and trust each other’s long-term public
-   * keys. It SHOULD NOT be used as a drop-in replacement for a standard
-   * authenticated key exchange (e.g. X3DH, Noise, or SIGMA) in high-security or
-   * high-value contexts.
-   *
-   * Any future protocol providing forward secrecy, replay protection, or strong
-   * peer authentication will require a versioned, breaking change.
-   */
   /**
    * Derives a child key with BRC-42.
    * @param publicKey The public key of the other party

package/src/primitives/__tests/AESGCM.test.ts

@@ -598,34 +598,3 @@ describe('AESGCM large input (non-mocked)', () => {
     expectUint8ArrayEqual(decryptedBytes, plaintext)
   })
 })
-
-describe('multiply reduction edge cases', () => {
-  it('applies reduction polynomial when LSB carry is set', () => {
-    // Force reduction path by setting v[15] LSB = 1
-    const a = new Uint8Array(16)
-    a[0] = 0x01
-
-    const b = new Uint8Array(16)
-    b[15] = 0x01
-
-    const out = multiply(a, b)
-
-    // We don't assert a magic value — we assert that output is non-zero
-    // and stable across runs (reduction happened)
-    expect(out.some(v => v !== 0)).toBe(true)
-  })
-
-  it('does not reduce when LSB carry is zero', () => {
-    const a = new Uint8Array(16)
-    a[0] = 0x01
-
-    const b = new Uint8Array(16)
-    b[15] = 0x00
-
-    const out = multiply(a, b)
-
-    expect(out.some(v => v !== 0)).toBe(false)
-  })
-})
-
-

package/src/primitives/__tests/utils.test.ts

@@ -323,13 +323,17 @@ describe('verifyNotNull', () => {
   })
 })
 
-describe('toUTF8 strict UTF-8 decoding (TOB-21)', () => {
+describe('toUTF8 UTF-8 decoding', () => {
 
-  it('replaces invalid 2-byte sequences with U+FFFD', () => {
+  it('decodes ASCII bytes', () => {
+    expect(toUTF8([0x48, 0x65, 0x6c, 0x6c, 0x6f])).toBe('Hello')
+  })
+
+  it('replaces invalid 2-byte sequences with U+FFFD and continues decoding', () => {
     // 0xC2 should expect a continuation byte 0x80–0xBF
     const arr = [0xC2, 0x20]   // 0x20 is INVALID continuation
     const str = toUTF8(arr)
-    expect(str).toBe('\uFFFD')
+    expect(str).toBe('\uFFFD ')
   })
 
   it('decodes valid 3-byte sequences', () => {
@@ -337,10 +341,10 @@ describe('toUTF8 strict UTF-8 decoding (TOB-21)', () => {
     expect(toUTF8(euro)).toBe('€')
   })
 
-  it('replaces invalid 3-byte sequences', () => {
+  it('replaces invalid 3-byte sequences with U+FFFD and continues decoding', () => {
     // Middle byte invalid
     const arr = [0xE2, 0x20, 0xAC]
-    expect(toUTF8(arr)).toBe('\uFFFD')
+    expect(toUTF8(arr)).toBe('\uFFFD \uFFFD')
   })
 
   it('decodes valid 4-byte sequences into surrogate pairs', () => {
@@ -348,10 +352,10 @@ describe('toUTF8 strict UTF-8 decoding (TOB-21)', () => {
     expect(toUTF8(smile)).toBe('😀')
   })
 
-  it('replaces invalid 4-byte sequences with U+FFFD', () => {
+  it('replaces invalid 4-byte sequences with U+FFFD and continues decoding', () => {
     // 0x9F is valid, 0x20 is INVALID continuation for byte 3
     const arr = [0xF0, 0x9F, 0x20, 0x80]
-    expect(toUTF8(arr)).toBe('\uFFFD')
+    expect(toUTF8(arr)).toBe('\uFFFD \uFFFD')
   })
 
   it('replaces incomplete UTF-8 sequence at end', () => {
@@ -359,6 +363,25 @@ describe('toUTF8 strict UTF-8 decoding (TOB-21)', () => {
     expect(toUTF8(arr)).toBe('\uFFFD')
   })
 
+  it('replaces overlong sequences with U+FFFD', () => {
+    expect(toUTF8([0xC0, 0xAF])).toBe('\uFFFD\uFFFD')
+  })
+
+  it('replaces UTF-8 encoded surrogates with U+FFFD', () => {
+    expect(toUTF8([0xED, 0xA0, 0x80])).toBe('\uFFFD\uFFFD\uFFFD')
+  })
+
+})
+
+describe("toArray('utf8') UTF-8 encoding", () => {
+  it('round-trips UTF-8 strings', () => {
+    const s = 'Hello € 😀'
+    expect(toUTF8(toArray(s, 'utf8') as number[])).toBe(s)
+  })
+
+  it('replaces lone surrogates with U+FFFD when encoding', () => {
+    expect(toArray('\uD800', 'utf8')).toEqual([0xEF, 0xBF, 0xBD])
+  })
 })
 
 describe('Point.encode infinity handling', () => {

package/src/primitives/utils.ts

@@ -168,53 +168,7 @@ export function base64ToArray (msg: string): number[] {
  * @returns An array of numbers, each representing a byte in the UTF-8 encoded string.
  */
 function utf8ToArray (str: string): number[] {
-  const result: number[] = []
-
-  for (let i = 0; i < str.length; i++) {
-    const cp = str.codePointAt(i)
-    if (cp === undefined) {
-      // Should never be out of range.
-      throw new Error(`Index out of range: ${i}`)
-    }
-    let codePoint = cp
-
-    if (codePoint > 0xFFFF) {
-      // Valid surrogate pair => skip the next code unit because codePointAt
-      // has already combined them into a single code point.
-      i++
-    } else {
-      // Check if codePoint is a lone (unpaired) high surrogate or low surrogate.
-      if (codePoint >= 0xD800 && codePoint <= 0xDFFF) {
-        // Replace with the replacement character (U+FFFD).
-        codePoint = 0xFFFD
-      }
-    }
-
-    // Encode according to the UTF-8 standard
-    if (codePoint <= 0x7F) {
-      result.push(codePoint)
-    } else if (codePoint <= 0x7FF) {
-      result.push(
-        0xC0 | (codePoint >> 6),
-        0x80 | (codePoint & 0x3F)
-      )
-    } else if (codePoint <= 0xFFFF) {
-      result.push(
-        0xE0 | (codePoint >> 12),
-        0x80 | ((codePoint >> 6) & 0x3F),
-        0x80 | (codePoint & 0x3F)
-      )
-    } else {
-      result.push(
-        0xF0 | (codePoint >> 18),
-        0x80 | ((codePoint >> 12) & 0x3F),
-        0x80 | ((codePoint >> 6) & 0x3F),
-        0x80 | (codePoint & 0x3F)
-      )
-    }
-  }
-
-  return result
+  return Array.from(new TextEncoder().encode(str))
 }
 
 /**
@@ -223,86 +177,7 @@ function utf8ToArray (str: string): number[] {
  * @returns {string} - The UTF-8 encoded string.
  */
 export const toUTF8 = (arr: number[]): string => {
-  let result = ''
-  const replacementChar = '\uFFFD'
-  for (let i = 0; i < arr.length; i++) {
-    const byte1 = arr[i]
-    if (byte1 <= 0x7f) {
-      result += String.fromCharCode(byte1)
-      continue
-    }
-    const emitReplacement = (): void => {
-      result += replacementChar
-    }
-    if (byte1 >= 0xc0 && byte1 <= 0xdf) {
-      if (i + 1 >= arr.length) {
-        emitReplacement()
-        continue
-      }
-      const byte2 = arr[i + 1]
-      if ((byte2 & 0xc0) !== 0x80) {
-        emitReplacement()
-        i += 1
-        continue
-      }
-      const codePoint = ((byte1 & 0x1f) << 6) | (byte2 & 0x3f)
-      result += String.fromCharCode(codePoint)
-      i += 1
-      continue
-    }
-    if (byte1 >= 0xe0 && byte1 <= 0xef) {
-      if (i + 2 >= arr.length) {
-        emitReplacement()
-        continue
-      }
-      const byte2 = arr[i + 1]
-      const byte3 = arr[i + 2]
-      if ((byte2 & 0xc0) !== 0x80 || (byte3 & 0xc0) !== 0x80) {
-        emitReplacement()
-        i += 2
-        continue
-      }
-      const codePoint =
-        ((byte1 & 0x0f) << 12) |
-        ((byte2 & 0x3f) << 6) |
-        (byte3 & 0x3f)
-
-      result += String.fromCharCode(codePoint)
-      i += 2
-      continue
-    }
-    if (byte1 >= 0xf0 && byte1 <= 0xf7) {
-      if (i + 3 >= arr.length) {
-        emitReplacement()
-        continue
-      }
-      const byte2 = arr[i + 1]
-      const byte3 = arr[i + 2]
-      const byte4 = arr[i + 3]
-      if (
-        (byte2 & 0xc0) !== 0x80 ||
-        (byte3 & 0xc0) !== 0x80 ||
-        (byte4 & 0xc0) !== 0x80
-      ) {
-        emitReplacement()
-        i += 3
-        continue
-      }
-      const codePoint =
-        ((byte1 & 0x07) << 18) |
-        ((byte2 & 0x3f) << 12) |
-        ((byte3 & 0x3f) << 6) |
-        (byte4 & 0x3f)
-      const offset = codePoint - 0x10000
-      const highSurrogate = 0xd800 + (offset >> 10)
-      const lowSurrogate = 0xdc00 + (offset & 0x3ff)
-      result += String.fromCharCode(highSurrogate, lowSurrogate)
-      i += 3
-      continue
-    }
-    emitReplacement()
-  }
-  return result
+  return new TextDecoder().decode(new Uint8Array(arr))
 }
 
 /**