@qelos/aidev 0.11.0 → 1.0.1

package/ui/.output/server/node_modules/@exodus/bytes/fallback/multi-byte.table.js

@@ -0,0 +1,118 @@
+import { fromBase64url } from '@exodus/bytes/base64.js'
+import { utf16toString } from '@exodus/bytes/utf16.js'
+import loadEncodings from './multi-byte.encodings.cjs'
+
+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) {
+  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]
+        }
+
+        for (let k = 0; k < x; k++, pos++, code++) {
+          if (code <= 0xff_ff) {
+            res[pos] = code
+          } else {
+            const c = String.fromCodePoint(code)
+            res[pos] = (c.charCodeAt(0) << 16) | c.charCodeAt(1)
+          }
+        }
+      }
+    } else if (x[0] === '$' && Object.hasOwn(indices, x)) {
+      pos = unwrap(res, indices[x], pos) // self-reference using shared chunks
+    } else {
+      let last
+      // splits by codepoints
+      for (const c of utf16toString(loadBase64(x), 'uint8-le')) {
+        last = c
+        res[pos++] = c.length === 1 ? c.charCodeAt(0) : (c.charCodeAt(0) << 16) | c.charCodeAt(1)
+      }
+
+      code = last.codePointAt(0) + 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.endsWith('-katakana')) {
+    let a = -1
+    res = new Uint16Array(indices[id].map((x) => (a += x + 1)))
+  } else if (id === 'big5') {
+    res = new Uint32Array(sizes[id]) // single or double charcodes
+    unwrap(res, indices[id], 0)
+    // Pointer code updates are embedded into the table
+    // These are skipped in encoder as encoder uses only pointers >= (0xA1 - 0x81) * 157
+    res[1133] = 0xca_03_04
+    res[1135] = 0xca_03_0c
+    res[1164] = 0xea_03_04
+    res[1166] = 0xea_03_0c
+  } else {
+    if (!Object.hasOwn(sizes, id)) throw new Error('Unknown encoding')
+    res = new Uint16Array(sizes[id])
+    unwrap(res, indices[id], 0)
+  }
+
+  indices[id] = null // gc
+  tables.set(id, res)
+  return res
+}

package/ui/.output/server/node_modules/@exodus/bytes/fallback/percent.js

@@ -0,0 +1,31 @@
+import { decodeAscii, encodeLatin1 } from './latin1.js'
+import { decode2string } from './platform.js'
+
+const ERR = 'percentEncodeSet must be a string of unique increasing codepoints in range 0x20 - 0x7e'
+const percentMap = new Map()
+let hex, base
+
+export function percentEncoder(set, spaceAsPlus = false) {
+  if (typeof set !== 'string' || /[^\x20-\x7E]/.test(set)) throw new TypeError(ERR)
+  if (typeof spaceAsPlus !== 'boolean') throw new TypeError('spaceAsPlus must be boolean')
+  const id = set + +spaceAsPlus
+  const cached = percentMap.get(id)
+  if (cached) return cached
+
+  const n = encodeLatin1(set).sort() // string checked above to be ascii
+  if (decodeAscii(n) !== set || new Set(n).size !== n.length) throw new TypeError(ERR)
+
+  if (!base) {
+    hex = Array.from({ length: 256 }, (_, i) => `%${i.toString(16).padStart(2, '0').toUpperCase()}`)
+    base = hex.map((h, i) => (i < 0x20 || i > 0x7e ? h : String.fromCharCode(i)))
+  }
+
+  const map = base.slice() // copy
+  for (const c of n) map[c] = hex[c]
+  if (spaceAsPlus) map[0x20] = '+' // overrides whatever percentEncodeSet thinks about it
+
+  // Input is not typechecked, for internal use only
+  const percentEncode = (u8, start = 0, end = u8.length) => decode2string(u8, start, end, map)
+  percentMap.set(id, percentEncode)
+  return percentEncode
+}

package/ui/.output/server/node_modules/@exodus/bytes/fallback/platform.js

@@ -0,0 +1,2 @@
+// platform.native actually hosts Node.js / Deno detection too
+export * from './platform.native.js'

package/ui/.output/server/node_modules/@exodus/bytes/fallback/platform.native.js

@@ -0,0 +1,122 @@
+const { Buffer } = globalThis
+const haveNativeBuffer = Buffer && !Buffer.TYPED_ARRAY_SUPPORT
+export const nativeBuffer = haveNativeBuffer ? Buffer : null
+export const isHermes = /* @__PURE__ */ (() => !!globalThis.HermesInternal)()
+export const isDeno = /* @__PURE__ */ (() => !!globalThis.Deno)()
+export const isLE = /* @__PURE__ */ (() => new Uint8Array(Uint16Array.of(258).buffer)[0] === 2)()
+
+// We consider Node.js TextDecoder/TextEncoder native
+// Still needed in platform.native.js as this is re-exported to platform.js
+let isNative = (x) => x && (haveNativeBuffer || `${x}`.includes('[native code]'))
+if (!haveNativeBuffer && isNative(() => {})) isNative = () => false // e.g. XS, we don't want false positives
+
+export const nativeEncoder = /* @__PURE__ */ (() =>
+  isNative(globalThis.TextEncoder) ? new TextEncoder() : null)()
+export const nativeDecoder = /* @__PURE__ */ (() =>
+  isNative(globalThis.TextDecoder) ? new TextDecoder('utf-8', { ignoreBOM: true }) : null)()
+
+// Actually windows-1252, compatible with ascii and latin1 decoding
+// Beware that on non-latin1, i.e. on windows-1252, this is broken in ~all Node.js versions released
+// in 2025 due to a regression, so we call it Latin1 as it's usable only for that
+export const nativeDecoderLatin1 = /* @__PURE__ */ (() => {
+  // Not all barebone engines with TextDecoder support something except utf-8, detect
+  if (nativeDecoder) {
+    try {
+      return new TextDecoder('latin1', { ignoreBOM: true })
+    } catch {}
+  }
+
+  return null
+})()
+
+export function decodePartAddition(a, start, end, m) {
+  let o = ''
+  let i = start
+  for (const last3 = end - 3; i < last3; i += 4) {
+    const x0 = a[i]
+    const x1 = a[i + 1]
+    const x2 = a[i + 2]
+    const x3 = a[i + 3]
+    o += m[x0]
+    o += m[x1]
+    o += m[x2]
+    o += m[x3]
+  }
+
+  while (i < end) o += m[a[i++]]
+  return o
+}
+
+// Decoding with templates is faster on Hermes
+export function decodePartTemplates(a, start, end, m) {
+  let o = ''
+  let i = start
+  for (const last15 = end - 15; i < last15; i += 16) {
+    const x0 = a[i]
+    const x1 = a[i + 1]
+    const x2 = a[i + 2]
+    const x3 = a[i + 3]
+    const x4 = a[i + 4]
+    const x5 = a[i + 5]
+    const x6 = a[i + 6]
+    const x7 = a[i + 7]
+    const x8 = a[i + 8]
+    const x9 = a[i + 9]
+    const x10 = a[i + 10]
+    const x11 = a[i + 11]
+    const x12 = a[i + 12]
+    const x13 = a[i + 13]
+    const x14 = a[i + 14]
+    const x15 = a[i + 15]
+    o += `${m[x0]}${m[x1]}${m[x2]}${m[x3]}${m[x4]}${m[x5]}${m[x6]}${m[x7]}${m[x8]}${m[x9]}${m[x10]}${m[x11]}${m[x12]}${m[x13]}${m[x14]}${m[x15]}`
+  }
+
+  while (i < end) o += m[a[i++]]
+  return o
+}
+
+const decodePart = isHermes ? decodePartTemplates : decodePartAddition
+export function decode2string(arr, start, end, m) {
+  if (end - start > 30_000) {
+    // Limit concatenation to avoid excessive GC
+    // Thresholds checked on Hermes for toHex
+    const concat = []
+    for (let i = start; i < end; ) {
+      const step = i + 500
+      const iNext = step > end ? end : step
+      concat.push(decodePart(arr, i, iNext, m))
+      i = iNext
+    }
+
+    const res = concat.join('')
+    concat.length = 0
+    return res
+  }
+
+  return decodePart(arr, start, end, m)
+}
+
+/* eslint-disable @exodus/mutable/no-param-reassign-prop-only */
+
+function encodeCharcodesHermes(str, arr) {
+  const length = str.length
+  if (length > 64) {
+    const at = str.charCodeAt.bind(str) // faster on strings from ~64 chars on Hermes, but can be 10x slower on e.g. JSC
+    for (let i = 0; i < length; i++) arr[i] = at(i)
+  } else {
+    for (let i = 0; i < length; i++) arr[i] = str.charCodeAt(i)
+  }
+
+  return arr
+}
+
+export function encodeCharcodesPure(str, arr) {
+  const length = str.length
+  // Can be optimized with unrolling, but this is not used on non-Hermes atm
+  for (let i = 0; i < length; i++) arr[i] = str.charCodeAt(i)
+  return arr
+}
+
+/* eslint-enable @exodus/mutable/no-param-reassign-prop-only */
+
+export const encodeCharcodes = isHermes ? encodeCharcodesHermes : encodeCharcodesPure

package/ui/.output/server/node_modules/@exodus/bytes/fallback/single-byte.encodings.js

@@ -0,0 +1,73 @@
+// See tests/encoding/fixtures/single-byte/dump.js for generator
+
+const r = 0xff_fd
+
+/* eslint-disable unicorn/numeric-separators-style, @exodus/export-default/named */
+
+// Common ranges
+
+// prettier-ignore
+const i2 = [189,148,0,0,63,0,116,64,0,68,0,78,0,78,0,0,63,64,114,117,0,0,123,0,0,128,149,0,149,0,0,132,0,117,0,0,32,0,85,33,0,37,0,47,0,47,0,0,32,33,83,86,0,0,92,0,0,97,118,0,118,0,0,101,474]
+// prettier-ignore
+const iB = [[58,3424],[4,r],[29,3424],[4,r]]
+const i9 = [[47], 78, [12], 83, 128, [17], 47, [12], 52, 97]
+const w1 = [8236, 0, 8088, 0, 8090, 8097, 8090, 8090, 0, 8103]
+const w2 = [8236, 0, 8088, 271, 8090, 8097, 8090, 8090, 574, 8103]
+// prettier-ignore
+const w7 = [64,0,157,[4],39,68,109,62,67,0,0,82,75,68,0,175,75,86,105,92,108,144,114,115,0,120,[3],154,104,128,143,0,158,159,0,37,78,31,36,0,0,51,44,37,0,144,44,55,74,61,77,113,83,84,0,89,[3],123,73,97,112,0,127,128]
+const w8 = [8071, 8071, 8073, 8073, 8077, 8061, 8061]
+// prettier-ignore
+const k8b = [-22,910,879,879,899,880,880,894,876,893,[8,879],894,[4,878],864,859,884,882,861,877,881,876,873,875,846,815,815,835,816,816,830,812,829,[8,815],830,[4,814],800,795,820,818,797,813,817,812,809,811]
+// prettier-ignore
+const k8a = [9344,9345,9354,9357,9360,9363,9366,9373,9380,9387,9394,9461,9464,9467,9470,[4,9473],8845,9484,8580,8580,8625,8652,8652,6,8838,20,21,25,88,[3,9392],942]
+
+// prettier-ignore
+const maps = {
+  ibm866: [[48,912],[3,9441],...[29,62,122,122,109,107,120,101,106,111,109,107,31,34,65,56,39,10,69,102,102,96,89,109,105,98,81,108,102,102,97,97,84,82,75,75,98,96,13,0,123,118,125,128,111].map(x=>x+9266),[16,864],785,864,786,865,787,866,792,871,-72,8480,-67,8479,8218,-89,9378,-95],
+  'koi8-u': [...k8a,944,9391,944,944,[5,9391],996,944,[4,9391],846,848,9390,848,848,[5,9390],979,848,...k8b],
+  'koi8-r': [...k8a,[15,9391],846,[11,9390],...k8b],
+  macintosh: [68,68,69,70,77,81,86,90,88,89,90,88,89,90,91,89,90,90,91,89,90,90,91,92,90,91,92,90,94,92,93,93,8064,15,0,0,3,8061,16,56,6,0,8312,9,-4,8627,24,41,8558,0,8626,8626,-15,0,8524,8538,8535,775,8561,-17,-2,748,40,57,-1,-32,-22,8535,206,8579,8512,-28,-13,8029,-42,-11,-9,8,132,132,8003,8003,8010,8010,8004,8004,33,9459,39,159,8042,8145,8029,8029,64035,64035,8001,-42,7992,7995,8012,-35,-28,-38,-29,-33,[3,-29],-33,-27,-27,63503,-31,-24,-24,-27,60,464,485,-73,[3,479],-68,480,477,456],
+  'x-mac-cyrillic': [[32,912],8064,15,1006,0,3,8061,16,863,6,0,8312,855,934,8627,853,932,8558,0,8626,8626,930,0,987,849,844,923,845,924,845,924,844,923,920,836,-22,8535,206,8579,8512,-28,-13,8029,-42,832,911,831,910,902,8003,8003,8010,8010,8004,8004,33,8007,822,901,821,900,8250,804,883,880,[31,848],8109],
+  'windows-874': [8236,[4],8097,[11],...w8,[9],...iB],
+}
+
+// windows-1250 - windows-1258
+// prettier-ignore
+;[
+  [...w1,214,8110,206,215,239,234,0,...w8,0,8329,199,8095,191,200,224,219,0,550,566,158,0,95,[4],180,[4],204,0,0,553,143,[5],76,165,0,129,544,128,...i2],
+  [898,898,8088,976,8090,8097,8090,8090,8228,8103,895,8110,894,895,893,896,962,...w8,0,8329,959,8095,958,959,957,960,0,877,956,869,0,1003,0,0,857,0,858,[4],856,0,0,852,931,989,[3],921,8285,922,0,924,840,919,920,[64,848]],
+  [...w2,214,8110,198,0,239,0,0,...w8,580,8329,199,8095,183,0,224,217],
+  [8236,0,8088,271,8090,8097,8090,8090,0,8103,0,8110,[5],...w8,0,8329,0,8095,[5],740,740,[7],r,[4],8038,[4],720,[3],[3,720],0,720,0,[20,720],r,[44,720],r],
+  [...w2,214,8110,198,[4],...w8,580,8329,199,8095,183,0,0,217,0,...i9],
+  [...w2,0,8110,[5],...w8,580,8329,0,8095,[8],8198,[5],45,[15],61,[5],[20,1264],[5,1308],[7,r],[27,1264],r,r,7953,7953,r],
+  [8236,1533,8088,271,8090,8097,8090,8090,574,8103,1519,8110,198,1529,1546,1529,1567,...w8,1553,8329,1527,8095,183,8047,8047,1563,0,1387,[8],1556,[15],1377,[4],1376,1537,[22,1376],0,[4,1375],[4,1380],0,1379,0,[4,1378],[5],1373,1373,0,0,[4,1371],0,1370,1370,0,1369,0,1368,0,0,7953,7953,1491],
+  [...w1,0,8110,0,27,569,41,0,...w8,0,8329,0,8095,0,18,573,0,0,r,[3],r,0,0,48,0,172,[4],23,[8],...w7,474],
+  [...w2,0,8110,198,[4],...w8,580,8329,0,8095,183,0,0,217,[35],63,[8],564,[3],64,0,567,0,0,203,[7],210,549,[4],32,[8],533,[3],33,0,561,0,0,172,[7],179,8109],
+].forEach((m, i) => {
+  maps[`windows-${i + 1250}`] = m
+});
+
+// iso-8859-1 - iso-8859-16
+// prettier-ignore
+;[
+  [], // Actual Latin1 / Unicode subset, non-WHATWG, which maps iso-8859-1 to windows-1252
+  [99,566,158,0,152,180,0,0,183,180,185,205,0,207,204,0,84,553,143,0,137,165,528,0,168,165,170,190,544,192,...i2],
+  [133,566,0,0,r,126,0,0,135,180,115,136,0,r,204,0,118,[4],111,0,0,120,165,100,121,0,r,189,[3],r,0,69,66,[9],r,[4],75,0,0,68,[4],143,126,[4],r,0,38,35,[9],r,[4],44,0,0,37,[4],112,95,474],
+  [99,150,179,0,131,149,0,0,183,104,119,186,0,207,0,0,84,553,164,0,116,134,528,0,168,89,104,171,141,192,140,64,[6],103,68,0,78,0,74,0,0,91,64,116,122,99,[5],153,[3],139,140,0,33,[6],72,37,0,47,0,43,0,0,60,33,85,91,68,[5],122,[3],108,109,474],
+  [[12,864],0,[66,864],8230,[12,864],-86,864,864],
+  [[3,r],0,[7,r],1376,0,[13,r],1376,[3,r],1376,r,[26,1376],[5,r],[19,1376],[13,r]],
+  [8055,8055,0,8200,8202,[4],720,[3],r,8038,[4],[3,720],0,[3,720],0,720,0,[20,720],r,[44,720],r],
+  [r,[8],45,[15],61,[4],[32,r],7992,[27,1264],r,r,7953,7953,r],
+  i9, // non-WHATWG, which maps iso-8859-9 to windows-1254
+  [99,112,127,134,131,144,0,147,103,182,187,209,0,188,155,0,84,97,112,119,116,129,0,132,88,167,172,194,8024,173,140,64,[6],103,68,0,78,0,74,[4],116,122,[4],145,0,153,[6],33,[6],72,37,0,47,0,43,[4],85,91,[4],114,0,122,[5],57],
+  iB, // non-WHATWG, which maps iso-8859-11 to windows-874
+  null, // no 12
+  [8060,[3],8057,0,0,48,0,172,[4],23,[4],8040,[3],...w7,7962],
+  [7521,7521,0,102,102,7524,0,7640,0,7640,7520,7750,0,0,201,7534,7534,110,110,7564,7564,0,7583,7625,7582,7625,7589,7735,7623,7623,7586,[16],164,[6],7571,[6],152,[17],133,[6],7540,[6],121],
+  [[3],8200,0,186,0,185,[11],201,[3],198,[3],150,150,186],
+  [99,99,158,8200,8057,186,0,185,0,366,0,205,0,204,204,0,0,90,143,201,8040,0,0,198,84,351,0,150,150,186,189,[3],63,0,65,[10],64,114,[3],123,0,131,152,[4],59,316,[4],32,0,34,[10],33,83,[3],92,0,100,121,[4],28,285],
+].forEach((m, i) => {
+  if (m) maps[`iso-8859-${i + 1}`] = [[33], ...m]
+});
+
+export default maps

package/ui/.output/server/node_modules/@exodus/bytes/fallback/single-byte.js

@@ -0,0 +1,110 @@
+import { asciiPrefix, decodeAscii, decodeLatin1 } from './latin1.js'
+import encodings from './single-byte.encodings.js'
+import { decode2string, nativeDecoder } from './platform.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
+
+export function getEncoding(encoding) {
+  assertEncoding(encoding)
+  if (encoding === xUserDefined) return Array.from({ length: 128 }, (_, i) => 0xf7_80 + i)
+  if (encoding === iso8i) encoding = 'iso-8859-8'
+  const enc = encodings[encoding]
+  const deltas = enc.flatMap((x) => (Array.isArray(x) ? new Array(x[0]).fill(x[1] ?? 0) : x))
+  return deltas.map((x, i) => (x === r ? x : x + 128 + i))
+}
+
+const mappers = new Map()
+const decoders = new Map()
+const encmaps = 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(r)
+  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
+  const isLatin1 = encoding === 'iso-8859-1'
+  if (isLatin1 && !nativeDecoder) return (arr, loose = false) => decodeLatin1(arr) // native decoder is faster for ascii below
+
+  let strings
+  const codes = getEncoding(encoding)
+  const incomplete = codes.includes(r)
+  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 prefixLen = asciiPrefix(arr)
+    if (prefixLen === arr.length) return decodeAscii(arr)
+    if (isLatin1) return decodeLatin1(arr) // TODO: check if decodeAscii with subarray is faster for small prefixes too
+    const prefix = decodeLatin1(arr, 0, prefixLen) // TODO: check if decodeAscii with subarray is faster for small prefixes too
+    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
+}
+
+export function encodeMap(encoding) {
+  const cached = encmaps.get(encoding)
+  if (cached) return cached
+
+  const codes = getEncoding(encoding)
+  let max = 128
+  while (codes.length < 128) codes.push(128 + codes.length)
+  for (const code of codes) if (code > max && code !== r) max = code
+  const map = new Uint8Array(max + 1) // < 10 KiB for all except macintosh, 63 KiB for macintosh
+  for (let i = 0; i < 128; i++) {
+    map[i] = i
+    if (codes[i] !== r) map[codes[i]] = 128 + i
+  }
+
+  encmaps.set(encoding, map)
+  return map
+}