@qelos/aidev 0.11.0 → 1.0.0

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

@@ -0,0 +1,38 @@
+// TODO: make this more strict against Symbol.toStringTag
+// Is not very significant though, anything faking Symbol.toStringTag could as well override
+// prototypes, which is not something we protect against
+
+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]'
+}
+
+export function fromSource(x) {
+  if (x instanceof Uint8Array) return x
+  if (ArrayBuffer.isView(x)) return new Uint8Array(x.buffer, x.byteOffset, x.byteLength)
+  if (isAnyArrayBuffer(x)) {
+    if ('detached' in x) return x.detached === true ? new Uint8Array() : new Uint8Array(x)
+    // Old engines without .detached, try-catch
+    try {
+      return new Uint8Array(x)
+    } catch {
+      return new Uint8Array()
+    }
+  }
+
+  throw new TypeError('Argument must be a SharedArrayBuffer, ArrayBuffer or ArrayBufferView')
+}
+
+// Warning: unlike whatwg-encoding, returns lowercased labels
+// Those are case-insensitive and that's how TextDecoder encoding getter normalizes them
+export function getBOMEncoding(input) {
+  const u8 = fromSource(input) // asserts
+  if (u8.length >= 3 && u8[0] === 0xef && u8[1] === 0xbb && u8[2] === 0xbf) return 'utf-8'
+  if (u8.length < 2) return null
+  if (u8[0] === 0xff && u8[1] === 0xfe) return 'utf-16le'
+  if (u8[0] === 0xfe && u8[1] === 0xff) return 'utf-16be'
+  return null
+}

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

@@ -0,0 +1,369 @@
+// We can't return native TextDecoder if it's present, as Node.js one is broken on windows-1252 and we fix that
+// We are also faster than Node.js built-in on both TextEncoder and TextDecoder
+
+import { utf16toString, utf16toStringLoose } from '@exodus/bytes/utf16.js'
+import { utf8fromStringLoose, utf8toString, utf8toStringLoose } from '@exodus/bytes/utf8.js'
+import {
+  createSinglebyteDecoder,
+  latin1toString,
+  latin1fromString,
+} from '@exodus/bytes/single-byte.js'
+import labels from './encoding.labels.js'
+import { fromSource, getBOMEncoding } from './encoding.api.js'
+import { unfinishedBytes, mergePrefix } from './encoding.util.js'
+
+export { getBOMEncoding } from './encoding.api.js'
+
+export const E_ENCODING = 'Unknown encoding'
+const E_MULTI = "import '@exodus/bytes/encoding.js' for legacy multi-byte encodings support"
+const E_OPTIONS = 'The "options" argument must be of type object'
+const replacementChar = '\uFFFD'
+const multibyteSet = new Set(['big5', 'euc-kr', 'euc-jp', 'iso-2022-jp', 'shift_jis', 'gbk', 'gb18030']) // prettier-ignore
+let createMultibyteDecoder, multibyteEncoder
+
+let labelsMap
+// Warning: unlike whatwg-encoding, returns lowercased labels
+// Those are case-insensitive and that's how TextDecoder encoding getter normalizes them
+// https://encoding.spec.whatwg.org/#names-and-labels
+export function normalizeEncoding(label) {
+  // fast path
+  if (label === 'utf-8' || label === 'utf8' || label === 'UTF-8' || label === 'UTF8') return 'utf-8'
+  if (label === 'windows-1252' || label === 'ascii' || label === 'latin1') return 'windows-1252'
+  // full map
+  if (/[^\w\t\n\f\r .:-]/i.test(label)) return null // must be ASCII (with ASCII whitespace)
+  const low = `${label}`.trim().toLowerCase()
+  if (Object.hasOwn(labels, low)) return low
+  if (!labelsMap) {
+    labelsMap = new Map()
+    for (const [name, aliases] of Object.entries(labels)) {
+      for (const alias of aliases) labelsMap.set(alias, name)
+    }
+  }
+
+  const mapped = labelsMap.get(low)
+  if (mapped) return mapped
+  return null
+}
+
+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
+}
+
+export const isMultibyte = (enc) => multibyteSet.has(enc)
+export function setMultibyte(createDecoder, createEncoder) {
+  createMultibyteDecoder = createDecoder
+  multibyteEncoder = createEncoder
+}
+
+export function getMultibyteEncoder() {
+  if (!multibyteEncoder) throw new Error(E_MULTI)
+  return multibyteEncoder
+}
+
+const define = (obj, key, value) => Object.defineProperty(obj, key, { value, writable: false })
+
+function isAnyUint8Array(x) {
+  if (x instanceof Uint8Array) return true
+  if (!x || !ArrayBuffer.isView(x) || x.BYTES_PER_ELEMENT !== 1) return false
+  return Object.prototype.toString.call(x) === '[object Uint8Array]'
+}
+
+function unicodeDecoder(encoding, loose) {
+  if (encoding === 'utf-8') return loose ? utf8toStringLoose : utf8toString // likely
+  const form = encoding === 'utf-16le' ? 'uint8-le' : 'uint8-be'
+  return loose ? (u) => utf16toStringLoose(u, form) : (u) => utf16toString(u, form)
+}
+
+export class TextDecoder {
+  #decode
+  #unicode
+  #multibyte
+  #chunk
+  #canBOM
+
+  constructor(encoding = 'utf-8', options = {}) {
+    if (typeof options !== 'object') throw new TypeError(E_OPTIONS)
+    const enc = normalizeEncoding(encoding)
+    if (!enc || enc === 'replacement') throw new RangeError(E_ENCODING)
+    define(this, 'encoding', enc)
+    define(this, 'fatal', !!options.fatal)
+    define(this, 'ignoreBOM', !!options.ignoreBOM)
+    this.#unicode = enc === 'utf-8' || enc === 'utf-16le' || enc === 'utf-16be'
+    this.#multibyte = !this.#unicode && isMultibyte(enc)
+    this.#canBOM = this.#unicode && !this.ignoreBOM
+  }
+
+  get [Symbol.toStringTag]() {
+    return 'TextDecoder'
+  }
+
+  decode(input, options = {}) {
+    if (typeof options !== 'object') throw new TypeError(E_OPTIONS)
+    const stream = !!options.stream
+    let u = input === undefined ? new Uint8Array() : fromSource(input)
+    const empty = u.length === 0 // also can't be streaming after next line
+    if (empty && stream) return '' // no state change
+
+    if (this.#unicode) {
+      let prefix
+      if (this.#chunk) {
+        const merged = mergePrefix(u, this.#chunk, this.encoding)
+        if (u.length < 3) {
+          u = merged // might be unfinished, but fully consumed old u
+        } else {
+          prefix = merged // stops at complete chunk
+          const add = prefix.length - this.#chunk.length
+          if (add > 0) u = u.subarray(add)
+        }
+
+        this.#chunk = null
+      } else if (empty) {
+        this.#canBOM = !this.ignoreBOM // not streaming
+        return ''
+      }
+
+      // For non-stream utf-8 we don't have to do this as it matches utf8toStringLoose already
+      // For non-stream loose utf-16 we still have to do this as this API supports uneven byteLength unlike utf16toStringLoose
+      let suffix = ''
+      if (stream || (!this.fatal && this.encoding !== 'utf-8')) {
+        const trail = unfinishedBytes(u, u.byteLength, this.encoding)
+        if (trail > 0) {
+          if (stream) {
+            this.#chunk = Uint8Array.from(u.subarray(-trail)) // copy
+          } else {
+            // non-fatal mode as already checked
+            suffix = replacementChar
+          }
+
+          u = u.subarray(0, -trail)
+        }
+      }
+
+      let seenBOM = false
+      if (this.#canBOM) {
+        const bom = this.#findBom(prefix ?? u)
+        if (bom) {
+          seenBOM = true
+          if (prefix) {
+            prefix = prefix.subarray(bom)
+          } else {
+            u = u.subarray(bom)
+          }
+        }
+      } else if (!stream && !this.ignoreBOM) {
+        this.#canBOM = true
+      }
+
+      if (!this.#decode) this.#decode = unicodeDecoder(this.encoding, !this.fatal)
+      try {
+        const res = (prefix ? this.#decode(prefix) : '') + this.#decode(u) + suffix
+        // "BOM seen" is set on the current decode call only if it did not error, in "serialize I/O queue" after decoding
+        if (stream && (seenBOM || res.length > 0)) this.#canBOM = false
+        return res
+      } catch (err) {
+        this.#chunk = null // reset unfinished chunk on errors
+        // The correct way per spec seems to be not destroying the decoder state (aka BOM here) in stream mode
+        // See also multi-byte.js
+        throw err
+      }
+
+      // eslint-disable-next-line no-else-return
+    } else if (this.#multibyte) {
+      if (!createMultibyteDecoder) throw new Error(E_MULTI)
+      if (!this.#decode) this.#decode = createMultibyteDecoder(this.encoding, !this.fatal) // can contain state!
+      return this.#decode(u, stream)
+    } else {
+      if (!this.#decode) this.#decode = createSinglebyteDecoder(this.encoding, !this.fatal)
+      return this.#decode(u)
+    }
+  }
+
+  #findBom(u) {
+    switch (this.encoding) {
+      case 'utf-8':
+        return u.byteLength >= 3 && u[0] === 0xef && u[1] === 0xbb && u[2] === 0xbf ? 3 : 0
+      case 'utf-16le':
+        return u.byteLength >= 2 && u[0] === 0xff && u[1] === 0xfe ? 2 : 0
+      case 'utf-16be':
+        return u.byteLength >= 2 && u[0] === 0xfe && u[1] === 0xff ? 2 : 0
+    }
+
+    /* c8 ignore next */
+    throw new Error('Unreachable')
+  }
+}
+
+export class TextEncoder {
+  constructor() {
+    define(this, 'encoding', 'utf-8')
+  }
+
+  get [Symbol.toStringTag]() {
+    return 'TextEncoder'
+  }
+
+  encode(str = '') {
+    if (typeof str !== 'string') str = `${str}`
+    return utf8fromStringLoose(str) // non-pooled
+  }
+
+  encodeInto(str, target) {
+    if (typeof str !== 'string') str = `${str}`
+    if (!isAnyUint8Array(target)) throw new TypeError('Target must be an Uint8Array')
+    if (target.buffer.detached) return { read: 0, written: 0 } // Until https://github.com/whatwg/encoding/issues/324 is resolved
+
+    const tlen = target.length
+    if (tlen < str.length) str = str.slice(0, tlen)
+    let u8 = utf8fromStringLoose(str)
+    let read
+    if (tlen >= u8.length) {
+      read = str.length
+    } else if (u8.length === str.length) {
+      if (u8.length > tlen) u8 = u8.subarray(0, tlen) // ascii can be truncated
+      read = u8.length
+    } else {
+      u8 = u8.subarray(0, tlen)
+      const unfinished = unfinishedBytes(u8, u8.length, 'utf-8')
+      if (unfinished > 0) u8 = u8.subarray(0, u8.length - unfinished)
+
+      // We can do this because loose str -> u8 -> str preserves length, unlike loose u8 -> str -> u8
+      // Each unpaired surrogate (1 charcode) is replaced with a single charcode
+      read = utf8toStringLoose(u8).length // FIXME: Converting back is very inefficient
+    }
+
+    try {
+      target.set(u8)
+    } catch {
+      return { read: 0, written: 0 } // see above, likely detached but no .detached property support
+    }
+
+    return { read, written: u8.length }
+  }
+}
+
+const E_NO_STREAMS = 'TransformStream global not present in the environment'
+
+// https://encoding.spec.whatwg.org/#interface-textdecoderstream
+export class TextDecoderStream {
+  constructor(encoding = 'utf-8', options = {}) {
+    if (!globalThis.TransformStream) throw new Error(E_NO_STREAMS)
+    const decoder = new TextDecoder(encoding, options)
+    const transform = new TransformStream({
+      transform: (chunk, controller) => {
+        const value = decoder.decode(fromSource(chunk), { stream: true })
+        if (value) controller.enqueue(value)
+      },
+      flush: (controller) => {
+        // https://streams.spec.whatwg.org/#dom-transformer-flush
+        const value = decoder.decode()
+        if (value) controller.enqueue(value)
+        // No need to call .terminate() (Node.js is wrong)
+      },
+    })
+
+    define(this, 'encoding', decoder.encoding)
+    define(this, 'fatal', decoder.fatal)
+    define(this, 'ignoreBOM', decoder.ignoreBOM)
+    define(this, 'readable', transform.readable)
+    define(this, 'writable', transform.writable)
+  }
+
+  get [Symbol.toStringTag]() {
+    return 'TextDecoderStream'
+  }
+}
+
+// https://encoding.spec.whatwg.org/#interface-textencoderstream
+// Only UTF-8 per spec
+export class TextEncoderStream {
+  constructor() {
+    if (!globalThis.TransformStream) throw new Error(E_NO_STREAMS)
+    let lead
+    const transform = new TransformStream({
+      // https://encoding.spec.whatwg.org/#encode-and-enqueue-a-chunk
+      // Not identical in code, but reuses loose mode to have identical behavior
+      transform: (chunk, controller) => {
+        let s = String(chunk) // DOMString, might contain unpaired surrogates
+        if (s.length === 0) return
+        if (lead) {
+          s = lead + s
+          lead = null
+        }
+
+        const last = s.charCodeAt(s.length - 1) // Can't come from previous lead due to length check
+        if ((last & 0xfc_00) === 0xd8_00) {
+          lead = s[s.length - 1]
+          s = s.slice(0, -1)
+        }
+
+        if (s) controller.enqueue(utf8fromStringLoose(s))
+      },
+      // https://encoding.spec.whatwg.org/#encode-and-flush
+      flush: (controller) => {
+        if (lead) controller.enqueue(Uint8Array.of(0xef, 0xbf, 0xbd))
+      },
+    })
+
+    define(this, 'encoding', 'utf-8')
+    define(this, 'readable', transform.readable)
+    define(this, 'writable', transform.writable)
+  }
+
+  get [Symbol.toStringTag]() {
+    return 'TextEncoderStream'
+  }
+}
+
+// https://encoding.spec.whatwg.org/#decode
+// Warning: encoding sniffed from BOM takes preference over the supplied one
+// Warning: lossy, performs replacement, no option of throwing
+// Completely ignores encoding and even skips validation when BOM is found
+// Unlike TextDecoder public API, additionally supports 'replacement' encoding
+export function legacyHookDecode(input, fallbackEncoding = 'utf-8') {
+  let u8 = fromSource(input)
+  const bomEncoding = getBOMEncoding(u8)
+  if (bomEncoding) u8 = u8.subarray(bomEncoding === 'utf-8' ? 3 : 2)
+  const enc = bomEncoding ?? normalizeEncoding(fallbackEncoding) // "the byte order mark is more authoritative than anything else"
+
+  if (enc === 'utf-8') return utf8toStringLoose(u8)
+  if (enc === 'utf-16le' || enc === 'utf-16be') {
+    let suffix = ''
+    if (u8.byteLength % 2 !== 0) {
+      suffix = replacementChar
+      u8 = u8.subarray(0, -unfinishedBytes(u8, u8.byteLength, enc))
+    }
+
+    return utf16toStringLoose(u8, enc === 'utf-16le' ? 'uint8-le' : 'uint8-be') + suffix
+  }
+
+  if (!Object.hasOwn(labels, enc)) throw new RangeError(E_ENCODING)
+
+  if (isMultibyte(enc)) {
+    if (!createMultibyteDecoder) throw new Error(E_MULTI)
+    return createMultibyteDecoder(enc, true)(u8)
+  }
+
+  // https://encoding.spec.whatwg.org/#replacement-decoder
+  // On non-streaming non-fatal case, it just replaces any non-empty input with a single replacement char
+  if (enc === 'replacement') return input.byteLength > 0 ? replacementChar : ''
+
+  return createSinglebyteDecoder(enc, true)(u8)
+}
+
+export function isomorphicDecode(input) {
+  return latin1toString(fromSource(input))
+}
+
+export function isomorphicEncode(str) {
+  return latin1fromString(str)
+}

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

@@ -0,0 +1,50 @@
+// See https://encoding.spec.whatwg.org/#names-and-labels
+
+/* eslint-disable @exodus/export-default/named */
+// prettier-ignore
+const labels = {
+  'utf-8': ['unicode-1-1-utf-8', 'unicode11utf8', 'unicode20utf8', 'utf8', 'x-unicode20utf8'],
+  'utf-16be': ['unicodefffe'],
+  'utf-16le': ['csunicode', 'iso-10646-ucs-2', 'ucs-2', 'unicode', 'unicodefeff', 'utf-16'],
+  'iso-8859-2': ['iso-ir-101'],
+  'iso-8859-3': ['iso-ir-109'],
+  'iso-8859-4': ['iso-ir-110'],
+  'iso-8859-5': ['csisolatincyrillic', 'cyrillic', 'iso-ir-144'],
+  'iso-8859-6': ['arabic', 'asmo-708', 'csiso88596e', 'csiso88596i', 'csisolatinarabic', 'ecma-114', 'iso-8859-6-e', 'iso-8859-6-i', 'iso-ir-127'],
+  'iso-8859-7': ['csisolatingreek', 'ecma-118', 'elot_928', 'greek', 'greek8', 'iso-ir-126', 'sun_eu_greek'],
+  'iso-8859-8': ['csiso88598e', 'csisolatinhebrew', 'hebrew', 'iso-8859-8-e', 'iso-ir-138', 'visual'],
+  'iso-8859-8-i': ['csiso88598i', 'logical'],
+  'iso-8859-16': [],
+  'koi8-r': ['cskoi8r', 'koi', 'koi8', 'koi8_r'],
+  'koi8-u': ['koi8-ru'],
+  'windows-874': ['dos-874', 'iso-8859-11', 'iso8859-11', 'iso885911', 'tis-620'],
+  ibm866: ['866', 'cp866', 'csibm866'],
+  'x-mac-cyrillic': ['x-mac-ukrainian'],
+  macintosh: ['csmacintosh', 'mac', 'x-mac-roman'],
+  gbk: ['chinese', 'csgb2312', 'csiso58gb231280', 'gb2312', 'gb_2312', 'gb_2312-80', 'iso-ir-58', 'x-gbk'],
+  gb18030: [],
+  big5: ['big5-hkscs', 'cn-big5', 'csbig5', 'x-x-big5'],
+  'euc-jp': ['cseucpkdfmtjapanese', 'x-euc-jp'],
+  shift_jis: ['csshiftjis', 'ms932', 'ms_kanji', 'shift-jis', 'sjis', 'windows-31j', 'x-sjis'],
+  'euc-kr': ['cseuckr', 'csksc56011987', 'iso-ir-149', 'korean', 'ks_c_5601-1987', 'ks_c_5601-1989', 'ksc5601', 'ksc_5601', 'windows-949'],
+  'iso-2022-jp': ['csiso2022jp'],
+  replacement: ['csiso2022kr', 'hz-gb-2312', 'iso-2022-cn', 'iso-2022-cn-ext', 'iso-2022-kr'],
+  'x-user-defined': [],
+}
+
+for (const i of [10, 13, 14, 15]) labels[`iso-8859-${i}`] = [`iso8859-${i}`, `iso8859${i}`]
+for (const i of [2, 6, 7]) labels[`iso-8859-${i}`].push(`iso_8859-${i}:1987`)
+for (const i of [3, 4, 5, 8]) labels[`iso-8859-${i}`].push(`iso_8859-${i}:1988`)
+// prettier-ignore
+for (let i = 2; i < 9; i++) labels[`iso-8859-${i}`].push(`iso8859-${i}`, `iso8859${i}`, `iso_8859-${i}`)
+for (let i = 2; i < 5; i++) labels[`iso-8859-${i}`].push(`csisolatin${i}`, `l${i}`, `latin${i}`)
+for (let i = 0; i < 9; i++) labels[`windows-125${i}`] = [`cp125${i}`, `x-cp125${i}`]
+
+// prettier-ignore
+labels['windows-1252'].push('ansi_x3.4-1968', 'ascii', 'cp819', 'csisolatin1', 'ibm819', 'iso-8859-1', 'iso-ir-100', 'iso8859-1', 'iso88591', 'iso_8859-1', 'iso_8859-1:1987', 'l1', 'latin1', 'us-ascii')
+// prettier-ignore
+labels['windows-1254'].push('csisolatin5', 'iso-8859-9', 'iso-ir-148', 'iso8859-9', 'iso88599', 'iso_8859-9', 'iso_8859-9:1989', 'l5', 'latin5')
+labels['iso-8859-10'].push('csisolatin6', 'iso-ir-157', 'l6', 'latin6')
+labels['iso-8859-15'].push('csisolatin9', 'iso_8859-15', 'l9')
+
+export default labels

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

@@ -0,0 +1,65 @@
+// Get a number of last bytes in an Uint8Array `u` ending at `len` that don't
+// form a codepoint yet, but can be a part of a single codepoint on more data
+export function unfinishedBytes(u, len, enc) {
+  switch (enc) {
+    case 'utf-8': {
+      // 0-3
+      let p = 0
+      while (p < 2 && p < len && (u[len - p - 1] & 0xc0) === 0x80) p++ // go back 0-2 trailing bytes
+      if (p === len) return 0 // no space for lead
+      const l = u[len - p - 1]
+      if (l < 0xc2 || l > 0xf4) return 0 // not a lead
+      if (p === 0) return 1 // nothing to recheck, we have only lead, return it. 2-byte must return here
+      if (l < 0xe0 || (l < 0xf0 && p >= 2)) return 0 // 2-byte, or 3-byte or less and we already have 2 trailing
+      const lower = l === 0xf0 ? 0x90 : l === 0xe0 ? 0xa0 : 0x80
+      const upper = l === 0xf4 ? 0x8f : l === 0xed ? 0x9f : 0xbf
+      const n = u[len - p]
+      return n >= lower && n <= upper ? p + 1 : 0
+    }
+
+    case 'utf-16le':
+    case 'utf-16be': {
+      // 0-3
+      const p = len % 2 // uneven byte length adds 1
+      if (len < 2) return p
+      const l = len - p - 1
+      const last = enc === 'utf-16le' ? (u[l] << 8) ^ u[l - 1] : (u[l - 1] << 8) ^ u[l]
+      return last >= 0xd8_00 && last < 0xdc_00 ? p + 2 : p // lone lead adds 2
+    }
+  }
+
+  throw new Error('Unsupported encoding')
+}
+
+// Merge prefix `chunk` with `u` and return new combined prefix
+// For u.length < 3, fully consumes u and can return unfinished data,
+// otherwise returns a prefix with no unfinished bytes
+export function mergePrefix(u, chunk, enc) {
+  if (u.length === 0) return chunk
+  const cl = chunk.length
+  if (u.length < 3) {
+    // No reason to bruteforce offsets, also it's possible this doesn't yet end the sequence
+    const a = new Uint8Array(cl + u.length)
+    a.set(chunk)
+    a.set(u, cl)
+    return a
+  }
+
+  // Slice off a small portion of u into prefix chunk so we can decode them separately without extending array size
+  const t = new Uint8Array(cl + 3) // We have 1-3 bytes and need 1-3 more bytes
+  t.set(chunk)
+  t.set(u.subarray(0, 3), cl)
+
+  // Stop at the first offset where unfinished bytes reaches 0 or fits into u
+  // If that doesn't happen (u too short), just concat chunk and u completely (above)
+  for (let i = 1; i <= 3; i++) {
+    const unfinished = unfinishedBytes(t, cl + i, enc) // 0-3
+    if (unfinished <= i) {
+      // Always reachable at 3, but we still need 'unfinished' value for it
+      const add = i - unfinished // 0-3
+      return add > 0 ? t.subarray(0, cl + add) : chunk
+    }
+  }
+
+  // Unreachable
+}

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

@@ -0,0 +1,152 @@
+import {
+  nativeEncoder,
+  nativeDecoder,
+  nativeDecoderLatin1,
+  nativeBuffer,
+  encodeCharcodes,
+  isHermes,
+  isDeno,
+  isLE,
+} from './platform.js'
+
+const atob = /* @__PURE__ */ (() => globalThis.atob)()
+const web64 = /* @__PURE__ */ (() => Uint8Array.prototype.toBase64)()
+
+// See http://stackoverflow.com/a/22747272/680742, which says that lowest limit is in Chrome, with 0xffff args
+// On Hermes, actual max is 0x20_000 minus current stack depth, 1/16 of that should be safe
+const maxFunctionArgs = 0x20_00
+
+// toBase64+atob path is faster on everything where fromBase64 is fast
+const useLatin1atob = web64 && atob
+
+export function asciiPrefix(arr) {
+  let p = 0 // verified ascii bytes
+  const length = arr.length
+  // Threshold tested on Hermes (worse on <=48, better on >=52)
+  // Also on v8 arrs of size <=64 might be on heap and using Uint32Array on them is unoptimal
+  if (length > 64) {
+    // Speedup with u32
+    const u32start = (4 - (arr.byteOffset & 3)) % 4 // offset start by this many bytes for alignment
+    for (; p < u32start; p++) if (arr[p] >= 0x80) return p
+    const u32length = ((arr.byteLength - u32start) / 4) | 0
+    const u32 = new Uint32Array(arr.buffer, arr.byteOffset + u32start, u32length)
+    let i = 0
+    for (const last3 = u32length - 3; ; p += 16, 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]
+      // "(a | b | c | d) & mask" is slower on Hermes though faster on v8
+      if (a & 0x80_80_80_80 || b & 0x80_80_80_80 || c & 0x80_80_80_80 || d & 0x80_80_80_80) break
+    }
+
+    for (; i < u32length; p += 4, i++) if (u32[i] & 0x80_80_80_80) break
+  }
+
+  for (; p < length; p++) if (arr[p] >= 0x80) return p
+  return length
+}
+
+// Capable of decoding Uint16Array to UTF-16 as well as Uint8Array to Latin-1
+export function decodeLatin1(arr, start = 0, stop = arr.length) {
+  start |= 0
+  stop |= 0
+  const total = stop - start
+  if (total === 0) return ''
+
+  if (
+    useLatin1atob &&
+    total >= 256 &&
+    total < 1e8 &&
+    arr.toBase64 === web64 &&
+    arr.BYTES_PER_ELEMENT === 1
+  ) {
+    const sliced = start === 0 && stop === arr.length ? arr : arr.subarray(start, stop)
+    return atob(sliced.toBase64())
+  }
+
+  if (total > maxFunctionArgs) {
+    let prefix = ''
+    for (let i = start; i < stop; ) {
+      const i1 = Math.min(stop, i + maxFunctionArgs)
+      prefix += String.fromCharCode.apply(String, arr.subarray(i, i1))
+      i = i1
+    }
+
+    return prefix
+  }
+
+  const sliced = start === 0 && stop === arr.length ? arr : arr.subarray(start, stop)
+  return String.fromCharCode.apply(String, sliced)
+}
+
+// Unchecked for well-formedness, raw. Expects Uint16Array input
+export const decodeUCS2 =
+  nativeBuffer && isLE && !isDeno
+    ? (u16, stop = u16.length) => {
+        // TODO: fast path for BE, perhaps faster path for Deno. Note that decoder replaces, this function doesn't
+        if (stop > 32) return nativeBuffer.from(u16.buffer, u16.byteOffset, stop * 2).ucs2Slice() // from 64 bytes, below are in heap
+        return decodeLatin1(u16, 0, stop)
+      }
+    : (u16, stop = u16.length) => decodeLatin1(u16, 0, stop)
+
+// Does not check input, uses best available method
+// Building an array for this is only faster than proper string concatenation when TextDecoder or native Buffer are available
+export const decodeAscii = nativeBuffer
+  ? (a) =>
+      // Buffer is faster on Node.js (but only for long enough data), if we know that output is ascii
+      a.byteLength >= 0x3_00 && !isDeno
+        ? nativeBuffer.from(a.buffer, a.byteOffset, a.byteLength).latin1Slice(0, a.byteLength) // .latin1Slice is faster than .asciiSlice
+        : nativeDecoder.decode(a) // On Node.js, utf8 decoder is faster than latin1
+  : nativeDecoderLatin1
+    ? (a) => nativeDecoderLatin1.decode(a) // On browsers (specifically WebKit), latin1 decoder is faster than utf8
+    : (a) =>
+        decodeLatin1(
+          a instanceof Uint8Array ? a : new Uint8Array(a.buffer, a.byteOffset, a.byteLength)
+        )
+
+/* eslint-disable @exodus/mutable/no-param-reassign-prop-only */
+
+export function encodeAsciiPrefix(x, s) {
+  let i = 0
+  for (const len3 = s.length - 3; i < len3; i += 4) {
+    const x0 = s.charCodeAt(i), x1 = s.charCodeAt(i + 1), x2 = s.charCodeAt(i + 2), x3 = s.charCodeAt(i + 3) // prettier-ignore
+    if ((x0 | x1 | x2 | x3) >= 128) break
+    x[i] = x0
+    x[i + 1] = x1
+    x[i + 2] = x2
+    x[i + 3] = x3
+  }
+
+  return i
+}
+
+/* eslint-enable @exodus/mutable/no-param-reassign-prop-only */
+
+// Warning: can be used only on checked strings, converts strings to 8-bit
+export const encodeLatin1 = (str) => encodeCharcodes(str, new Uint8Array(str.length))
+
+// Expects nativeEncoder to be present
+const useEncodeInto = /* @__PURE__ */ (() => isHermes && nativeEncoder?.encodeInto)()
+export const encodeAscii = useEncodeInto
+  ? (str, ERR) => {
+      // Much faster in Hermes
+      const codes = new Uint8Array(str.length + 4) // overshoot by a full utf8 char
+      const info = nativeEncoder.encodeInto(str, codes)
+      if (info.read !== str.length || info.written !== str.length) throw new SyntaxError(ERR) // non-ascii
+      return codes.subarray(0, str.length)
+    }
+  : nativeBuffer
+    ? (str, ERR) => {
+        // TextEncoder is slow on Node.js 24 / 25 (was ok on 22)
+        // Node.js Buffer.from always returns 8-byte aligned allocations, this is safe for e.g. conversion to Uint32Array
+        const codes = nativeBuffer.from(str, 'utf8') // ascii/latin1 coerces, we need to check
+        if (codes.length !== str.length) throw new SyntaxError(ERR) // non-ascii
+        return new Uint8Array(codes.buffer, codes.byteOffset, codes.byteLength)
+      }
+    : (str, ERR) => {
+        const codes = nativeEncoder.encode(str)
+        if (codes.length !== str.length) throw new SyntaxError(ERR) // non-ascii
+        return codes
+      }

package/ui/.output/server/node_modules/@exodus/bytes/fallback/multi-byte.encodings.cjs

@@ -0,0 +1 @@
+module.exports = () => require('./multi-byte.encodings.json') // lazy-load