@stacksjs/stx 0.2.95 → 0.2.96

package/dist/signal-processing.js

@@ -1,2 +1,946 @@
-// @bun
-import{Bs as a,Cs as b,Ds as c,Es as d,Fs as e,Gs as f,Hs as g,Is as h,Js as i}from"./chunk-1xz0w746.js";import"./chunk-m8448qby.js";import"./chunk-kx6eb6ma.js";import"./chunk-g1vt329s.js";import"./chunk-7074g241.js";import"./chunk-9cf97f9p.js";import"./chunk-6djzdes9.js";import"./chunk-v7f8jj15.js";import"./chunk-keawsbpn.js";import"./chunk-8b3z0zd5.js";import"./chunk-hbgxbgam.js";import"./chunk-ejh8fyak.js";import"./chunk-krqn0ddk.js";import"./chunk-y1k17c8b.js";import"./chunk-2j21d3ka.js";import"./chunk-frg705zq.js";import"./chunk-hjm2xab3.js";import"./chunk-07y6m5xx.js";import"./chunk-wazkqv7n.js";import"./chunk-x05nxhyv.js";import"./chunk-31dr4bys.js";import"./chunk-mgj88zeq.js";import"./chunk-m167kjhv.js";import"./chunk-3a4qsygv.js";import"./chunk-dqn9gyhb.js";import"./chunk-988dw6q3.js";import"./chunk-8qc1bsym.js";import"./chunk-xyg1r5w0.js";import"./chunk-7gd339hd.js";import"./chunk-4deg33rw.js";import"./chunk-pa9zb7ty.js";import"./chunk-a2g2qb2y.js";import"./chunk-h5jxydqq.js";import"./chunk-nhv099jv.js";import"./chunk-shv88d2d.js";import"./chunk-0dx4q6yq.js";import"./chunk-ek2w6zvy.js";import"./chunk-9wmq2272.js";import"./chunk-7dkz6z2s.js";import"./chunk-9ecv8aqj.js";import"./chunk-bdk6g1vj.js";import"./chunk-xqq1vxb6.js";import"./chunk-amaa1bev.js";import"./chunk-r5m9xtm7.js";import"./chunk-bs3gmfxz.js";import"./chunk-1zgsgk4b.js";import"./chunk-2jxbwnkz.js";import"./chunk-zen6ax1y.js";import"./chunk-yb1t2h8h.js";import"./chunk-fjk3x41y.js";import"./chunk-5shey2e4.js";import"./chunk-27zsyhrd.js";import"./chunk-7ed3tean.js";import"./chunk-8vtm0m84.js";import"./chunk-tzwtg722.js";import"./chunk-ah88wzbg.js";import"./chunk-v8j49spx.js";import"./chunk-tg2f1mzq.js";import"./chunk-n9dhs1dw.js";import"./chunk-rwrv9wbf.js";import"./chunk-wg9k6h8w.js";import"./chunk-9jtj77jx.js";import"./chunk-qygvvygy.js";import"./chunk-gz5fmp3q.js";import"./chunk-vjbefncc.js";import"./chunk-8xj7c3mf.js";import"./chunk-qvrbjpdc.js";import"./chunk-w3b6m427.js";import"./chunk-rz2ec6g7.js";import"./chunk-35faj94w.js";import"./chunk-djddhmcc.js";import"./chunk-knm8a8yx.js";import"./chunk-xv34zbp4.js";export{a as scanScriptTags,i as processSignals,g as processScriptSetup,e as preEvalLiteralReactiveIfs,b as parseLoopExpression,c as hasSignalsSyntax,h as extractExports,f as convertSignalLoopsToAttributes,d as convertSignalDirectivesToAttributes};
+import { generateServerDataBridge } from "./client-script.js";
+import { findIfBlocks } from "./parser/index.js";
+import { transformStoreImports } from "./store-imports.js";
+import { shouldTranspileTypeScript, transpileTypeScript } from "./utils.js";
+import { injectSignalsRuntime, injectBrowserRuntime } from "./runtime-injection.js";
+let signalSetupCounter = 0;
+const SCRIPT_OPEN_RE = /<script\b([^>]*)>/gi, SINGLE_ELEMENT_RE = /^<([a-zA-Z][a-zA-Z0-9-]*)\b((?:\s+[^=\s>]+(?:=(?:"[^"]*"|'[^']*'|[^\s>]*))?)*\s*)>([\s\S]*)<\/\1>$/s;
+export function scanScriptTags(html, opts = {}) {
+  const out = [];
+  SCRIPT_OPEN_RE.lastIndex = 0;
+  let m;
+  while ((m = SCRIPT_OPEN_RE.exec(html)) !== null) {
+    const attrs = m[1], bodyStart = m.index + m[0].length, closeIdx = html.toLowerCase().indexOf("</script>", bodyStart);
+    if (closeIdx === -1)
+      break;
+    const end = closeIdx + 9;
+    if (opts.skipAttrs && opts.skipAttrs.test(attrs)) {
+      SCRIPT_OPEN_RE.lastIndex = end;
+      continue;
+    }
+    out.push({
+      fullMatch: html.slice(m.index, end),
+      attrs,
+      body: html.slice(bodyStart, closeIdx),
+      start: m.index,
+      end
+    });
+    SCRIPT_OPEN_RE.lastIndex = end;
+  }
+  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) {
+  return [
+    /@if\s*=/,
+    /@for\s*=/,
+    /@show\s*=/,
+    /@model\s*=/,
+    /@bind:/,
+    /@class\s*=/,
+    /@style\s*=/,
+    /\bx-data\s*=/,
+    /\bstate\s*(?:<[^>]*>)?\s*\(/,
+    /\bderived\s*(?:<[^>]*>)?\s*\(/,
+    /\beffect\s*(?:<[^>]*>)?\s*\(/,
+    /\bref\s*(?:<[^>]*>)?\s*\(/,
+    /\bcomputed\s*(?:<[^>]*>)?\s*\(/,
+    /\breactive\s*(?:<[^>]*>)?\s*\(/,
+    /\bwatch\s*(?:<[^>]*>)?\s*\(/,
+    /\bwatchEffect\s*(?:<[^>]*>)?\s*\(/,
+    /data-stx(?:-auto)?(?![-\w])/,
+    /data-stx-scoped/
+  ].some((pattern) => pattern.test(template));
+}
+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;
+}
+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) {
+  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))
+      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) {
+  let output = template;
+  const signalNames = extractClientSignalNames(template), 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");
+      if (!(valueBranches.length > 0 && valueBranches.every((b) => conditionIsClientReactive(b.condition, signalNames, context))))
+        continue;
+      replacement = parsed[0].branches.map((branch) => {
+        if (branch.type === "elseif")
+          return branchToAttrElement(branch.content, "@else-if", branch.condition ?? "");
+        if (branch.type === "else")
+          return branchToAttrElement(branch.content, "@else");
+        return branchToAttrElement(branch.content, "@if", branch.condition ?? "");
+      }).join(`
+`);
+    } else {
+      if (!conditionIsClientReactive(condition, signalNames, context))
+        continue;
+      replacement = branchToAttrElement(content, "@if", condition);
+    }
+    replacements.push({ start: startIdx, end: endIdx, replacement });
+  }
+  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 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"
+]);
+function findElementEnd(output, startIdx, tag, startTagEnd) {
+  if (VOID_ELEMENT_TAGS.has(tag.toLowerCase()))
+    return startTagEnd;
+  const lower = tag.toLowerCase(), lowerOut = output.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;
+    }
+    const raw = /^<(script|style)\b/i.exec(output.slice(i, i + 8));
+    if (raw) {
+      const startGt = output.indexOf(">", i);
+      if (startGt === -1)
+        return -1;
+      if (output[startGt - 1] === "/") {
+        i = startGt + 1;
+        continue;
+      }
+      const close = lowerOut.indexOf(`</${raw[1].toLowerCase()}`, i);
+      if (close === -1)
+        return -1;
+      const gt = output.indexOf(">", close);
+      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 = [];
+  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);
+    if (parsed.iterable) {
+      const iter = parsed.iterable.trim();
+      if (iter.startsWith("[") || iter.startsWith("{") || iter.startsWith("'") || iter.startsWith('"') || iter.startsWith("`") || /^-?\d/.test(iter))
+        continue;
+      if (context) {
+        const rootVar = iter.split(/[.[(]/)[0].trim();
+        if (rootVar && rootVar in context)
+          continue;
+      }
+    }
+    if (parsed.style === "as")
+      expr = parsed.indexVar ? `(${parsed.itemVar}, ${parsed.indexVar}) in ${parsed.iterable}` : `${parsed.itemVar} in ${parsed.iterable}`;
+    const 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 content = output.substring(afterExpr, endIdx - endTag.length).trim(), singleElementMatch = content.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}">${content}</template>`;
+    replacements.push({ start: startIdx, end: endIdx, replacement });
+  }
+  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("");
+}
+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|useReactiveProp|useFetch|useRef|useEventListener|useDebounce|useDebouncedValue|useThrottle|useInterval|useTimeout|useToggle|useCounter|useClickOutside|useFocus|useAsync|useColorMode|useDark|useWebSocket|useRoute|useSearchParams|onMount|onDestroy|defineProps|withDefaults|defineEmits|defineExpose|defineSlots|useOptimistic)\s*(?:<[^>]*>)?\s*\(/, signalScripts = [];
+  for (const s of scripts) {
+    let content = s.body;
+    if (shouldTranspileTypeScript(s.attrs))
+      content = transpileTypeScript(content);
+    if (SIGNAL_API_RE.test(content))
+      signalScripts.push({ fullMatch: s.fullMatch, attrs: s.attrs, content });
+  }
+  if (signalScripts.length === 0)
+    return { output: template, setupCode: null };
+  const setupFnName = `__stx_setup_${Date.now()}_${signalSetupCounter++}`, { hasUserImports, bundleClientScript } = await import("./client-script-bundler.js"), resolvedParts = [];
+  for (let i = 0;i < signalScripts.length; i++) {
+    let scriptContent = signalScripts[i].content;
+    if (hasUserImports(scriptContent)) {
+      console.log("[stx:bundler] bundling signal script imports");
+      scriptContent = await bundleClientScript(scriptContent, filePath || "", {
+        projectRoot: process.cwd()
+      });
+    }
+    scriptContent = scriptContent.replace(/^\s*import\s+(?:type\s+)?\{[^}]*\}\s+from\s+['"](?:stx|@stacksjs\/stx|@stacksjs\/browser)['"]\s*;?\s*$/gm, "// [stx import stripped \u2014 resolved via window.stx in __stx_setup]");
+    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), bridge = generateServerDataBridge(mergedContent, serverData), setupCode = `
+<script data-stx-scoped>
+function ${setupFnName}() {
+  const { state, derived, effect, batch, onMount, onDestroy, defineStore, useStore, useFetch, useRef, useQuery, useMutation, useOptimistic, useDebounce, useDebouncedValue, useThrottle, useInterval, useTimeout, useToggle, useCounter, useClickOutside, useFocus, useAsync, useLocalStorage, useSessionStorage, useCookie, useReactiveProp, useEventListener, useWebSocket, useColorMode, useDark, useHead, useSeoMeta, definePageMeta, useRoute, useSearchParams, navigate, goBack, goForward, provide, ref, reactive, computed, watch, watchEffect, defineProps, withDefaults, defineEmits, defineExpose, defineSlots } = window.stx;
+${bridge}${mergedContent}
+  return { ${mergedExports} };
+}
+if(window.stx)window.stx._latestSetup=${setupFnName};
+</script>`;
+  let output = template;
+  for (const s of signalScripts)
+    output = output.split(s.fullMatch).join("");
+  if (output.includes("<body"))
+    output = output.replace(/<body([^>]*)>/, `<body$1 data-stx="${setupFnName}">`);
+  else {
+    const skipTags = ["script", "style", "html", "head", "meta", "link", "title", "!doctype"];
+    let marked = !1;
+    output = output.replace(/<([a-zA-Z][a-zA-Z0-9-]*)\b([^>]*)>/gi, (match, tag, attrs) => {
+      if (marked || skipTags.includes(tag.toLowerCase()))
+        return match;
+      marked = !0;
+      return `<${tag}${attrs} data-stx="${setupFnName}">`;
+    });
+  }
+  return { output, 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*=/);
+    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))
+    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);
+  output = injectBrowserRuntime(output);
+  if (setupCode)
+    if (output.includes("</head>"))
+      output = output.replace("</head>", `${setupCode}
+</head>`);
+    else if (output.includes("<body"))
+      output = output.replace(/<body([^>]*)>/, `<body$1>
+${setupCode}`);
+    else
+      output = output + `
+` + setupCode;
+  const bodyMatch = output.replace(/<script\b[\s\S]*?<\/script>/gi, "").replace(/<style\b[\s\S]*?<\/style>/gi, "").match(/<body([^>]*)>/i), bodyHasDataStx = bodyMatch && /data-stx/.test(bodyMatch[1]);
+  if (!setupCode && !bodyHasDataStx && bodyMatch && !/data-stx-auto/.test(bodyMatch[1])) {
+    const bodyTagRe = /<body[^>]*>/i, scriptOrStyleRe = /<(script|style)\b[\s\S]*?<\/\1>/gi, skipRanges = [];
+    let m;
+    while ((m = scriptOrStyleRe.exec(output)) !== null)
+      skipRanges.push([m.index, m.index + m[0].length]);
+    let searchFrom = 0, bodyIdx = -1;
+    while (searchFrom < output.length) {
+      bodyTagRe.lastIndex = searchFrom;
+      const hit = bodyTagRe.exec(output.slice(searchFrom));
+      if (!hit)
+        break;
+      const absIdx = searchFrom + hit.index;
+      if (!skipRanges.some(([s, e]) => absIdx >= s && absIdx < e)) {
+        bodyIdx = absIdx;
+        break;
+      }
+      searchFrom = absIdx + hit[0].length;
+    }
+    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;
+}