@ohos-ports/stacksjs-stx 0.2.287-beta.0

package/dist/hot-reload.js

@@ -0,0 +1,373 @@
+export class HotReloadServer {
+  clients = new Set;
+  server = null;
+  options;
+  constructor(options = {}) {
+    this.options = {
+      wsPort: options.wsPort ?? 3001,
+      showOverlay: options.showOverlay ?? !0,
+      reconnectInterval: options.reconnectInterval ?? 1000,
+      maxReconnectAttempts: options.maxReconnectAttempts ?? 10,
+      verbose: options.verbose ?? !1
+    };
+  }
+  start(port) {
+    let wsPort = port ?? this.options.wsPort;
+    const maxAttempts = 20;
+    for (let attempt = 0;attempt < maxAttempts; attempt++)
+      try {
+        this.server = Bun.serve({
+          port: wsPort,
+          fetch(req, server) {
+            if (server.upgrade(req, { data: {} }))
+              return;
+            return new Response("stx Hot Reload Server", {
+              headers: { "Content-Type": "text/plain" }
+            });
+          },
+          websocket: {
+            open: (ws) => {
+              this.clients.add(ws);
+              if (this.options.verbose)
+                console.log(`[HMR] Client connected (${this.clients.size} total)`);
+              ws.send(JSON.stringify({
+                type: "connected",
+                timestamp: Date.now()
+              }));
+            },
+            close: (ws) => {
+              this.clients.delete(ws);
+              if (this.options.verbose)
+                console.log(`[HMR] Client disconnected (${this.clients.size} total)`);
+            },
+            message: (_ws, message) => {
+              const str = typeof message === "string" ? message : message.toString();
+              if (str === "ping")
+                return;
+              try {
+                const msg = JSON.parse(str);
+                if (msg.type === "console" && Array.isArray(msg.args)) {
+                  const args = msg.args.join(" "), c = { log: "\x1B[36m", warn: "\x1B[33m", error: "\x1B[31m", info: "\x1B[34m" }[msg.level] ?? "\x1B[36m";
+                  console.log(`${c}[browser]${msg.level !== "log" ? ` ${msg.level}` : ""}\x1B[0m ${args}`);
+                }
+              } catch {}
+            }
+          }
+        });
+        if (this.options.verbose)
+          console.log(`[HMR] WebSocket server started on port ${wsPort}`);
+        return wsPort;
+      } catch (error) {
+        if (error?.code === "EADDRINUSE") {
+          wsPort++;
+          continue;
+        }
+        throw error;
+      }
+    throw Error(`Could not find an available port after ${maxAttempts} attempts starting from ${port ?? this.options.wsPort}`);
+  }
+  stop() {
+    for (const client of this.clients)
+      try {
+        client.close();
+      } catch {}
+    this.clients.clear();
+    if (this.server) {
+      this.server.stop();
+      this.server = null;
+    }
+    if (this.options.verbose)
+      console.log("[HMR] Server stopped");
+  }
+  broadcast(message) {
+    const data = JSON.stringify(message);
+    let sent = 0;
+    for (const client of this.clients)
+      try {
+        if (client.readyState === 1) {
+          client.send(data);
+          sent++;
+        }
+      } catch {
+        this.clients.delete(client);
+      }
+    if (this.options.verbose && sent > 0)
+      console.log(`[HMR] Broadcast ${message.type} to ${sent} client(s)`);
+  }
+  reload(filePath) {
+    if (this.options.verbose)
+      console.log(`[HMR] Sending reload to ${this.clients.size} client(s) for: ${filePath || "all"}`);
+    this.broadcast({
+      type: "reload",
+      path: filePath,
+      timestamp: Date.now()
+    });
+  }
+  updateCss(filePath, content) {
+    this.broadcast({
+      type: "css-update",
+      path: filePath,
+      content,
+      timestamp: Date.now()
+    });
+  }
+  error(message) {
+    this.broadcast({
+      type: "error",
+      content: message,
+      timestamp: Date.now()
+    });
+  }
+  get clientCount() {
+    return this.clients.size;
+  }
+  get port() {
+    return this.options.wsPort;
+  }
+}
+export function generateHotReloadScript(wsPort, options = {}) {
+  const {
+    showOverlay = !0,
+    reconnectInterval = 1000,
+    maxReconnectAttempts = 10
+  } = options;
+  return `
+<script>
+(function() {
+  // stx Hot Reload Client
+  var wsUrl = 'ws://' + window.location.hostname + ':${wsPort}';
+  var reconnectAttempts = 0;
+  var maxAttempts = ${maxReconnectAttempts};
+  var reconnectInterval = ${reconnectInterval};
+  var socket = null;
+  var overlay = null;
+  var wasConnected = false; // Track if we ever connected successfully
+
+  ${showOverlay ? `
+  // Create connection status overlay
+  function createOverlay() {
+    overlay = document.createElement('div');
+    overlay.id = 'stx-hmr-overlay';
+    overlay.style.cssText = 'position:fixed;top:0;left:0;right:0;padding:8px 16px;background:#f59e0b;color:#000;font-family:system-ui,sans-serif;font-size:14px;text-align:center;z-index:999999;display:none;';
+    document.body.appendChild(overlay);
+  }
+
+  function showOverlay(message, isError) {
+    // Only show overlay if we were previously connected (don't show during initial connection)
+    if (!wasConnected && !isError) return;
+    if (!overlay) createOverlay();
+    overlay.textContent = message;
+    overlay.style.background = isError ? '#ef4444' : '#f59e0b';
+    overlay.style.color = isError ? '#fff' : '#000';
+    overlay.style.display = 'block';
+  }
+
+  function hideOverlay() {
+    if (overlay) overlay.style.display = 'none';
+  }
+  ` : `
+  function showOverlay() {}
+  function hideOverlay() {}
+  `}
+
+  function connect() {
+    try {
+      socket = new WebSocket(wsUrl);
+    }
+catch (e) {
+      // Silent fail for initial connection attempts
+      if (wasConnected) {
+        scheduleReconnect();
+      }
+      return;
+    }
+
+    socket.onopen = function() {
+      // connected silently
+      wasConnected = true;
+      reconnectAttempts = 0;
+      hideOverlay();
+    };
+
+    socket.onmessage = function(event) {
+      try {
+        var msg = JSON.parse(event.data);
+
+        switch (msg.type) {
+          case 'reload':
+            console.log('[stx] Reloading...', msg.path || '');
+            // Use SPA router for progressive update instead of full page reload.
+            // Falls back to hard reload only when the router isn't available.
+            // Call the ROUTER directly, not window.navigate: the runtime helper
+            // takes (url, options) and silently dropped the third argument, so
+            // force never arrived and the same-URL early return made this a
+            // no-op on every page that had the router (#1807). pushState=false
+            // keeps the address bar untouched (this is a reload, not a
+            // navigation) and force=true bypasses the early return.
+            if (window.stxRouter && typeof window.stxRouter.navigate === 'function') {
+              window.stxRouter.navigate(window.location.pathname + window.location.search, false, true);
+            } else {
+              window.location.reload();
+            }
+            break;
+
+          case 'css-update':
+            console.log('[stx] CSS update:', msg.path);
+            updateCss(msg.path, msg.content);
+            break;
+
+          case 'error':
+            console.error('[stx] Error:', msg.content);
+            showOverlay('Build Error: ' + msg.content, true);
+            break;
+
+          case 'connected':
+            break;
+        }
+      }
+catch (e) {
+        console.error('[stx] Invalid message:', e);
+      }
+    };
+
+    socket.onclose = function() {
+      socket = null;
+      // Only log and show overlay if we were previously connected
+      if (wasConnected) {
+        console.log('[stx] Connection closed, reconnecting...');
+        scheduleReconnect();
+      }
+else {
+        // Silently retry initial connection
+        setTimeout(connect, reconnectInterval);
+      }
+    };
+
+    socket.onerror = function() {
+      // Errors are handled in onclose
+    };
+  }
+
+  function scheduleReconnect() {
+    if (reconnectAttempts < maxAttempts) {
+      reconnectAttempts++;
+      showOverlay('Reconnecting... (' + reconnectAttempts + '/' + maxAttempts + ')');
+      setTimeout(connect, reconnectInterval);
+    }
+else {
+      showOverlay('Connection lost. Refresh to reconnect.', true);
+    }
+  }
+
+  // CSS hot update without full reload
+  function updateCss(path, content) {
+    // Try to find and update existing stylesheet
+    var links = document.querySelectorAll('link[rel="stylesheet"]');
+    for (var i = 0; i < links.length; i++) {
+      var href = links[i].getAttribute('href');
+      if (href && href.indexOf(path) !== -1) {
+        // Add cache-busting query param
+        var newHref = href.split('?')[0] + '?t=' + Date.now();
+        links[i].setAttribute('href', newHref);
+        return;
+      }
+    }
+
+    // If content provided, inject as style tag
+    if (content) {
+      var style = document.createElement('style');
+      style.setAttribute('data-stx-hmr', path);
+      style.textContent = content;
+
+      // Remove old injected style
+      var old = document.querySelector('style[data-stx-hmr="' + path + '"]');
+      if (old) old.remove();
+
+      document.head.appendChild(style);
+    }
+  }
+
+  // Start connection when DOM is ready
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', connect);
+  }
+else {
+    connect();
+  }
+
+  // Forward browser console to the dev server terminal
+  var _origLog = console.log;
+  var _origError = console.error;
+  var _origWarn = console.warn;
+  var _origInfo = console.info;
+
+  function _fwd(level, args) {
+    if (socket && socket.readyState === 1) {
+      try {
+        socket.send(JSON.stringify({
+          type: 'console',
+          level: level,
+          args: Array.prototype.slice.call(args).map(function(a) {
+            if (a === null) return 'null';
+            if (a === undefined) return 'undefined';
+            if (typeof a === 'object') { try { return JSON.stringify(a); } catch(e) { return String(a); } }
+            return String(a);
+          })
+        }));
+      } catch(e) {}
+    }
+  }
+
+  console.log = function() { _origLog.apply(console, arguments); _fwd('log', arguments); };
+  console.error = function() { _origError.apply(console, arguments); _fwd('error', arguments); };
+  console.warn = function() { _origWarn.apply(console, arguments); _fwd('warn', arguments); };
+  console.info = function() { _origInfo.apply(console, arguments); _fwd('info', arguments); };
+
+  // Expose for debugging
+  window.__stxHmr = {
+    reconnect: connect,
+    status: function() { return socket ? socket.readyState : -1; }
+  };
+})();
+</script>
+`;
+}
+export function injectHotReload(html, wsPort, options = {}) {
+  const script = generateHotReloadScript(wsPort, options), bodyIdx = html.lastIndexOf("</body>");
+  if (bodyIdx !== -1)
+    return html.slice(0, bodyIdx) + script + html.slice(bodyIdx);
+  if (html.includes("</html>"))
+    return html.replace("</html>", `${script}</html>`);
+  return html + script;
+}
+export function isCssOnlyChange(filename) {
+  const ext = filename.toLowerCase();
+  return ext.endsWith(".css") || ext.endsWith(".scss") || ext.endsWith(".sass") || ext.endsWith(".less");
+}
+export function shouldReloadOnChange(filename) {
+  const ext = filename.toLowerCase();
+  return [".stx", ".html", ".htm", ".md", ".js", ".ts", ".jsx", ".tsx", ".json"].some((e) => ext.endsWith(e));
+}
+export function shouldIgnoreFile(filename) {
+  return [
+    /^\./,
+    /node_modules/,
+    /\.stx\/output/,
+    /\.stx\/cache/,
+    /~$/,
+    /\.swp$/,
+    /\.swo$/
+  ].some((pattern) => pattern.test(filename));
+}
+let globalHmrServer = null;
+export function getHmrServer(options) {
+  if (!globalHmrServer)
+    globalHmrServer = new HotReloadServer(options);
+  return globalHmrServer;
+}
+export function stopHmrServer() {
+  if (globalHmrServer) {
+    globalHmrServer.stop();
+    globalHmrServer = null;
+  }
+}

package/dist/html-masking.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Element-position-aware masking.
+ *
+ * Several pipeline stages temporarily replace `<script>…</script>` bodies or
+ * `<!-- … -->` comments with sentinel placeholders so later passes don't process
+ * their contents, then restore them at the end. A naive global regex
+ * (`/<script…>…<\/script>/g`, `/<!--…-->/g`) also matches such a token when it
+ * appears INSIDE a quoted attribute value — e.g. `aria-label="<script>x</script>"`
+ * or `title="<!-- "><img onerror=alert(1)> -->"`. The renderer's HTML-escaping
+ * then runs against the harmless placeholder, and the raw token is restored into
+ * the attribute afterward, breaking out of it — an XSS.
+ *
+ * `maskAtElementPosition` walks the string tracking tag/attribute/quote state and
+ * only masks tokens that begin at *element position* (not within an open tag, not
+ * inside a quoted attribute value). A token embedded in an attribute is left in
+ * place to be escaped normally.
+ *
+ * This is a leaf module (no stx imports) so any stage can use it without risking
+ * an import cycle.
+ *
+ * @module html-masking
+ */
+/**
+ * Locate a maskable token starting at `html[i]`.
+ * @returns the end index (exclusive) of the token, or -1 if none starts here.
+ */
+export type TokenMatcher = (html: string, i: number) => number;
+export interface ElementPositionToken {
+    start: number;
+    end: number;
+    token: string;
+}
+/** Matches a real `<script…>…</script>` element (through the first `</script>`). */
+export declare function matchScriptElement(html: string, i: number): number;
+/** Matches a real `<style…>…</style>` element (through the first `</style>`). */
+export declare function matchStyleElement(html: string, i: number): number;
+/** Matches an HTML comment `<!-- … -->` (through the first `-->`). */
+export declare function matchHtmlComment(html: string, i: number): number;
+/**
+ * Find tokens that begin where an HTML element can actually start.
+ *
+ * The walk also treats comments and script/style raw-text bodies as opaque, so
+ * callers never see tag-like text nested inside those regions.
+ */
+export declare function scanAtElementPosition(html: string, match: TokenMatcher): ElementPositionToken[];
+/**
+ * Cheap, conservative preflight for the unresolved-expression cloak pass.
+ *
+ * A mustache in an element's own text needs at least two opening and two
+ * closing braces outside tags, comments, and script/style raw text. They may
+ * be separated by child elements, so looking only for contiguous `{{` is NOT
+ * sufficient. False positives merely run the normal cloak scan; false
+ * negatives would leave an unresolved expression visible.
+ */
+export declare function mightContainOwnTextMustache(html: string): boolean;
+/**
+ * Drop the oldest entries until there is room for one more.
+ *
+ * Wholesale `clear()` was the first version and it made the caches useless: a
+ * render cycles through more distinct documents than the cap, so hitting the cap
+ * wiped the entry that was about to be reused. Measured on the #1945 fixture, one
+ * key-and-content pair missed 24 times in a row — computed every time, hit never.
+ * A Map iterates in insertion order, so the first key is the oldest.
+ */
+export declare function evictOldest(cache: Map<string, unknown>, maxEntries: number): void;
+/**
+ * Drop cached mask results.
+ *
+ * Nothing in the framework calls this, and nothing needs to. Entries are keyed
+ * on the input document itself plus the caller's placeholder key, so an edited
+ * template is a different key and can never be answered with a stale result --
+ * there is no invalidation to perform. It exists for callers that want a cold
+ * cache, such as tests.
+ */
+export declare function clearMaskCache(): void;
+/**
+ * Mask every token (per `match`) that begins at element position, replacing it
+ * with `placeholder(token, index)`. Returns the rewritten string plus the ordered
+ * list of removed tokens. Restore by replacing each placeholder with `tokens[i]`.
+ *
+ * Note: HTML attributes do not use backslash escaping, so a `"`/`'` always
+ * toggles the surrounding quote — matching how browsers parse attribute values.
+ */
+export declare function maskAtElementPosition(html: string, match: TokenMatcher, placeholder: (token: string, index: number) => string, 
+/**
+ * Opt in to memoisation. Must fully determine what `placeholder` returns for
+ * a given index — two calls sharing a key MUST be interchangeable.
+ */
+cacheKey?: string): {
+    output: string;
+    tokens: string[];
+};
+export interface StashedScripts {
+    /** The document with each `<script>` element replaced by a NUL sentinel. */
+    output: string;
+    /** The removed script elements, in placeholder order. */
+    scripts: string[];
+    /**
+     * Put the scripts back.
+     *
+     * Returns the pre-stash document unchanged when `html` is still the masked
+     * output. Stashing replaces each script with a sentinel and restoring puts
+     * exactly those scripts back at exactly those sentinels, so when nothing
+     * edited the masked document in between, the replace pass can only rebuild,
+     * character by character, a string the caller already handed us.
+     *
+     * That is the common case, not a corner: one render of the #1945 fixture
+     * reaches this having changed nothing in FOUR of five passes, rebuilding
+     * 445,208 bytes to arrive back where it started. The component loop stashes
+     * on every pass but only the first pass resolves anything.
+     */
+    restore: (html: string) => string;
+}
+export declare function stashScriptElements(html: string): StashedScripts;
+/**
+ * Drop cached stash results.
+ *
+ * Nothing in the framework calls this, and nothing needs to. Entries are keyed
+ * on the input document itself, so an edited template is a different key and
+ * can never be answered with a stale result -- there is no invalidation to
+ * perform. It exists for callers that want a cold cache, such as tests.
+ */
+export declare function clearStashCache(): void;
+/** Restore scripts stashed by {@link stashScriptElements}. */
+export declare function restoreStashedScripts(html: string, scripts: string[]): string;

package/dist/html-masking.js

@@ -0,0 +1,196 @@
+const SCRIPT_OPEN = /<script\b[^>]*>/iy, SCRIPT_CLOSE = /<\/script\s*>/ig, STYLE_OPEN = /<style\b[^>]*>/iy, STYLE_CLOSE = /<\/style\s*>/ig;
+function matchElement(html, i, open, close) {
+  open.lastIndex = i;
+  const om = open.exec(html);
+  if (!om || om.index !== i)
+    return -1;
+  close.lastIndex = open.lastIndex;
+  const cm = close.exec(html);
+  if (!cm)
+    return -1;
+  return cm.index + cm[0].length;
+}
+export function matchScriptElement(html, i) {
+  return matchElement(html, i, SCRIPT_OPEN, SCRIPT_CLOSE);
+}
+export function matchStyleElement(html, i) {
+  return matchElement(html, i, STYLE_OPEN, STYLE_CLOSE);
+}
+export function matchHtmlComment(html, i) {
+  if (!html.startsWith("<!--", i))
+    return -1;
+  const closeRel = html.indexOf("-->", i + 4);
+  if (closeRel === -1)
+    return -1;
+  return closeRel + 3;
+}
+function matchOpaqueRegion(html, i) {
+  if (html.startsWith("<!--", i)) {
+    const end = matchHtmlComment(html, i);
+    return end === -1 ? html.length : end;
+  }
+  SCRIPT_OPEN.lastIndex = i;
+  if (SCRIPT_OPEN.exec(html)?.index === i) {
+    SCRIPT_CLOSE.lastIndex = SCRIPT_OPEN.lastIndex;
+    const close = SCRIPT_CLOSE.exec(html);
+    return close ? close.index + close[0].length : html.length;
+  }
+  STYLE_OPEN.lastIndex = i;
+  if (STYLE_OPEN.exec(html)?.index === i) {
+    STYLE_CLOSE.lastIndex = STYLE_OPEN.lastIndex;
+    const close = STYLE_CLOSE.exec(html);
+    return close ? close.index + close[0].length : html.length;
+  }
+  return -1;
+}
+export function scanAtElementPosition(html, match) {
+  const tokens = [];
+  let i = 0;
+  const n = html.length;
+  let inTag = !1, quote = null;
+  while (i < n) {
+    const ch = html[i];
+    if (inTag) {
+      if (quote) {
+        if (ch === quote)
+          quote = null;
+      } else if (ch === '"' || ch === "'")
+        quote = ch;
+      else if (ch === ">")
+        inTag = !1;
+      i++;
+      continue;
+    }
+    if (ch !== "<") {
+      const next = html.indexOf("<", i + 1);
+      if (next === -1)
+        break;
+      i = next;
+      continue;
+    }
+    const end = match(html, i);
+    if (end > i) {
+      tokens.push({ start: i, end, token: html.slice(i, end) });
+      i = end;
+      continue;
+    }
+    const opaqueEnd = matchOpaqueRegion(html, i);
+    if (opaqueEnd > i) {
+      i = opaqueEnd;
+      continue;
+    }
+    const letter = html.charCodeAt(i + 1);
+    if (letter >= 65 && letter <= 90 || letter >= 97 && letter <= 122)
+      inTag = !0;
+    i++;
+  }
+  return tokens;
+}
+export function mightContainOwnTextMustache(html) {
+  let opening = 0, closing = 0, i = 0, inTag = !1, quote = null;
+  while (i < html.length) {
+    if (inTag) {
+      const ch = html[i];
+      if (quote) {
+        if (ch === quote)
+          quote = null;
+      } else if (ch === '"' || ch === "'")
+        quote = ch;
+      else if (ch === ">")
+        inTag = !1;
+      i++;
+      continue;
+    }
+    const lt = html.indexOf("<", i), textEnd = lt === -1 ? html.length : lt;
+    while (i < textEnd) {
+      const ch = html[i++];
+      if (ch === "{")
+        opening++;
+      else if (ch === "}")
+        closing++;
+      if (opening >= 2 && closing >= 2)
+        return !0;
+    }
+    if (lt === -1)
+      break;
+    const opaqueEnd = matchOpaqueRegion(html, lt);
+    if (opaqueEnd > lt) {
+      i = opaqueEnd;
+      continue;
+    }
+    const first = html.charCodeAt(lt + 1), letter = first === 47 ? html.charCodeAt(lt + 2) : first;
+    if (letter >= 65 && letter <= 90 || letter >= 97 && letter <= 122)
+      inTag = !0;
+    i = lt + 1;
+  }
+  return !1;
+}
+export function evictOldest(cache, maxEntries) {
+  while (cache.size >= maxEntries) {
+    const oldest = cache.keys().next();
+    if (oldest.done)
+      return;
+    cache.delete(oldest.value);
+  }
+}
+const MASK_CACHE_MIN_BYTES = 65536, MASK_CACHE_MAX_ENTRIES = 12, maskCache = new Map;
+export function clearMaskCache() {
+  maskCache.clear();
+}
+export function maskAtElementPosition(html, match, placeholder, cacheKey) {
+  const cacheable = cacheKey !== void 0 && html.length >= MASK_CACHE_MIN_BYTES, key = cacheable ? `${cacheKey}\x00${html}` : "";
+  if (cacheable) {
+    const hit = maskCache.get(key);
+    if (hit)
+      return { output: hit.output, tokens: hit.tokens.slice() };
+  }
+  const matches = scanAtElementPosition(html, match);
+  if (matches.length === 0)
+    return { output: html, tokens: [] };
+  const tokens = matches.map((item) => item.token);
+  let output = "", cursor = 0;
+  for (let index = 0;index < matches.length; index++) {
+    const item = matches[index];
+    output += html.slice(cursor, item.start);
+    output += placeholder(item.token, index);
+    cursor = item.end;
+  }
+  output += html.slice(cursor);
+  if (cacheable) {
+    evictOldest(maskCache, MASK_CACHE_MAX_ENTRIES);
+    maskCache.set(key, { output, tokens });
+    return { output, tokens: tokens.slice() };
+  }
+  return { output, tokens };
+}
+const STASH_CACHE_MIN_BYTES = 65536, STASH_CACHE_MAX_ENTRIES = 4, stashCache = new Map;
+function stashResult(input, output, scripts) {
+  return {
+    output,
+    scripts,
+    restore: (html) => html === output ? input : restoreStashedScripts(html, scripts)
+  };
+}
+export function stashScriptElements(html) {
+  const cacheable = html.length >= STASH_CACHE_MIN_BYTES;
+  if (cacheable) {
+    const hit = stashCache.get(html);
+    if (hit)
+      return stashResult(html, hit.output, hit.scripts.slice());
+  }
+  const { output, tokens } = maskAtElementPosition(html, matchScriptElement, (_token, index) => `\x00STX_SCRIPT_${index}\x00`);
+  if (cacheable) {
+    evictOldest(stashCache, STASH_CACHE_MAX_ENTRIES);
+    stashCache.set(html, { output, scripts: tokens });
+    return stashResult(html, output, tokens.slice());
+  }
+  return stashResult(html, output, tokens);
+}
+export function clearStashCache() {
+  stashCache.clear();
+}
+export function restoreStashedScripts(html, scripts) {
+  if (scripts.length === 0)
+    return html;
+  return html.replace(/\x00STX_SCRIPT_(\d+)\x00/g, (_, idx) => scripts[+idx] ?? "");
+}