@exodus/bytes 1.0.0-rc.8 → 1.0.0-rc.9

package/fallback/multi-byte.js

@@ -0,0 +1,449 @@
+import { asciiPrefix, decodeLatin1 } from './latin1.js'
+import { getTable } from './multi-byte.table.js'
+
+export const E_STRICT = 'Input is not well-formed for this encoding'
+
+// TODO: optimize
+
+// If the decoder is not cleared properly, state can be preserved between non-streaming calls!
+// See comment about fatal stream
+
+// All except iso-2022-jp are ASCII supersets
+// When adding something that is not an ASCII superset, ajust the ASCII fast path
+const REP = 0xff_fd
+const mappers = {
+  // https://encoding.spec.whatwg.org/#euc-kr-decoder
+  'euc-kr': () => {
+    const euc = getTable('euc-kr')
+    let lead = 0
+
+    const pushback = []
+    const bytes = (b) => {
+      if (lead) {
+        const cp = b >= 0x41 && b <= 0xfe ? euc[(lead - 0x81) * 190 + b - 0x41] : undefined
+        lead = 0
+        if (cp !== undefined && cp !== REP) return cp
+        if (b < 128) pushback.push(b)
+        return -2
+      }
+
+      if (b < 128) return b
+      if (b < 0x81 || b === 0xff) return -2
+      lead = b
+      return -1
+    }
+
+    const eof = () => {
+      if (!lead) return null
+      lead = 0
+      return -2
+    }
+
+    return { bytes, eof, pushback }
+  },
+  // https://encoding.spec.whatwg.org/#euc-jp-decoder
+  'euc-jp': () => {
+    const jis0208 = getTable('jis0208')
+    const jis0212 = getTable('jis0212')
+    let j12 = false
+    let lead = 0
+
+    const pushback = []
+    const bytes = (b) => {
+      if (lead === 0x8e && b >= 0xa1 && b <= 0xdf) {
+        lead = 0
+        return 0xfe_c0 + b
+      }
+
+      if (lead === 0x8f && b >= 0xa1 && b <= 0xfe) {
+        j12 = true
+        lead = b
+        return -1
+      }
+
+      if (lead) {
+        let cp
+        if (lead >= 0xa1 && lead <= 0xfe && b >= 0xa1 && b <= 0xfe) {
+          cp = (j12 ? jis0212 : jis0208)[(lead - 0xa1) * 94 + b - 0xa1]
+        }
+
+        lead = 0
+        j12 = false
+        if (cp !== undefined && cp !== REP) return cp
+        if (b < 128) pushback.push(b)
+        return -2
+      }
+
+      if (b < 128) return b
+      if ((b < 0xa1 && b !== 0x8e && b !== 0x8f) || b === 0xff) return -2
+      lead = b
+      return -1
+    }
+
+    // eslint-disable-next-line sonarjs/no-identical-functions
+    const eof = () => {
+      if (!lead) return null
+      lead = 0
+      return -2
+    }
+
+    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': () => {
+    const jis0208 = getTable('jis0208')
+    const EOF = -1
+    let dState = 1
+    let oState = 1
+    let lead = 0
+    let out = false
+
+    const pushback = []
+    const bytes = (b) => {
+      if (dState < 5) {
+        if (b === EOF) return null
+        if (b === 0x1b) {
+          dState = 6 // escape start
+          return -1
+        }
+      }
+
+      switch (dState) {
+        case 1:
+        case 2:
+          // ASCII, Roman (common)
+          out = false
+          if (dState === 2) {
+            if (b === 0x5c) return 0xa5
+            if (b === 0x7e) return 0x20_3e
+          }
+
+          if (b <= 0x7f && b !== 0x0e && b !== 0x0f) return b
+          return -2
+        case 3:
+          // Katakana
+          out = false
+          if (b >= 0x21 && b <= 0x5f) return 0xff_40 + b
+          return -2
+        case 4:
+          // Leading byte
+          out = false
+          if ((b >= 0x21) & (b <= 0x7e)) {
+            lead = b
+            dState = 5
+            return -1
+          }
+
+          return -2
+        case 5:
+          // Trailing byte
+          out = false
+          if (b === 0x1b) {
+            dState = 6 // escape start
+            return -2
+          }
+
+          dState = 4
+          if (b >= 0x21 && b <= 0x7e) {
+            const cp = jis0208[(lead - 0x21) * 94 + b - 0x21]
+            return cp !== undefined && cp !== REP ? cp : -2
+          }
+
+          return -2
+        case 6:
+          // Escape start
+          if (b === 0x24 || b === 0x28) {
+            lead = b
+            dState = 7
+            return -1
+          }
+
+          out = false
+          dState = oState
+          if (b !== EOF) pushback.push(b)
+          return -2
+        case 7: {
+          // Escape
+          const l = lead
+          lead = 0
+          let s
+          if (l === 0x28) {
+            // eslint-disable-next-line unicorn/prefer-switch
+            if (b === 0x42) {
+              s = 1
+            } else if (b === 0x4a) {
+              s = 2
+            } else if (b === 0x49) {
+              s = 3
+            }
+          } else if (l === 0x24 && (b === 0x40 || b === 0x42)) {
+            s = 4
+          }
+
+          if (s) {
+            dState = oState = s
+            const output = out
+            out = true
+            return output ? -2 : -1
+          }
+
+          out = false
+          dState = oState
+          if (b !== EOF) pushback.push(b)
+          pushback.push(l)
+          return -2
+        }
+      }
+    }
+
+    const eof = () => bytes(EOF)
+
+    return { bytes, eof, pushback }
+  },
+  // https://encoding.spec.whatwg.org/#shift_jis-decoder
+  shift_jis: () => {
+    const jis0208 = getTable('jis0208')
+    let lead = 0
+
+    const pushback = []
+    const bytes = (b) => {
+      if (lead) {
+        const l = lead
+        lead = 0
+        if (b >= 0x40 && b <= 0xfc && b !== 0x7f) {
+          const p = (l - (l < 0xa0 ? 0x81 : 0xc1)) * 188 + b - (b < 0x7f ? 0x40 : 0x41)
+          if (p >= 8836 && p <= 10_715) return 0xe0_00 - 8836 + p // 16-bit
+          const cp = jis0208[p]
+          if (cp !== undefined && cp !== REP) return cp
+        }
+
+        if (b < 128) pushback.push(b)
+        return -2
+      }
+
+      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
+      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 { bytes, eof, pushback }
+  },
+  // https://encoding.spec.whatwg.org/#gbk-decoder
+  gbk: () => mappers.gb18030(), // 10.1.1. GBK’s decoder is gb18030’s decoder
+  // https://encoding.spec.whatwg.org/#gb18030-decoder
+  gb18030: () => {
+    const gb18030 = getTable('gb18030')
+    const gb18030r = getTable('gb18030-ranges')
+    let g1 = 0, g2 = 0, g3 = 0 // prettier-ignore
+    const index = (p) => {
+      if ((p > 39_419 && p < 189_000) || p > 1_237_575) return
+      if (p === 7457) return 0xe7_c7
+      let a = 0, b = 0 // prettier-ignore
+      for (const [c, d] of gb18030r) {
+        if (c > p) break
+        a = c
+        b = d
+      }
+
+      return b + p - a
+    }
+
+    const pushback = []
+    const bytes = (b) => {
+      if (g3) {
+        if (b < 0x30 || b > 0x39) {
+          pushback.push(b, g3, g2)
+          g1 = g2 = g3 = 0
+          return -2
+        }
+
+        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
+      }
+
+      if (g2) {
+        if (b >= 0x81 && b <= 0xfe) {
+          g3 = b
+          return -1
+        }
+
+        pushback.push(b, g2)
+        g1 = g2 = 0
+        return -2
+      }
+
+      if (g1) {
+        if (b >= 0x30 && b <= 0x39) {
+          g2 = b
+          return -1
+        }
+
+        let cp
+        if (b >= 0x40 && b <= 0xfe && b !== 0x7f) {
+          cp = gb18030[(g1 - 0x81) * 190 + b - (b < 0x7f ? 0x40 : 0x41)]
+        }
+
+        g1 = 0
+        if (cp !== undefined && cp !== REP) return cp
+        if (b < 128) pushback.push(b)
+        return -2
+      }
+
+      if (b < 128) return b
+      if (b === 0x80) return 0x20_ac
+      if (b === 0xff) return -2
+      g1 = b
+      return -1
+    }
+
+    const eof = () => {
+      if (!g1 && !g2 && !g3) return null
+      g1 = g2 = g3 = 0
+      return -2
+    }
+
+    return { bytes, eof, pushback }
+  },
+}
+
+export const isAsciiSuperset = (enc) => enc !== 'iso-2022-jp' // all others are ASCII supersets and can use fast path
+export const multibyteSupported = (enc) => Object.hasOwn(mappers, enc) || enc === 'big5'
+
+export function multibyteDecoder(enc, loose = false) {
+  if (enc === 'big5') return big5decoder(loose)
+  if (!Object.hasOwn(mappers, enc)) throw new RangeError('Unsupported encoding')
+
+  // Input is assumed to be typechecked already
+  let mapper
+  const asciiSuperset = isAsciiSuperset(enc)
+  return (arr, stream = false) => {
+    const onErr = loose
+      ? () => '\uFFFD'
+      : () => {
+          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
+          // Decoders big5, euc-jp, euc-kr, shift_jis, gb18030 / gbk - all clear state before throwing unless EOF, so not affected
+          // iso-2022-jp is the only tricky one one where this !stream check matters in non-stream mode
+          if (!stream) mapper = null // destroy state, effectively the same as 'do not flush' = false, but early
+          throw new Error(E_STRICT)
+        }
+
+    let res = ''
+    const length = arr.length
+    if (asciiSuperset && !mapper) {
+      res = decodeLatin1(arr, 0, asciiPrefix(arr))
+      if (res.length === arr.length) return res // ascii
+    }
+
+    if (!mapper) mapper = mappers[enc]()
+    const { bytes, eof, pushback } = mapper
+    let i = res.length
+
+    // First, dump everything until EOF
+    // 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()
+      }
+    }
+
+    // Then, dump EOF. This needs the same loop as the characters can be pushed back
+    // TODO: only some encodings need this, most can be optimized
+    if (!stream) {
+      while (i <= length || pushback.length > 0) {
+        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
+        }
+      }
+    }
+
+    // Chrome and WebKit fail on this, we don't: completely destroy the old decoder instance when finished streaming
+    // > If this’s do not flush is false, then set this’s decoder to a new instance of this’s encoding’s decoder,
+    // > Set this’s do not flush to options["stream"]
+    if (!stream) mapper = null
+
+    return res
+  }
+}
+
+// The only decoder which returns multiple codepoints per byte, also has non-charcode codepoints
+// We store that as strings
+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 Error(E_STRICT)
+        }
+
+    let res = ''
+    const length = arr.length
+    if (!lead) {
+      res = decodeLatin1(arr, 0, asciiPrefix(arr))
+      if (res.length === arr.length) return res // ascii
+    }
+
+    if (!big5) big5 = getTable('big5')
+    for (let i = res.length; i < length || pushback.length > 0; ) {
+      const b = pushback.length > 0 ? pushback.pop() : arr[i++]
+      if (lead) {
+        let cp
+        if ((b >= 0x40 && b <= 0x7e) || (b >= 0xa1 && b !== 0xff)) {
+          cp = big5[(lead - 0x81) * 157 + b - (b < 0x7f ? 0x40 : 0x62)]
+        }
+
+        lead = 0
+        if (cp) {
+          res += cp // strings
+        } else {
+          res += onErr()
+          if (b < 128) pushback.push(b)
+        }
+      } else if (b < 128) {
+        res += String.fromCharCode(b)
+      } else if (b < 0x81 || b === 0xff) {
+        res += onErr()
+      } else {
+        lead = b
+      }
+    }
+
+    if (!stream) {
+      // Destroy decoder state
+      pushback.length = 0
+      if (lead) {
+        lead = 0
+        res += onErr()
+      }
+    }
+
+    return res
+  }
+}

package/fallback/multi-byte.table.js

@@ -0,0 +1,114 @@
+import { fromBase64url } from '@exodus/bytes/base64.js' // eslint-disable-line @exodus/import/no-unresolved
+import { utf16toString } from '@exodus/bytes/utf16.js' // eslint-disable-line @exodus/import/no-unresolved
+import loadEncodings from './multi-byte.encodings.cjs'
+import { to16input } from './utf16.js'
+
+export const sizes = {
+  jis0208: 11_104,
+  jis0212: 7211,
+  'euc-kr': 23_750,
+  gb18030: 23_940,
+  big5: 19_782,
+}
+
+// This is huge. It's _much_ smaller than https://npmjs.com/text-encoding though
+// Exactly as mapped by the index table
+// 0,x - hole of x empty elements
+// n,c - continious [c, ...] of length n
+// $.. - references to common chunks
+// -{x} - same as 1,{x}
+
+// See tests/multi-byte.test.js to verify that this data decodes exactly into the encoding spec tables
+
+let indices
+const tables = new Map()
+/* eslint-disable @exodus/mutable/no-param-reassign-prop-only */
+
+function loadBase64(str) {
+  const x = fromBase64url(str)
+  const len = x.length
+  const len2 = len >> 1
+  const y = new Uint8Array(len)
+  let a = -1, b = 0 // prettier-ignore
+  for (let i = 0, j = 0; i < len; i += 2, j++) {
+    a = (a + x[j] + 1) & 0xff
+    b = (b + x[len2 + j]) & 0xff
+    y[i] = a
+    y[i + 1] = b
+  }
+
+  return y
+}
+
+function unwrap(res, t, pos, stringMode = false) {
+  let code = 0
+  for (let i = 0; i < t.length; i++) {
+    let x = t[i]
+    if (typeof x === 'number') {
+      if (x === 0) {
+        pos += t[++i]
+      } else {
+        if (x < 0) {
+          code -= x
+          x = 1
+        } else {
+          code += t[++i]
+        }
+
+        if (stringMode) {
+          for (let k = 0; k < x; k++, pos++, code++) res[pos] = String.fromCodePoint(code)
+        } 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) {
+      const s = [...utf16toString(loadBase64(x), 'uint8-le')] // splits by codepoints
+      for (let i = 0; i < s.length; ) res[pos++] = s[i++] // TODO: splice?
+      code = s[s.length - 1].codePointAt(0) + 1
+    } else {
+      const u16 = to16input(loadBase64(x), true) // data is little-endian
+      res.set(u16, pos)
+      pos += u16.length
+      code = u16[u16.length - 1] + 1
+    }
+  }
+
+  return pos
+}
+
+export function getTable(id) {
+  const cached = tables.get(id)
+  if (cached) return cached
+
+  if (!indices) indices = loadEncodings() // lazy-load
+  if (!Object.hasOwn(indices, id)) throw new Error('Unknown encoding')
+  if (!indices[id]) throw new Error('Table already used (likely incorrect bundler dedupe)')
+
+  let res
+  if (id.endsWith('-ranges')) {
+    res = []
+    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 === 'big5') {
+    if (!Object.hasOwn(sizes, id)) throw new Error('Unknown encoding')
+    res = new Array(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'
+  } 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)
+  }
+
+  indices[id] = null // gc
+  tables.set(id, res)
+  return res
+}

package/fallback/single-byte.encodings.js

@@ -0,0 +1,45 @@
+// See tests/fixtures/encodings/single-byte/dump.js for generator
+
+const c =
+  '\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0'
+const k8a = '─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥\xA0⌡°²·÷═║╒ё'
+const k8b = '©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ'
+const i2 = 'żŔÁÂĂÄĹĆÇČÉĘËĚÍÎĎĐŃŇÓÔŐÖ×ŘŮÚŰÜÝŢßŕáâăäĺćçčéęëěíîďđńňóôőö÷řůúűüýţ˙'
+const ch = 'АБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ'
+const cl1 = 'абвгдежзийклмнопрстуфхцчшщъыьэю'
+const i8 = 'אבגדהוזחטיךכלםמןנסעףפץצקרשת'
+const p = '€\x81‚ƒ„…†‡'
+const s = 'µ¶·ø¹ŗ»¼½¾æĄĮĀĆÄÅĘĒČÉŹĖĢĶĪĻŠŃŅÓŌÕÖ×ŲŁŚŪÜŻŽßąįāćäåęēčéźėģķīļšńņóōõö÷ųłśūüżž'
+const f = (n) => '\uFFFD'.repeat(n)
+
+/* eslint-disable @exodus/export-default/named */
+// prettier-ignore
+export default {
+  ibm866: ch + "абвгдежзийклмноп░▒▓│┤╡╢╖╕╣║╗╝╜╛┐└┴┬├─┼╞╟╚╔╩╦╠═╬╧╨╤╥╙╘╒╓╫╪┘┌█▄▌▐▀рстуфхцчшщъыьэюяЁёЄєЇїЎў°∙·√№¤■\xA0",
+  "iso-8859-10": c + "ĄĒĢĪĨĶ§ĻĐŠŦŽ\xADŪŊ°ąēģīĩķ·ļđšŧž―ūŋĀÁÂÃÄÅÆĮČÉĘËĖÍÎÏÐŅŌÓÔÕÖŨØŲÚÛÜÝÞßāáâãäåæįčéęëėíîïðņōóôõöũøųúûüýþĸ",
+  "iso-8859-13": c + "”¢£¤„¦§Ø©Ŗ«¬\xAD®Æ°±²³“" + s + "’",
+  "iso-8859-14": c + "Ḃḃ£ĊċḊ§Ẁ©ẂḋỲ\xAD®ŸḞḟĠġṀṁ¶ṖẁṗẃṠỳẄẅṡÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏŴÑÒÓÔÕÖṪØÙÚÛÜÝŶßàáâãäåæçèéêëìíîïŵñòóôõöṫøùúûüýŷ",
+  "iso-8859-15": c + "¡¢£€¥Š§š©ª«¬\xAD®¯°±²³Žµ¶·ž¹º»ŒœŸ",
+  "iso-8859-16": c + "ĄąŁ€„Š§š©Ș«Ź\xADźŻ°±ČłŽ”¶·žčș»ŒœŸżÀÁÂĂÄĆÆÇÈÉÊËÌÍÎÏĐŃÒÓÔŐÖŚŰÙÚÛÜĘȚßàáâăäćæçèéêëìíîïđńòóôőöśűùúûüęț",
+  "iso-8859-2": c + "Ą˘Ł¤ĽŚ§¨ŠŞŤŹ\xADŽŻ°ą˛ł´ľśˇ¸šşťź˝ž" + i2,
+  "iso-8859-3": c + "Ħ˘£¤\uFFFDĤ§¨İŞĞĴ\xAD\uFFFDŻ°ħ²³´µĥ·¸ışğĵ½\uFFFDżÀÁÂ\uFFFDÄĊĈÇÈÉÊËÌÍÎÏ\uFFFDÑÒÓÔĠÖ×ĜÙÚÛÜŬŜßàáâ\uFFFDäċĉçèéêëìíîï\uFFFDñòóôġö÷ĝùúûüŭŝ˙",
+  "iso-8859-4": c + "ĄĸŖ¤ĨĻ§¨ŠĒĢŦ\xADŽ¯°ą˛ŗ´ĩļˇ¸šēģŧŊžŋĀÁÂÃÄÅÆĮČÉĘËĖÍÎĪĐŅŌĶÔÕÖ×ØŲÚÛÜŨŪßāáâãäåæįčéęëėíîīđņōķôõö÷øųúûüũū˙",
+  "iso-8859-5": c + "ЁЂЃЄЅІЇЈЉЊЋЌ\xADЎЏ" + ch + cl1 + "я№ёђѓєѕіїјљњћќ§ўџ",
+  "iso-8859-6": c + f(3) + "¤" + f(7) + "،\xAD" + f(13) + "؛" + f(3) + "؟\uFFFDءآأؤإئابةتثجحخدذرزسشصضطظعغ" + f(5) + "ـفقكلمنهوىي\u064B\u064C\u064D\u064E\u064F\u0650\u0651\u0652" + f(13),
+  "iso-8859-7": c + "‘’£€₯¦§¨©ͺ«¬\xAD\uFFFD―°±²³΄΅Ά·ΈΉΊ»Ό½ΎΏΐΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡ\uFFFDΣΤΥΦΧΨΩΪΫάέήίΰαβγδεζηθικλμνξοπρςστυφχψωϊϋόύώ\uFFFD",
+  "iso-8859-8": c + "\uFFFD¢£¤¥¦§¨©×«¬\xAD®¯°±²³´µ¶·¸¹÷»¼½¾" + f(32) + "‗" + i8 + f(2) + "\u200E\u200F\uFFFD",
+  "koi8-r": k8a + "╓╔╕╖╗╘╙╚╛╜╝╞╟╠╡Ё╢╣╤╥╦╧╨╩╪╫╬" + k8b,
+  "koi8-u": k8a + "є╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ" + k8b,
+  macintosh: "ÄÅÇÉÑÖÜáàâäãåçéèêëíìîïñóòôöõúùûü†°¢£§•¶ß®©™´¨≠ÆØ∞±≤≥¥µ∂∑∏π∫ªºΩæø¿¡¬√ƒ≈∆«»…\xA0ÀÃÕŒœ–—“”‘’÷◊ÿŸ⁄€‹›fifl‡·‚„‰ÂÊÁËÈÍÎÏÌÓÔ\uF8FFÒÚÛÙıˆ˜¯˘˙˚¸˝˛ˇ",
+  "windows-1250": "€\x81‚\x83„…†‡\x88‰Š‹ŚŤŽŹ\x90‘’“”•–—\x98™š›śťžź\xA0ˇ˘Ł¤Ą¦§¨©Ş«¬\xAD®Ż°±˛ł´µ¶·¸ąş»Ľ˝ľ" + i2,
+  "windows-1251": "ЂЃ‚ѓ„…†‡€‰Љ‹ЊЌЋЏђ‘’“”•–—\x98™љ›њќћџ\xA0ЎўЈ¤Ґ¦§Ё©Є«¬\xAD®Ї°±Ііґµ¶·ё№є»јЅѕї" + ch + cl1 + 'я',
+  "windows-1252": p + "ˆ‰Š‹Œ\x8DŽ\x8F\x90‘’“”•–—˜™š›œ\x9DžŸ",
+  "windows-1253": p + "\x88‰\x8A‹\x8C\x8D\x8E\x8F\x90‘’“”•–—\x98™\x9A›\x9C\x9D\x9E\x9F\xA0΅Ά£¤¥¦§¨©\uFFFD«¬\xAD®―°±²³΄µ¶·ΈΉΊ»Ό½ΎΏΐΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡ\uFFFDΣΤΥΦΧΨΩΪΫάέήίΰαβγδεζηθικλμνξοπρςστυφχψωϊϋόύώ\uFFFD",
+  "windows-1254": p + "ˆ‰Š‹Œ\x8D\x8E\x8F\x90‘’“”•–—˜™š›œ\x9D\x9EŸ\xA0¡¢£¤¥¦§¨©ª«¬\xAD®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏĞÑÒÓÔÕÖ×ØÙÚÛÜİŞßàáâãäåæçèéêëìíîïğñòóôõö÷øùúûüış",
+  "windows-1255": p + "ˆ‰\x8A‹\x8C\x8D\x8E\x8F\x90‘’“”•–—˜™\x9A›\x9C\x9D\x9E\x9F\xA0¡¢£₪¥¦§¨©×«¬\xAD®¯°±²³´µ¶·¸¹÷»¼½¾¿\u05B0\u05B1\u05B2\u05B3\u05B4\u05B5\u05B6\u05B7\u05B8\u05B9\u05BA\u05BB\u05BC\u05BD־\u05BF׀\u05C1\u05C2׃װױײ׳״" + f(7) + i8 + f(2) + "\u200E\u200F\uFFFD",
+  "windows-1256": "€پ‚ƒ„…†‡ˆ‰ٹ‹Œچژڈگ‘’“”•–—ک™ڑ›œ\u200C\u200Dں\xA0،¢£¤¥¦§¨©ھ«¬\xAD®¯°±²³´µ¶·¸¹؛»¼½¾؟ہءآأؤإئابةتثجحخدذرزسشصض×طظعغـفقكàلâمنهوçèéêëىيîï\u064B\u064C\u064D\u064Eô\u064F\u0650÷\u0651ù\u0652ûü\u200E\u200Fے",
+  "windows-1257": "€\x81‚\x83„…†‡\x88‰\x8A‹\x8C¨ˇ¸\x90‘’“”•–—\x98™\x9A›\x9C¯˛\x9F\xA0\uFFFD¢£¤\uFFFD¦§Ø©Ŗ«¬\xAD®Æ°±²³´" + s + "˙",
+  "windows-1258": p + "ˆ‰\x8A‹Œ\x8D\x8E\x8F\x90‘’“”•–—˜™\x9A›œ\x9D\x9EŸ\xA0¡¢£¤¥¦§¨©ª«¬\xAD®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂĂÄÅÆÇÈÉÊË\u0300ÍÎÏĐÑ\u0309ÓÔƠÖ×ØÙÚÛÜƯ\u0303ßàáâăäåæçèéêë\u0301íîïđñ\u0323óôơö÷øùúûüư₫",
+  "windows-874": "€\x81\x82\x83\x84…\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90‘’“”•–—\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0กขฃคฅฆงจฉชซฌญฎฏฐฑฒณดตถทธนบปผฝพฟภมยรฤลฦวศษสหฬอฮฯะ\u0E31าำ\u0E34\u0E35\u0E36\u0E37\u0E38\u0E39\u0E3A" + f(4) + "฿เแโใไๅๆ\u0E47\u0E48\u0E49\u0E4A\u0E4B\u0E4C\u0E4D\u0E4E๏๐๑๒๓๔๕๖๗๘๙๚๛" + f(4),
+  "x-mac-cyrillic": ch + "†°Ґ£§•¶І®©™Ђђ≠Ѓѓ∞±≤≥іµґЈЄєЇїЉљЊњјЅ¬√ƒ≈∆«»…\xA0ЋћЌќѕ–—“”‘’÷„ЎўЏџ№Ёёя" + cl1 + "€"
+}

package/fallback/single-byte.js

@@ -0,0 +1,83 @@
+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'
+
+export const assertEncoding = (encoding) => {
+  if (Object.hasOwn(encodings, encoding) || encoding === xUserDefined) return
+  throw new RangeError('Unsupported encoding')
+}
+
+function getEncoding(encoding) {
+  assertEncoding(encoding)
+  if (encoding === xUserDefined) {
+    return Array.from({ length: 128 }, (_, i) => String.fromCharCode(0xf7_80 + i)).join('')
+  }
+
+  return encodings[encoding]
+}
+
+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 incomplete = getEncoding(encoding).includes('\uFFFD')
+  let map
+  const mapper = (arr, start = 0) => {
+    if (!map) {
+      map = Uint16Array.from({ length: 256 }, (_, i) => i) // Unicode subset
+      const strings = getEncoding(encoding).split('')
+      map.set(Uint16Array.from(strings.map((x) => x.charCodeAt(0))), 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 incomplete = getEncoding(encoding).includes('\uFFFD')
+  const decoder = (arr, loose = false) => {
+    if (!strings) {
+      const part = getEncoding(encoding).split('')
+      strings = Array.from({ length: 128 }, (_, i) => String.fromCharCode(i)).concat(part)
+      while (strings.length < 256) strings.push(String.fromCharCode(strings.length))
+    }
+
+    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
+}