@exodus/bytes 1.0.0-rc.8 → 1.0.0

package/fallback/single-byte.js

@@ -0,0 +1,86 @@
+import { asciiPrefix, decodeLatin1 } from './latin1.js'
+import encodings from './single-byte.encodings.js'
+import { decode2string } from './_utils.js'
+
+export const E_STRICT = 'Input is not well-formed for this encoding'
+const xUserDefined = 'x-user-defined'
+const iso8i = 'iso-8859-8-i'
+
+export const assertEncoding = (encoding) => {
+  if (Object.hasOwn(encodings, encoding) || encoding === xUserDefined || encoding === iso8i) return
+  throw new RangeError('Unsupported encoding')
+}
+
+const r = 0xff_fd
+
+function getEncoding(encoding) {
+  assertEncoding(encoding)
+  if (encoding === xUserDefined) return Array.from({ length: 128 }, (_, i) => 0xf7_80 + i)
+  if (encoding === iso8i) encoding = 'iso-8859-8'
+  let prev = 127
+  return encodings[encoding].map((x) => (x === r ? x : (prev += x))) // eslint-disable-line no-return-assign
+}
+
+const mappers = new Map()
+const decoders = new Map()
+
+// Used only on Node.js, no reason to optimize for anything else
+// E.g. avoiding .from and filling zero-initialized arr manually is faster on Hermes, but we avoid this codepath on Hermes completely
+export function encodingMapper(encoding) {
+  const cached = mappers.get(encoding)
+  if (cached) return cached
+
+  const codes = getEncoding(encoding)
+  const incomplete = codes.includes(0xff_fd)
+  let map
+  const mapper = (arr, start = 0) => {
+    if (!map) {
+      map = new Uint16Array(256).map((_, i) => i) // Unicode subset
+      map.set(Uint16Array.from(codes), 128)
+    }
+
+    const o = Uint16Array.from(start === 0 ? arr : arr.subarray(start)) // copy to modify in-place, also those are 16-bit now
+    let i = 0
+    for (const end7 = o.length - 7; i < end7; i += 8) {
+      o[i] = map[o[i]]
+      o[i + 1] = map[o[i + 1]]
+      o[i + 2] = map[o[i + 2]]
+      o[i + 3] = map[o[i + 3]]
+      o[i + 4] = map[o[i + 4]]
+      o[i + 5] = map[o[i + 5]]
+      o[i + 6] = map[o[i + 6]]
+      o[i + 7] = map[o[i + 7]]
+    }
+
+    for (const end = o.length; i < end; i++) o[i] = map[o[i]]
+    return o
+  }
+
+  mappers.set(encoding, { mapper, incomplete })
+  return { mapper, incomplete }
+}
+
+export function encodingDecoder(encoding) {
+  const cached = decoders.get(encoding)
+  if (cached) return cached
+
+  let strings
+  const codes = getEncoding(encoding)
+  const incomplete = codes.includes(0xff_fd)
+  const decoder = (arr, loose = false) => {
+    if (!strings) {
+      const allCodes = Array.from({ length: 128 }, (_, i) => i).concat(codes)
+      while (allCodes.length < 256) allCodes.push(allCodes.length)
+      strings = allCodes.map((c) => String.fromCharCode(c))
+    }
+
+    const prefix = decodeLatin1(arr, 0, asciiPrefix(arr))
+    if (prefix.length === arr.length) return prefix
+    const suffix = decode2string(arr, prefix.length, arr.length, strings)
+    if (!loose && incomplete && suffix.includes('\uFFFD')) throw new TypeError(E_STRICT)
+    return prefix + suffix
+  }
+
+  decoders.set(encoding, decoder)
+  return decoder
+}

package/fallback/utf16.js

@@ -0,0 +1,180 @@
+import { decodeLatin1, encodeCharcodes } from './latin1.js'
+import { isLE } from './_utils.js'
+
+export const E_STRICT = 'Input is not well-formed utf16'
+export const E_STRICT_UNICODE = 'Input is not well-formed Unicode'
+
+const replacementCodepoint = 0xff_fd
+const replacementCodepointSwapped = 0xfd_ff
+
+const to16 = (a) => new Uint16Array(a.buffer, a.byteOffset, a.byteLength / 2) // Requires checked length and alignment!
+
+export function to16input(u8, le) {
+  // Assume even number of bytes
+  if (le === isLE) return to16(u8.byteOffset % 2 === 0 ? u8 : Uint8Array.from(u8))
+
+  const res = new Uint8Array(u8.length)
+
+  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
+  }
+
+  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
+  }
+
+  return to16(res)
+}
+
+export const decode = (u16, loose = false, checked = false) => {
+  if (checked || isWellFormed(u16)) return decodeLatin1(u16, 0, u16.length) // it's capable of decoding Uint16Array to UTF-16 as well
+  if (!loose) throw new TypeError(E_STRICT)
+  return decodeLatin1(toWellFormed(Uint16Array.from(u16)), 0, u16.length) // 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)
+}
+
+// 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
+
+function encodeCheckedSwapped(str, arr) {
+  // TODO: faster path for Hermes? See encodeCharcodes
+  const length = str.length
+  for (let i = 0; i < length; i++) {
+    const x = str.charCodeAt(i)
+    arr[i] = ((x & 0xff) << 8) | (x >> 8)
+  }
+
+  return arr
+}
+
+// lead: d800 - dbff, trail: dc00 - dfff
+
+function encodeUnchecked(str, arr, loose = false) {
+  // TODO: faster path for Hermes? See encodeCharcodes
+  const length = str.length
+  for (let i = 0; i < length; i++) {
+    const code = str.charCodeAt(i)
+    arr[i] = code
+    if (code >= 0xd8_00 && code < 0xe0_00) {
+      // An unexpected trail or a lead at the very end of input
+      if (code > 0xdb_ff || i + 1 >= length) {
+        if (!loose) throw new TypeError(E_STRICT_UNICODE)
+        arr[i] = replacementCodepoint
+      } else {
+        const next = str.charCodeAt(i + 1) // Process valid pairs immediately
+        if (next < 0xdc_00 || next >= 0xe0_00) {
+          if (!loose) throw new TypeError(E_STRICT_UNICODE)
+          arr[i] = replacementCodepoint
+        } else {
+          i++ // consume next
+          arr[i] = next
+        }
+      }
+    }
+  }
+
+  return arr
+}
+
+function encodeUncheckedSwapped(str, arr, loose = false) {
+  // TODO: faster path for Hermes? See encodeCharcodes
+  const length = str.length
+  for (let i = 0; i < length; i++) {
+    const code = str.charCodeAt(i)
+    arr[i] = ((code & 0xff) << 8) | (code >> 8)
+    if (code >= 0xd8_00 && code < 0xe0_00) {
+      // An unexpected trail or a lead at the very end of input
+      if (code > 0xdb_ff || i + 1 >= length) {
+        if (!loose) throw new TypeError(E_STRICT_UNICODE)
+        arr[i] = replacementCodepointSwapped
+      } else {
+        const next = str.charCodeAt(i + 1) // Process valid pairs immediately
+        if (next < 0xdc_00 || next >= 0xe0_00) {
+          if (!loose) throw new TypeError(E_STRICT_UNICODE)
+          arr[i] = replacementCodepointSwapped
+        } else {
+          i++ // consume next
+          arr[i] = ((next & 0xff) << 8) | (next >> 8)
+        }
+      }
+    }
+  }
+
+  return arr
+}
+
+export function toWellFormed(u16) {
+  const length = u16.length
+  for (let i = 0; i < length; i++) {
+    const code = u16[i]
+    if (code >= 0xd8_00 && code < 0xe0_00) {
+      // An unexpected trail or a lead at the very end of input
+      if (code > 0xdb_ff || i + 1 >= length) {
+        u16[i] = replacementCodepoint
+      } else {
+        const next = u16[i + 1] // Process valid pairs immediately
+        if (next < 0xdc_00 || next >= 0xe0_00) {
+          u16[i] = replacementCodepoint
+        } else {
+          i++ // consume next
+        }
+      }
+    }
+  }
+
+  return u16
+}
+
+export function isWellFormed(u16) {
+  const length = u16.length
+  let i = 0
+
+  // 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) {
+    const u32length = (u16.byteLength / 4) | 0
+    const u32 = new Uint32Array(u16.buffer, u16.byteOffset, u32length)
+    for (const last3 = u32length - 3; ; i += 4) {
+      if (i >= last3) break // loop is fast enough for moving this here to be _very_ useful, likely due to array access checks
+      const a = u32[i]
+      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
+    }
+
+    for (; i < u32length; i++) if (u32[i] & 0x80_00_80_00) break
+    i *= 2
+  }
+
+  for (; i < length; i++) {
+    const code = u16[i]
+    if (code >= 0xd8_00 && code < 0xe0_00) {
+      // An unexpected trail or a lead at the very end of input
+      if (code > 0xdb_ff || 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
+    }
+  }
+
+  return true
+}

package/hex.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+
+import type { OutputFormat, Uint8ArrayBuffer } from './array.js';
+
+/**
+ * Encodes a Uint8Array to a lowercase hex string
+ * @param arr - The input bytes
+ * @returns The hex encoded string
+ */
+export function toHex(arr: Uint8ArrayBuffer): string;
+
+/**
+ * Decodes a hex string to bytes
+ * Unlike Buffer.from(), throws on invalid input
+ * @param str - 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;
+

package/hex.node.js

@@ -5,6 +5,7 @@ import { E_HEX } from './fallback/hex.js'
 if (Buffer.TYPED_ARRAY_SUPPORT) throw new Error('Unexpected Buffer polyfill')
 
 const { toHex: webHex } = Uint8Array.prototype // Modern engines have this
+const denoBug = Buffer.from('ag', 'hex').length > 0
 
 export function toHex(arr) {
   assertUint8(arr)
@@ -20,6 +21,7 @@ export const fromHex = Uint8Array.fromHex
   : (str, format = 'uint8') => {
       if (typeof str !== 'string') throw new TypeError('Input is not a string')
       if (str.length % 2 !== 0) throw new SyntaxError(E_HEX)
+      if (denoBug && /[^\dA-Fa-f]/.test(str)) throw new SyntaxError(E_HEX)
       const buf = Buffer.from(str, 'hex') // will stop on first non-hex character, so we can just validate length
       if (buf.length * 2 !== str.length) throw new SyntaxError(E_HEX)
       return typedView(buf, format)

package/multi-byte.js

@@ -0,0 +1,13 @@
+import { assertUint8 } from './assert.js'
+import { multibyteDecoder } from './fallback/multi-byte.js'
+
+export function createMultibyteDecoder(encoding, loose = false) {
+  const jsDecoder = multibyteDecoder(encoding, loose) // asserts
+  let streaming = false
+  return (arr, stream = false) => {
+    assertUint8(arr)
+    if (!streaming && arr.byteLength === 0) return ''
+    streaming = stream
+    return jsDecoder(arr, stream)
+  }
+}

package/multi-byte.node.js

@@ -0,0 +1,25 @@
+import { assertUint8 } from './assert.js'
+import { isDeno } from './fallback/_utils.js'
+import { isAsciiSuperset, multibyteDecoder } from './fallback/multi-byte.js'
+import { isAscii } from 'node:buffer'
+
+const toBuf = (x) => Buffer.from(x.buffer, x.byteOffset, x.byteLength)
+
+export function createMultibyteDecoder(encoding, loose = false) {
+  const jsDecoder = multibyteDecoder(encoding, loose) // asserts
+  let streaming = false
+  const asciiSuperset = isAsciiSuperset(encoding)
+  return (arr, stream = false) => {
+    assertUint8(arr)
+    if (!streaming) {
+      if (arr.byteLength === 0) return ''
+      if (asciiSuperset && isAscii(arr)) {
+        if (isDeno) return toBuf(arr).toString()
+        return toBuf(arr).latin1Slice(0, arr.byteLength) // .latin1Slice is faster than .asciiSlice
+      }
+    }
+
+    streaming = stream
+    return jsDecoder(arr, stream)
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/bytes",
-  "version": "1.0.0-rc.8",
+  "version": "1.0.0",
   "description": "Various operations on Uint8Array data",
   "scripts": {
     "lint": "eslint .",
@@ -10,6 +10,10 @@
     "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",
@@ -17,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",
@@ -25,54 +30,96 @@
   },
   "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"
+    "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
   },
   "type": "module",
   "files": [
     "/fallback/_utils.js",
-    "/fallback/latin1.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",
+    "/array.d.ts",
     "/assert.js",
     "/base32.js",
     "/base58.js",
     "/base58check.js",
     "/base64.js",
+    "/base64.d.ts",
     "/bech32.js",
-    "/hex.node.js",
+    "/bigint.js",
+    "/encoding.js",
+    "/encoding-lite.js",
     "/hex.js",
-    "/utf8.node.js",
+    "/hex.d.ts",
+    "/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.d.ts",
+    "/utf8.node.js",
     "/wif.js"
   ],
   "exports": {
-    "./array.js": "./array.js",
+    "./array.js": {
+      "types": "./array.d.ts",
+      "default": "./array.js"
+    },
     "./base32.js": "./base32.js",
     "./base58.js": "./base58.js",
     "./base58check.js": "./base58check.js",
-    "./base64.js": "./base64.js",
+    "./base64.js": {
+      "types": "./base64.d.ts",
+      "default": "./base64.js"
+    },
     "./bech32.js": "./bech32.js",
+    "./bigint.js": "./bigint.js",
     "./hex.js": {
+      "types": "./hex.d.ts",
       "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": {
+      "types": "./utf8.d.ts",
       "node": "./utf8.node.js",
       "default": "./utf8.js"
     },
@@ -91,14 +138,15 @@
     "@exodus/crypto": "^1.0.0-rc.30",
     "@exodus/eslint-config": "^5.24.0",
     "@exodus/prettier": "^1.0.0",
-    "@exodus/test": "^1.0.0-rc.108",
+    "@exodus/test": "^1.0.0-rc.109",
     "@noble/hashes": "^2.0.1",
     "@scure/base": "^1.2.6",
     "@stablelib/base64": "^2.0.1",
     "@stablelib/hex": "^2.0.1",
-    "@types/node": "^22.13.0",
+    "@types/node": "^22.12.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",
@@ -114,11 +162,12 @@
     "hextreme": "^1.0.7",
     "hi-base32": "^0.5.1",
     "iconv-lite": "^0.7.0",
-    "jsvu": "^3.0.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",

package/single-byte.js

@@ -0,0 +1,54 @@
+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) {
+  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 } 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) {
+  const latin1path = encoding === 'windows-1252'
+  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 = toBuf(mapper(arr, prefix.length)) // prefix.length can mismatch prefixBytes
+    if (!isLE) b.swap16()
+    const suffix = b.ucs2Slice(0, b.byteLength)
+    if (!loose && incomplete && suffix.includes('\uFFFD')) throw new TypeError(E_STRICT)
+    return prefix + suffix
+  }
+}
+
+export const windows1252toString = createSinglebyteDecoder('windows-1252')