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

package/dist/signal-processing.js

@@ -0,0 +1,1081 @@
+import { generateServerDataBridge, injectBrowserCoreAutoImports } from "./client-script.js";
+import { findIfBlocks } from "./parser/index.js";
+import { buildRuntimeGlobalsDestructure, templateNeedsRuntime, usesReactiveRuntime } from "./runtime-globals.js";
+import { escapeScriptBody } from "./script-emit.js";
+import { transformStoreImports } from "./store-imports.js";
+import { shouldTranspileTypeScript, transpileTypeScript } from "./utils.js";
+import { injectSignalsRuntime } from "./runtime-injection.js";
+import { evictOldest, matchScriptElement, scanAtElementPosition } from "./html-masking.js";
+import { importOnce } from "./lazy-module.js";
+let signalSetupCounter = 0;
+const TAG_ATTR_RUN = `(?:"[^"]*"|'[^']*'|[^>"'])*`, SINGLE_ELEMENT_RE = /^<([a-zA-Z][a-zA-Z0-9-]*)\b((?:\s+[^=\s>]+(?:=(?:"[^"]*"|'[^']*'|[^\s>]*))?)*\s*)>([\s\S]*)<\/\1>$/s, SCRIPT_SCAN_CACHE_MIN_BYTES = 65536, SCRIPT_SCAN_CACHE_MAX_ENTRIES = 4, scriptScanCache = new Map;
+export function clearScriptScanCache() {
+  scriptScanCache.clear();
+}
+function scanScriptTagsUncached(html) {
+  const out = [];
+  for (const item of scanAtElementPosition(html, matchScriptElement)) {
+    const opening = item.token.match(/^<script\b([^>]*)>/i), closing = item.token.match(/<\/script\s*>$/i);
+    if (!opening || !closing)
+      continue;
+    const bodyStart = opening[0].length, bodyEnd = item.token.length - closing[0].length;
+    out.push(Object.freeze({
+      fullMatch: item.token,
+      attrs: opening[1],
+      body: item.token.slice(bodyStart, bodyEnd),
+      start: item.start,
+      end: item.end
+    }));
+  }
+  return out;
+}
+export function scanScriptTags(html, opts = {}) {
+  const cacheable = html.length >= SCRIPT_SCAN_CACHE_MIN_BYTES;
+  let all = cacheable ? scriptScanCache.get(html) : void 0;
+  if (all === void 0) {
+    all = scanScriptTagsUncached(html);
+    if (cacheable) {
+      evictOldest(scriptScanCache, SCRIPT_SCAN_CACHE_MAX_ENTRIES);
+      scriptScanCache.set(html, all);
+    }
+  }
+  const skip = opts.skipAttrs;
+  if (!skip)
+    return all.slice();
+  const out = [];
+  for (const tag of all) {
+    skip.lastIndex = 0;
+    if (!skip.test(tag.attrs))
+      out.push(tag);
+  }
+  return out;
+}
+export function parseLoopExpression(expr) {
+  const trimmed = expr.trim(), asMatch = trimmed.match(/^([\s\S]+?)\s+as\s+(.+)$/);
+  if (asMatch) {
+    const iterable = asMatch[1].trim(), spec = asMatch[2].trim(), { itemVar, indexVar } = parseItemSpec(spec);
+    if (itemVar)
+      return { style: "as", iterable, itemVar, indexVar };
+  }
+  const inMatch = trimmed.match(/^(\([^)]+\)|\w+(?:\s*,\s*\w+)?)\s+(?:in|of)\s+([\s\S]+)$/);
+  if (inMatch) {
+    const spec = inMatch[1].trim(), iterable = inMatch[2].trim(), { itemVar, indexVar } = parseItemSpec(spec);
+    if (itemVar)
+      return { style: "in", iterable, itemVar, indexVar };
+  }
+  return { style: "unknown", iterable: null, itemVar: null, indexVar: null };
+}
+function parseItemSpec(spec) {
+  const trimmed = spec.trim(), arrow = trimmed.match(/^(\w+)\s*=>\s*(\w+)$/);
+  if (arrow)
+    return { itemVar: arrow[2], indexVar: arrow[1] };
+  const paren = trimmed.match(/^\(\s*(\w+)(?:\s*,\s*(\w+))?\s*\)$/);
+  if (paren)
+    return { itemVar: paren[1], indexVar: paren[2] || null };
+  const pair = trimmed.match(/^(\w+)\s*,\s*(\w+)$/);
+  if (pair)
+    return { itemVar: pair[1], indexVar: pair[2] };
+  const single = trimmed.match(/^(\w+)$/);
+  if (single)
+    return { itemVar: single[1], indexVar: null };
+  return { itemVar: null, indexVar: null };
+}
+export function hasSignalsSyntax(template, filePath) {
+  return templateNeedsRuntime(template, filePath);
+}
+function hasTopLevelElseBranch(content) {
+  const tokenRegex = /@(if\s*\(|endif|elseif\s*\(|else\b)/g;
+  let depth = 0, m;
+  while ((m = tokenRegex.exec(content)) !== null) {
+    const tok = m[1];
+    if (tok.startsWith("if"))
+      depth++;
+    else if (tok === "endif")
+      depth--;
+    else if (depth === 0)
+      return !0;
+  }
+  return !1;
+}
+function extractClientSignalNames(template) {
+  const names = new Set, scriptRe = /<script\b(?![^>]*\bserver\b)(?![^>]*\bsrc\s*=)[^>]*>([\s\S]*?)<\/script>/gi, declRe = /\b(?:const|let|var)\s+([a-zA-Z_$][\w$]*)\s*=\s*(?:state|derived|computed|ref|reactive|signal)\s*(?:<[^>]*>)?\s*\(/g;
+  let scriptMatch;
+  while ((scriptMatch = scriptRe.exec(template)) !== null) {
+    const body = scriptMatch[1];
+    let declMatch;
+    while ((declMatch = declRe.exec(body)) !== null)
+      names.add(declMatch[1]);
+  }
+  return names;
+}
+function collectClientLoopScopes(template) {
+  if (!/[:@]for\s*=/.test(template) && !/\bx-for\s*=/.test(template))
+    return [];
+  const openingTag = new RegExp(`<([a-zA-Z][\\w-]*)\\b(${TAG_ATTR_RUN})>`, "iy"), loopAttr = /(?:^|\s)(?::for|@for|x-for)\s*=\s*(?:"([^"]*)"|'([^']*)')/i, starts = scanAtElementPosition(template, (html, index) => {
+    openingTag.lastIndex = index;
+    const match = openingTag.exec(html);
+    if (!match || match.index !== index || !loopAttr.test(match[2]))
+      return -1;
+    return openingTag.lastIndex;
+  }), scopes = [];
+  for (const start of starts) {
+    openingTag.lastIndex = 0;
+    const match = openingTag.exec(start.token);
+    if (!match)
+      continue;
+    const attrMatch = match[2].match(loopAttr), parsed = parseLoopExpression(attrMatch?.[1] ?? attrMatch?.[2] ?? ""), vars = [parsed.itemVar, parsed.indexVar].filter(Boolean);
+    if (vars.length === 0)
+      continue;
+    const tag = match[1], end = /\/\s*>$/.test(start.token) || VOID_ELEMENT_TAGS.has(tag.toLowerCase()) ? start.end : findElementEnd(template, start.start, tag, start.end);
+    if (end !== -1)
+      scopes.push({ start: start.start, end, vars: new Set(vars) });
+  }
+  return scopes;
+}
+const JS_NON_VARS = new Set([
+  "true",
+  "false",
+  "null",
+  "undefined",
+  "NaN",
+  "Infinity",
+  "typeof",
+  "instanceof",
+  "in",
+  "of",
+  "new",
+  "void",
+  "delete",
+  "this",
+  "Math",
+  "JSON",
+  "Date",
+  "Number",
+  "String",
+  "Boolean",
+  "Array",
+  "Object",
+  "RegExp",
+  "Map",
+  "Set",
+  "Symbol",
+  "parseInt",
+  "parseFloat",
+  "isNaN",
+  "isFinite",
+  "encodeURIComponent",
+  "decodeURIComponent",
+  "encodeURI",
+  "decodeURI",
+  "window",
+  "document",
+  "console"
+]);
+function stripExprStrings(expr) {
+  return expr.replace(/'(?:\\.|[^'\\])*'/g, "''").replace(/"(?:\\.|[^"\\])*"/g, '""').replace(/`(?:\\.|[^`\\])*`/g, "``");
+}
+function conditionIsClientReactive(condition, signalNames, context, clientLoopVars) {
+  if (!condition)
+    return !1;
+  const expr = stripExprStrings(condition);
+  let refsSignal = !1, refsServerVar = !1, refsZeroArgGetter = !1;
+  const idRe = /([a-zA-Z_$][\w$]*)/g;
+  let m;
+  while ((m = idRe.exec(expr)) !== null) {
+    const id = m[1];
+    if (expr.slice(0, m.index).trimEnd().endsWith("."))
+      continue;
+    if (JS_NON_VARS.has(id))
+      continue;
+    if (signalNames.has(id) || clientLoopVars?.has(id))
+      refsSignal = !0;
+    else if (context && id in context)
+      refsServerVar = !0;
+  }
+  const getterRe = /([a-zA-Z_$][\w$]*)(?:\.[a-zA-Z_$][\w$]*)*\s*\(\s*\)/g;
+  let c;
+  while ((c = getterRe.exec(expr)) !== null) {
+    const root = c[1];
+    if (expr.slice(0, c.index).trimEnd().endsWith("."))
+      continue;
+    if (JS_NON_VARS.has(root) || context && root in context)
+      continue;
+    refsZeroArgGetter = !0;
+  }
+  return (refsSignal || refsZeroArgGetter) && !refsServerVar;
+}
+function branchToAttrElement(content, attrName, attrValue) {
+  const attr = attrValue === void 0 ? ` ${attrName}` : ` ${attrName}="${attrValue.replace(/"/g, "&quot;")}"`, trimmed = content.trim(), singleElementMatch = trimmed.match(SINGLE_ELEMENT_RE);
+  if (singleElementMatch && isBalancedForTag(singleElementMatch[3], singleElementMatch[1])) {
+    const [, tag, attrs, innerContent] = singleElementMatch;
+    return `<${tag}${attrs}${attr}>${innerContent}</${tag}>`;
+  }
+  return `<template${attr}>${trimmed}</template>`;
+}
+function isBalancedForTag(inner, tag) {
+  const tokenRe = new RegExp(`<(/)?${tag}(?=[\\s/>])`, "gi");
+  let depth = 0, m;
+  while ((m = tokenRe.exec(inner)) !== null)
+    if (m[1]) {
+      depth--;
+      if (depth < 0)
+        return !1;
+    } else
+      depth++;
+  return !0;
+}
+export function convertSignalDirectivesToAttributes(template, context) {
+  const signalNames = extractClientSignalNames(template);
+  function convert(input) {
+    let output = input;
+    const clientLoopScopes = collectClientLoopScopes(input), loopVarsAt = (position) => {
+      const vars = new Set;
+      for (const scope of clientLoopScopes)
+        if (position > scope.start && position < scope.end)
+          for (const name of scope.vars)
+            vars.add(name);
+      return vars;
+    }, ifDirectiveStart = /@if\s*\(/g;
+    let match;
+    const replacements = [];
+    while ((match = ifDirectiveStart.exec(output)) !== null) {
+      const startIdx = match.index, exprStart = startIdx + match[0].length;
+      let depth = 1, i = exprStart;
+      while (i < output.length && depth > 0) {
+        if (output[i] === "(")
+          depth++;
+        else if (output[i] === ")")
+          depth--;
+        i++;
+      }
+      if (depth !== 0)
+        continue;
+      const condition = output.substring(exprStart, i - 1).trim(), afterCondition = i;
+      let ifDepth = 1, endIdx = afterCondition;
+      const endifRegex = /@(if\s*\(|endif)/g;
+      endifRegex.lastIndex = afterCondition;
+      let endMatch;
+      while ((endMatch = endifRegex.exec(output)) !== null)
+        if (endMatch[1].startsWith("if"))
+          ifDepth++;
+        else if (endMatch[1] === "endif") {
+          ifDepth--;
+          if (ifDepth === 0) {
+            endIdx = endMatch.index + endMatch[0].length;
+            break;
+          }
+        }
+      if (ifDepth !== 0)
+        continue;
+      const content = output.substring(afterCondition, endIdx - 6).trim();
+      let replacement;
+      if (hasTopLevelElseBranch(content)) {
+        const parsed = findIfBlocks(output.substring(startIdx, endIdx));
+        if (parsed.length === 0)
+          continue;
+        const valueBranches = parsed[0].branches.filter((b) => b.type !== "else"), clientLoopVars = loopVarsAt(startIdx);
+        if (!(valueBranches.length > 0 && valueBranches.every((b) => conditionIsClientReactive(b.condition, signalNames, context, clientLoopVars))))
+          continue;
+        replacement = parsed[0].branches.map((branch) => {
+          const branchContent = convert(branch.content);
+          if (branch.type === "elseif")
+            return branchToAttrElement(branchContent, "@else-if", branch.condition ?? "");
+          if (branch.type === "else")
+            return branchToAttrElement(branchContent, "@else");
+          return branchToAttrElement(branchContent, "@if", branch.condition ?? "");
+        }).join(`
+`);
+      } else {
+        if (!conditionIsClientReactive(condition, signalNames, context, loopVarsAt(startIdx)))
+          continue;
+        replacement = branchToAttrElement(convert(content), "@if", condition);
+      }
+      replacements.push({ start: startIdx, end: endIdx, replacement });
+      ifDirectiveStart.lastIndex = endIdx;
+    }
+    for (let i = replacements.length - 1;i >= 0; i--) {
+      const { start, end, replacement } = replacements[i];
+      output = output.substring(0, start) + replacement + output.substring(end);
+    }
+    return output;
+  }
+  return convert(template);
+}
+function evalLiteralCondition(expr) {
+  const trimmed = expr.trim();
+  if (trimmed === "")
+    return;
+  if (trimmed === "true")
+    return !0;
+  if (trimmed === "false")
+    return !1;
+  if (trimmed === "null")
+    return !1;
+  if (trimmed === "undefined")
+    return !1;
+  if (trimmed === "NaN")
+    return !1;
+  if (/^-?\d+(?:\.\d+)?$/.test(trimmed)) {
+    const n = Number(trimmed);
+    return n !== 0 && !Number.isNaN(n);
+  }
+  const singleQ = trimmed.match(/^'((?:\\.|[^'\\])*)'$/);
+  if (singleQ)
+    return singleQ[1].length > 0;
+  const doubleQ = trimmed.match(/^"((?:\\.|[^"\\])*)"$/);
+  if (doubleQ)
+    return doubleQ[1].length > 0;
+  return;
+}
+const VOID_ELEMENT_TAGS = new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]), RAW_TEXT_OPEN_TAG = /<(script|style)\b/iy, SCRIPT_CLOSE_PREFIX = /<\/script/gi, STYLE_CLOSE_PREFIX = /<\/style/gi;
+function findElementEnd(output, startIdx, tag, startTagEnd) {
+  if (VOID_ELEMENT_TAGS.has(tag.toLowerCase()))
+    return startTagEnd;
+  const lower = tag.toLowerCase(), len = output.length;
+  let depth = 1, i = startTagEnd;
+  while (i < len) {
+    const lt = output.indexOf("<", i);
+    if (lt === -1)
+      return -1;
+    i = lt;
+    if (output.startsWith("<!--", i)) {
+      const c = output.indexOf("-->", i + 4);
+      if (c === -1)
+        return -1;
+      i = c + 3;
+      continue;
+    }
+    RAW_TEXT_OPEN_TAG.lastIndex = i;
+    const raw = RAW_TEXT_OPEN_TAG.exec(output);
+    if (raw) {
+      const startGt = output.indexOf(">", i);
+      if (startGt === -1)
+        return -1;
+      if (output[startGt - 1] === "/") {
+        i = startGt + 1;
+        continue;
+      }
+      const closeRe = raw[1].toLowerCase() === "script" ? SCRIPT_CLOSE_PREFIX : STYLE_CLOSE_PREFIX;
+      closeRe.lastIndex = i;
+      const close = closeRe.exec(output);
+      if (close === null)
+        return -1;
+      const gt = output.indexOf(">", close.index);
+      if (gt === -1)
+        return -1;
+      i = gt + 1;
+      continue;
+    }
+    if (output[i + 1] === "/") {
+      const m = /^<\/([a-z][\w-]*)\s*>/i.exec(output.slice(i, i + 64));
+      if (!m) {
+        i++;
+        continue;
+      }
+      if (m[1].toLowerCase() === lower) {
+        depth--;
+        i += m[0].length;
+        if (depth === 0)
+          return i;
+        continue;
+      }
+      i += m[0].length;
+      continue;
+    }
+    const om = /^<([a-z][\w-]*)\b/i.exec(output.slice(i, i + 64));
+    if (!om) {
+      i++;
+      continue;
+    }
+    const gt = output.indexOf(">", i);
+    if (gt === -1)
+      return -1;
+    if (om[1].toLowerCase() === lower) {
+      const tagStr = output.slice(i, gt + 1);
+      if (!(/\/\s*>$/.test(tagStr) || VOID_ELEMENT_TAGS.has(lower)))
+        depth++;
+    }
+    i = gt + 1;
+  }
+  return -1;
+}
+const ELSE_ATTR_RE = /\s(?::else-if|x-else-if|@else-if|:else|x-else|@else)(?=[=\s/>])/;
+function nextSiblingHasElse(template, fromIndex) {
+  let i = fromIndex;
+  const len = template.length;
+  for (;; ) {
+    while (i < len && template[i] !== "<")
+      i++;
+    if (i >= len)
+      return !1;
+    if (template.startsWith("<!--", i)) {
+      const close = template.indexOf("-->", i + 4);
+      if (close === -1)
+        return !1;
+      i = close + 3;
+      continue;
+    }
+    break;
+  }
+  if (template[i + 1] === "/")
+    return !1;
+  const tagEnd = template.indexOf(">", i);
+  if (tagEnd === -1)
+    return !1;
+  const startTag = template.slice(i, tagEnd + 1);
+  return ELSE_ATTR_RE.test(startTag);
+}
+export function preEvalLiteralReactiveIfs(template) {
+  if (!template.includes(":if") && !template.includes(":show") && !template.includes("x-if") && !template.includes("x-show") && !template.includes("@if=") && !template.includes("@show="))
+    return template;
+  const skipRanges = [], rawTagRe = /<(script|style)\b[^>]*>[\s\S]*?<\/\1\s*>/gi;
+  let rawMatch;
+  while ((rawMatch = rawTagRe.exec(template)) !== null)
+    skipRanges.push([rawMatch.index, rawMatch.index + rawMatch[0].length]);
+  const inSkipRange = (i) => skipRanges.some(([s, e]) => i >= s && i < e), tagWithLiteralIf = /<([a-zA-Z][\w-]*)\b((?:\s+[^=\s>]+(?:=(?:"[^"]*"|'[^']*'|[^\s>]*))?)*?)\s+(:if|:show|x-if|x-show|@if|@show)\s*=\s*"([^"]*)"((?:\s+[^=\s>]+(?:=(?:"[^"]*"|'[^']*'|[^\s>]*))?)*\s*)(\/?)>/g, replacements = [];
+  let m;
+  while ((m = tagWithLiteralIf.exec(template)) !== null) {
+    if (inSkipRange(m.index))
+      continue;
+    const [full, tag, beforeAttrs, attrName, value, afterAttrs, selfClose] = m, verdict = evalLiteralCondition(value);
+    if (verdict === void 0)
+      continue;
+    const startIdx = m.index, startTagEnd = startIdx + full.length, elementEnd = !!selfClose || /\/\s*>$/.test(full) || VOID_ELEMENT_TAGS.has(tag.toLowerCase()) ? startTagEnd : findElementEnd(template, startIdx, tag, startTagEnd);
+    if (elementEnd === -1)
+      continue;
+    if ((attrName === ":if" || attrName === "x-if" || attrName === "@if") && nextSiblingHasElse(template, elementEnd)) {
+      tagWithLiteralIf.lastIndex = startTagEnd;
+      continue;
+    }
+    if (verdict === !0) {
+      const rebuiltStartTag = `<${tag}${beforeAttrs}${afterAttrs}${selfClose}>`;
+      replacements.push({ start: startIdx, end: startTagEnd, replacement: rebuiltStartTag });
+      continue;
+    }
+    replacements.push({ start: startIdx, end: elementEnd, replacement: "" });
+    tagWithLiteralIf.lastIndex = elementEnd;
+  }
+  if (replacements.length === 0)
+    return template;
+  replacements.sort((a, b) => a.start - b.start);
+  const safe = [];
+  let highWater = -1;
+  for (const r of replacements) {
+    if (r.start < highWater)
+      continue;
+    safe.push(r);
+    highWater = r.end;
+  }
+  let output = template;
+  for (let i = safe.length - 1;i >= 0; i--) {
+    const { start, end, replacement } = safe[i];
+    output = output.substring(0, start) + replacement + output.substring(end);
+  }
+  return output;
+}
+export function convertSignalLoopsToAttributes(template, context) {
+  let output = template;
+  const forDirectiveStart = /@(for|foreach)\s*\(/g;
+  let match;
+  const replacements = [], serverScopes = [];
+  while ((match = forDirectiveStart.exec(output)) !== null) {
+    const directive = match[1], startIdx = match.index, exprStart = startIdx + match[0].length;
+    let depth = 1, i = exprStart;
+    while (i < output.length && depth > 0) {
+      if (output[i] === "(")
+        depth++;
+      else if (output[i] === ")")
+        depth--;
+      i++;
+    }
+    if (depth !== 0)
+      continue;
+    let expr = output.substring(exprStart, i - 1).trim();
+    const afterExpr = i, parsed = parseLoopExpression(expr), endTag = directive === "for" ? "@endfor" : "@endforeach";
+    let forDepth = 1, endIdx = afterExpr;
+    const endRegex = directive === "for" ? new RegExp("@(for(?!each)\\s*\\(|endfor(?!each))", "g") : new RegExp(`@(${directive}\\s*\\(|end${directive})`, "g");
+    endRegex.lastIndex = afterExpr;
+    let endMatch;
+    while ((endMatch = endRegex.exec(output)) !== null)
+      if (endMatch[1].startsWith(directive))
+        forDepth++;
+      else {
+        forDepth--;
+        if (forDepth === 0) {
+          endIdx = endMatch.index + endMatch[0].length;
+          break;
+        }
+      }
+    if (forDepth !== 0)
+      continue;
+    const keepServerSide = () => {
+      const vars = [parsed.itemVar, parsed.indexVar].filter(Boolean);
+      if (vars.length)
+        serverScopes.push({ start: startIdx, end: endIdx, vars });
+    };
+    if (parsed.iterable) {
+      const iter = parsed.iterable.trim();
+      if (iter.startsWith("[") || iter.startsWith("{") || iter.startsWith("'") || iter.startsWith('"') || iter.startsWith("`") || /^-?\d/.test(iter)) {
+        keepServerSide();
+        continue;
+      }
+      const rootVar = iter.split(/[.[(]/)[0].trim(), fromContext = context ? rootVar in context : !1, fromEnclosingLoop = serverScopes.some((s) => startIdx > s.start && startIdx < s.end && s.vars.includes(rootVar));
+      if (rootVar && (fromContext || fromEnclosingLoop)) {
+        keepServerSide();
+        continue;
+      }
+    }
+    if (parsed.style === "as")
+      expr = parsed.indexVar ? `(${parsed.itemVar}, ${parsed.indexVar}) in ${parsed.iterable}` : `${parsed.itemVar} in ${parsed.iterable}`;
+    const content = output.substring(afterExpr, endIdx - endTag.length).trim(), nestedContext = context ? { ...context } : {};
+    if (parsed.itemVar)
+      delete nestedContext[parsed.itemVar];
+    if (parsed.indexVar)
+      delete nestedContext[parsed.indexVar];
+    const convertedContent = convertSignalLoopsToAttributes(content, nestedContext), singleElementMatch = convertedContent.match(SINGLE_ELEMENT_RE);
+    let replacement;
+    if (singleElementMatch) {
+      const [, tag, attrs, innerContent] = singleElementMatch;
+      replacement = `<${tag}${attrs} @for="${expr}">${innerContent}</${tag}>`;
+    } else
+      replacement = `<template @for="${expr}">${convertedContent}</template>`;
+    replacements.push({ start: startIdx, end: endIdx, replacement });
+    forDirectiveStart.lastIndex = endIdx;
+  }
+  for (let i = replacements.length - 1;i >= 0; i--) {
+    const { start, end, replacement } = replacements[i];
+    output = output.substring(0, start) + replacement + output.substring(end);
+  }
+  return output;
+}
+function dedupeTopLevelDeclarations(code) {
+  const seen = new Set, out = [];
+  let i = 0, depth = 0;
+  const len = code.length, skipString = (quote) => {
+    let j = i + 1;
+    while (j < len) {
+      const ch = code[j];
+      if (ch === "\\") {
+        j += 2;
+        continue;
+      }
+      if (ch === quote)
+        return j + 1;
+      j++;
+    }
+    return len;
+  }, skipLineComment = () => {
+    let j = i + 2;
+    while (j < len && code[j] !== `
+`)
+      j++;
+    return j;
+  }, skipBlockComment = () => {
+    let j = i + 2;
+    while (j < len - 1) {
+      if (code[j] === "*" && code[j + 1] === "/")
+        return j + 2;
+      j++;
+    }
+    return len;
+  }, findStatementEnd = (start) => {
+    let j = start, d = 0;
+    while (j < len) {
+      const ch = code[j];
+      if (ch === "/" && code[j + 1] === "/") {
+        let k = j + 2;
+        while (k < len && code[k] !== `
+`)
+          k++;
+        j = k;
+        continue;
+      }
+      if (ch === "/" && code[j + 1] === "*") {
+        let k = j + 2;
+        while (k < len - 1 && !(code[k] === "*" && code[k + 1] === "/"))
+          k++;
+        j = k + 2;
+        continue;
+      }
+      if (ch === '"' || ch === "'" || ch === "`") {
+        let k = j + 1;
+        while (k < len) {
+          if (code[k] === "\\") {
+            k += 2;
+            continue;
+          }
+          if (code[k] === ch) {
+            k++;
+            break;
+          }
+          k++;
+        }
+        j = k;
+        continue;
+      }
+      if (ch === "(" || ch === "[" || ch === "{") {
+        d++;
+        j++;
+        continue;
+      }
+      if (ch === ")" || ch === "]" || ch === "}") {
+        d--;
+        j++;
+        continue;
+      }
+      if (ch === ";" && d === 0)
+        return j + 1;
+      j++;
+    }
+    return len;
+  };
+  while (i < len) {
+    const ch = code[i];
+    if (ch === "/" && code[i + 1] === "/") {
+      const end = skipLineComment();
+      out.push(code.slice(i, end));
+      i = end;
+      continue;
+    }
+    if (ch === "/" && code[i + 1] === "*") {
+      const end = skipBlockComment();
+      out.push(code.slice(i, end));
+      i = end;
+      continue;
+    }
+    if (ch === '"' || ch === "'" || ch === "`") {
+      const end = skipString(ch);
+      out.push(code.slice(i, end));
+      i = end;
+      continue;
+    }
+    if (ch === "{") {
+      depth++;
+      out.push(ch);
+      i++;
+      continue;
+    }
+    if (ch === "}") {
+      depth--;
+      out.push(ch);
+      i++;
+      continue;
+    }
+    if (depth === 0) {
+      const prev = i > 0 ? code[i - 1] : "";
+      if (prev === "" || /\s/.test(prev) || prev === ";" || prev === "}" || prev === "{") {
+        const m = code.slice(i).match(/^(const|let|var)\s+([a-zA-Z_$][\w$]*)\s*=/);
+        if (m) {
+          const name = m[2], stmtEnd = findStatementEnd(i + m[0].length);
+          if (seen.has(name)) {
+            out.push(`/* stx: deduped const ${name} */`);
+            i = stmtEnd;
+            continue;
+          }
+          seen.add(name);
+          out.push(code.slice(i, stmtEnd));
+          i = stmtEnd;
+          continue;
+        }
+      }
+    }
+    out.push(ch);
+    i++;
+  }
+  return out.join("");
+}
+const SETUP_MARKER_SKIP_TAGS = new Set(["script", "style", "html", "head", "meta", "link", "title", "!doctype"]);
+function overlapsSignalScript(start, end, ranges) {
+  for (const range of ranges) {
+    if (range.start >= end)
+      return !1;
+    if (range.end > start)
+      return !0;
+  }
+  return !1;
+}
+function hasTextOutsideSignalScripts(template, text, ranges) {
+  let from = 0;
+  while (from < template.length) {
+    const index = template.indexOf(text, from);
+    if (index === -1)
+      return !1;
+    if (!overlapsSignalScript(index, index + text.length, ranges))
+      return !0;
+    from = index + text.length;
+  }
+  return !1;
+}
+function findSetupMarkerInsertion(template, ranges) {
+  if (hasTextOutsideSignalScripts(template, "<body", ranges)) {
+    const bodyTagRe = new RegExp(`<body(${TAG_ATTR_RUN})>`, "g");
+    let match;
+    while ((match = bodyTagRe.exec(template)) !== null)
+      if (!overlapsSignalScript(match.index, match.index + match[0].length, ranges))
+        return match.index + match[0].length - 1;
+    return null;
+  }
+  const openingTagRe = new RegExp(`<([a-zA-Z][a-zA-Z0-9-]*)\\b(${TAG_ATTR_RUN})>`, "gi");
+  let match;
+  while ((match = openingTagRe.exec(template)) !== null) {
+    if (overlapsSignalScript(match.index, match.index + match[0].length, ranges))
+      continue;
+    if (SETUP_MARKER_SKIP_TAGS.has(match[1].toLowerCase()))
+      continue;
+    return match.index + match[0].length - 1;
+  }
+  return null;
+}
+function rebuildSetupOwner(template, ranges, markerAt, setupFnName) {
+  const chunks = [], marker = ` data-stx="${setupFnName}"`;
+  let cursor = 0, markerWritten = !1;
+  const appendThrough = (end) => {
+    if (markerAt !== null && !markerWritten && markerAt >= cursor && markerAt <= end) {
+      chunks.push(template.slice(cursor, markerAt), marker, template.slice(markerAt, end));
+      markerWritten = !0;
+    } else
+      chunks.push(template.slice(cursor, end));
+  };
+  for (const range of ranges) {
+    if (range.start < cursor)
+      continue;
+    appendThrough(range.start);
+    cursor = range.end;
+  }
+  appendThrough(template.length);
+  return chunks.join("");
+}
+export async function processScriptSetup(template, filePath, serverData) {
+  const scripts = scanScriptTags(template, {
+    skipAttrs: /\bserver\b|\bsrc\s*=|\bdata-stx-scoped\b|\bdata-stx-router\b/
+  }), SIGNAL_API_RE = /\b(?:state|derived|effect|ref|reactive|computed|watch|watchEffect|useStore|useLocalStorage|useSessionStorage|useCookie|useId|useReactiveProp|useFetch|useRef|useEventListener|useDebounce|useDebouncedValue|useThrottle|useInterval|useTimeout|useToggle|useCounter|useClickOutside|useFocus|useAsync|useColorMode|useDark|useMediaQuery|useScrollLock|usePreferredDark|usePreferredLight|usePreferredReducedMotion|usePreferredContrast|useWebSocket|useRoute|useSearchParams|onMount|onDestroy|defineProps|withDefaults|defineEmits|defineExpose|defineSlots|useOptimistic)\s*(?:<[^>]*>)?\s*\(/, signalScripts = [], { hasUserImports, bundleClientScript } = await importOnce("stx/client-script-bundler", () => import("./client-script-bundler.js"));
+  for (const s of scripts) {
+    let content = s.body;
+    if (shouldTranspileTypeScript(s.attrs))
+      content = transpileTypeScript(content);
+    if (SIGNAL_API_RE.test(content)) {
+      signalScripts.push({ content, start: s.start, end: s.end });
+      continue;
+    }
+    if (!hasUserImports(content))
+      continue;
+    try {
+      const bundled = await bundleClientScript(injectBrowserCoreAutoImports(content).code, filePath || "", {
+        projectRoot: process.cwd()
+      });
+      if (SIGNAL_API_RE.test(bundled))
+        signalScripts.push({ content, start: s.start, end: s.end, bundled });
+    } catch {}
+  }
+  if (signalScripts.length === 0)
+    return { output: template, setupCode: null };
+  const setupIdentity = `${filePath ?? ""}\x00${signalScripts.map((s) => s.content).join("\x00")}`, setupFnName = `__stx_setup_${Bun.hash(setupIdentity).toString(36).slice(0, 10)}`, resolvedParts = [];
+  for (let i = 0;i < signalScripts.length; i++) {
+    let scriptContent = signalScripts[i].bundled ?? injectBrowserCoreAutoImports(signalScripts[i].content).code;
+    if (!signalScripts[i].bundled && hasUserImports(scriptContent))
+      scriptContent = await bundleClientScript(scriptContent, filePath || "", {
+        projectRoot: process.cwd()
+      });
+    scriptContent = stripStxRuntimeImports(scriptContent);
+    const resolved = transformStoreImports(scriptContent);
+    resolvedParts.push(`// \u2500\u2500 merged signal script #${i + 1} \u2500\u2500
+${resolved}`);
+  }
+  let mergedContent = resolvedParts.join(`
+
+`);
+  mergedContent = dedupeTopLevelDeclarations(mergedContent);
+  const mergedExports = extractExports(mergedContent), mergedExportNames = mergedExports.split(",").map((name) => name.trim()).filter(Boolean), bridge = generateServerDataBridge(mergedContent, serverData), setupCode = `
+<script data-stx-scoped>
+function ${setupFnName}() {
+  ${buildRuntimeGlobalsDestructure("const", mergedExportNames)}
+${escapeScriptBody(`${bridge}${mergedContent}`)}
+  return { ${mergedExports} };
+}
+window.__stx_latestSetup=${setupFnName};
+if(window.stx)window.stx._latestSetup=${setupFnName};
+</script>`, markerAt = findSetupMarkerInsertion(template, signalScripts);
+  return { output: rebuildSetupOwner(template, signalScripts, markerAt, setupFnName), setupCode };
+}
+export function extractExports(setupContent) {
+  const code = setupContent, names = [], seen = new Set;
+  let depth = 0, i = 0;
+  const len = code.length;
+  let lastSig = "";
+  const skipRegex = () => {
+    i++;
+    let inClass = !1;
+    while (i < len) {
+      const c = code[i];
+      if (c === "\\") {
+        i += 2;
+        continue;
+      }
+      if (c === "[" && !inClass) {
+        inClass = !0;
+        i++;
+        continue;
+      }
+      if (c === "]" && inClass) {
+        inClass = !1;
+        i++;
+        continue;
+      }
+      if (c === "/" && !inClass) {
+        i++;
+        while (i < len && /[gimsuyd]/.test(code[i]))
+          i++;
+        return;
+      }
+      if (c === `
+`)
+        return;
+      i++;
+    }
+  }, isRegexStart = () => {
+    if (!lastSig)
+      return !0;
+    if (/[\w)\]]/.test(lastSig))
+      return !1;
+    return !0;
+  }, skipString = (quote) => {
+    i++;
+    while (i < len) {
+      if (code[i] === "\\") {
+        i += 2;
+        continue;
+      }
+      if (code[i] === quote) {
+        i++;
+        return;
+      }
+      i++;
+    }
+  }, skipTemplateLiteral = () => {
+    i++;
+    while (i < len) {
+      if (code[i] === "\\") {
+        i += 2;
+        continue;
+      }
+      if (code[i] === "`") {
+        i++;
+        return;
+      }
+      if (code[i] === "$" && code[i + 1] === "{") {
+        i += 2;
+        let templateDepth = 1;
+        while (i < len && templateDepth > 0)
+          if (code[i] === "{") {
+            templateDepth++;
+            i++;
+          } else if (code[i] === "}") {
+            templateDepth--;
+            i++;
+          } else if (code[i] === "'" || code[i] === '"')
+            skipString(code[i]);
+          else if (code[i] === "`")
+            skipTemplateLiteral();
+          else
+            i++;
+        continue;
+      }
+      i++;
+    }
+  }, skipComment = () => {
+    if (code[i] === "/" && code[i + 1] === "/") {
+      while (i < len && code[i] !== `
+`)
+        i++;
+      return !0;
+    }
+    if (code[i] === "/" && code[i + 1] === "*") {
+      i += 2;
+      while (i < len - 1 && !(code[i] === "*" && code[i + 1] === "/"))
+        i++;
+      i += 2;
+      return !0;
+    }
+    return !1;
+  }, checkDeclaration = () => {
+    if (depth !== 0)
+      return;
+    const declMatch = code.slice(i).match(/^(const|let|var)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*(?:[!:;,\n]|=(?!=)|$)/);
+    if (declMatch) {
+      const varName = declMatch[2];
+      if (!seen.has(varName)) {
+        names.push(varName);
+        seen.add(varName);
+      }
+      return;
+    }
+    const destructMatch = code.slice(i).match(/^(?:const|let|var)\s+\{([^}]+)\}\s*=/);
+    if (destructMatch) {
+      destructMatch[1].split(",").forEach((s) => {
+        const trimmed = s.trim();
+        if (!trimmed)
+          return;
+        const colonIdx = trimmed.indexOf(":"), name = (colonIdx >= 0 ? trimmed.slice(colonIdx + 1).trim() : trimmed).split(/[\s=]/)[0];
+        if (name && !seen.has(name)) {
+          names.push(name);
+          seen.add(name);
+        }
+      });
+      return;
+    }
+    const arrayDestructMatch = code.slice(i).match(/^(?:const|let|var)\s+\[([^\]]+)\]\s*=/);
+    if (arrayDestructMatch) {
+      arrayDestructMatch[1].split(",").forEach((s) => {
+        const trimmed = s.trim().replace(/^\.\.\./, "");
+        if (!trimmed)
+          return;
+        const name = trimmed.split(/[\s=]/)[0];
+        if (name && !seen.has(name)) {
+          names.push(name);
+          seen.add(name);
+        }
+      });
+      return;
+    }
+    const funcMatch = code.slice(i).match(/^function\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\(/);
+    if (funcMatch) {
+      const funcName = funcMatch[1];
+      if (!seen.has(funcName)) {
+        names.push(funcName);
+        seen.add(funcName);
+      }
+      return;
+    }
+    const asyncMatch = code.slice(i).match(/^async\s+function\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\(/);
+    if (asyncMatch) {
+      const funcName = asyncMatch[1];
+      if (!seen.has(funcName)) {
+        names.push(funcName);
+        seen.add(funcName);
+      }
+    }
+  };
+  while (i < len) {
+    if (skipComment())
+      continue;
+    if (code[i] === "'" || code[i] === '"') {
+      skipString(code[i]);
+      lastSig = code[i - 1];
+      continue;
+    }
+    if (code[i] === "`") {
+      skipTemplateLiteral();
+      lastSig = "`";
+      continue;
+    }
+    if (code[i] === "/" && code[i + 1] !== "/" && code[i + 1] !== "*" && isRegexStart()) {
+      skipRegex();
+      lastSig = "/";
+      continue;
+    }
+    if (code[i] === "{") {
+      depth++;
+      lastSig = "{";
+      i++;
+      continue;
+    }
+    if (code[i] === "}") {
+      depth--;
+      lastSig = "}";
+      i++;
+      continue;
+    }
+    if (depth === 0 && /[a-z]/i.test(code[i]) && (i === 0 || /\s|[;{}()]/.test(code[i - 1])))
+      checkDeclaration();
+    if (!/\s/.test(code[i]))
+      lastSig = code[i];
+    i++;
+  }
+  return names.join(", ");
+}
+export async function processSignals(template, options, filePath, serverData) {
+  if (!hasSignalsSyntax(template, filePath))
+    return template;
+  let output = template;
+  if (options.skipSignalsRuntime)
+    return output;
+  const { output: processedOutput, setupCode } = await processScriptSetup(output, filePath, serverData);
+  output = processedOutput;
+  output = await injectSignalsRuntime(output, options);
+  if (setupCode) {
+    const headIdx = findMarkupIndexOutsideScripts(output, /<\/head>/i), bodyIdx = headIdx === -1 ? findMarkupIndexOutsideScripts(output, /<body[^>]*>/i) : -1;
+    if (headIdx !== -1)
+      output = `${output.slice(0, headIdx)}${setupCode}
+${output.slice(headIdx)}`;
+    else if (bodyIdx !== -1) {
+      const bodyTag = /<body[^>]*>/i.exec(output.slice(bodyIdx))[0], insertAt = bodyIdx + bodyTag.length;
+      output = `${output.slice(0, insertAt)}
+${setupCode}${output.slice(insertAt)}`;
+    } else
+      output = `${output}
+${setupCode}`;
+  }
+  if (!setupCode) {
+    const bodyMatch = output.replace(/<script\b[\s\S]*?<\/script>/gi, "").replace(/<style\b[\s\S]*?<\/style>/gi, "").match(/<body([^>]*)>/i);
+    if (!(bodyMatch && /data-stx/.test(bodyMatch[1])) && bodyMatch && !/data-stx-auto/.test(bodyMatch[1])) {
+      const bodyTagRe = /<body[^>]*>/i, bodyIdx = findMarkupIndexOutsideScripts(output, bodyTagRe);
+      if (bodyIdx !== -1) {
+        const before = output.slice(0, bodyIdx), after = output.slice(bodyIdx).replace(bodyTagRe, (m) => m.replace(/^<body([^>]*)>$/i, "<body$1 data-stx-auto>"));
+        output = before + after;
+      }
+    }
+  }
+  return output;
+}
+export function findMarkupIndexOutsideScripts(html, pattern) {
+  const scriptOrStyleRe = /<(script|style)\b[\s\S]*?<\/\1>/gi, skipRanges = [];
+  let block;
+  while ((block = scriptOrStyleRe.exec(html)) !== null)
+    skipRanges.push([block.index, block.index + block[0].length]);
+  const probe = new RegExp(pattern.source, pattern.flags.replace(/[gy]/g, ""));
+  let searchFrom = 0;
+  while (searchFrom < html.length) {
+    const hit = probe.exec(html.slice(searchFrom));
+    if (!hit)
+      return -1;
+    const absoluteIndex = searchFrom + hit.index;
+    if (!skipRanges.some(([start, end]) => absoluteIndex >= start && absoluteIndex < end))
+      return absoluteIndex;
+    searchFrom = absoluteIndex + Math.max(hit[0].length, 1);
+  }
+  return -1;
+}
+const STX_IMPORT_STRIPPED = "/* [stx import stripped, resolved via window.stx in __stx_setup] */";
+export function rewriteStxImportSpecifiers(specifiers) {
+  const aliases = [];
+  for (const raw of specifiers.split(",")) {
+    const specifier = raw.trim();
+    if (!specifier || specifier.startsWith("type "))
+      continue;
+    const renamed = specifier.match(/^([A-Za-z_$][\w$]*)\s+as\s+([A-Za-z_$][\w$]*)$/);
+    if (renamed && renamed[1] !== renamed[2])
+      aliases.push(`${renamed[2]} = ${renamed[1]}`);
+  }
+  if (aliases.length === 0)
+    return STX_IMPORT_STRIPPED;
+  return `var ${aliases.join(", ")}; ${STX_IMPORT_STRIPPED}`;
+}
+const STX_RUNTIME_IMPORT_RE = /^\s*import\s+(?:type\s+)?\{([^}]*)\}\s+from\s+['"](?:stx|@stacksjs\/stx|@stacksjs\/browser)['"]\s*;?\s*$/gm;
+export function stripStxRuntimeImports(code) {
+  return code.replace(STX_RUNTIME_IMPORT_RE, (_match, specifiers) => rewriteStxImportSpecifiers(specifiers));
+}