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

package/dist/includes.js

@@ -0,0 +1,764 @@
+import { findSfcTemplateBlock } from "./sfc-template.js";
+import path from "node:path";
+import { processConditionals } from "./conditionals.js";
+import { isProduction, isTest } from "./env.js";
+import { findBodyOpenTag, replaceBodyOpenTag } from "./find-body-tag.js";
+import { processExpressions, usesSignalsInScript } from "./expressions.js";
+import { buildRuntimeGlobalsDestructure } from "./runtime-globals.js";
+import { LRUCache } from "./performance-utils.js";
+import { createSafeFunction, isExpressionSafe, safeEvaluate, safeEvaluateObject } from "./safe-evaluator.js";
+import { transformStoreImports } from "./store-imports.js";
+import { createDetailedErrorMessage, fileExists, shouldTranspileTypeScript, transpileTypeScript } from "./utils.js";
+function findBalancedBraces(str, start) {
+  if (str[start] !== "{")
+    return -1;
+  let depth = 1, pos = start + 1;
+  while (pos < str.length && depth > 0) {
+    if (str[pos] === "{")
+      depth++;
+    else if (str[pos] === "}")
+      depth--;
+    pos++;
+  }
+  return depth === 0 ? pos : -1;
+}
+function findTopLevelComma(str, start) {
+  let depth = 0;
+  for (let i = start;i < str.length; i++) {
+    const ch = str[i];
+    if (ch === "(" || ch === "[" || ch === "{")
+      depth++;
+    else if (ch === ")" || ch === "]" || ch === "}")
+      depth--;
+    else if (ch === "," && depth === 0)
+      return i;
+  }
+  return -1;
+}
+function replaceDirectiveBalanced(template, directive, newName) {
+  let result = template;
+  const pattern = new RegExp(`${directive.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*\\(`, "g");
+  let match = pattern.exec(result);
+  while (match) {
+    const start = match.index, openParen = start + match[0].length - 1;
+    let depth = 1, pos = openParen + 1;
+    while (pos < result.length && depth > 0) {
+      if (result[pos] === "(")
+        depth++;
+      else if (result[pos] === ")")
+        depth--;
+      pos++;
+    }
+    if (depth !== 0)
+      break;
+    const inner = result.substring(openParen + 1, pos - 1), replacement = `${newName}(${inner})`;
+    result = result.substring(0, start) + replacement + result.substring(pos);
+    pattern.lastIndex = start + replacement.length;
+    match = pattern.exec(result);
+  }
+  return result;
+}
+function hasSignalApis(scriptContent) {
+  return /\b(state|derived|effect)\s*(?:<[^<>()]*>)?\s*\(/.test(scriptContent);
+}
+function extractExports(setupContent) {
+  const code = setupContent, names = [], seen = new Set;
+  let depth = 0, i = 0;
+  const len = code.length, 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 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]);
+      continue;
+    }
+    if (code[i] === "`") {
+      skipTemplateLiteral();
+      continue;
+    }
+    if (code[i] === "{") {
+      depth++;
+      i++;
+      continue;
+    }
+    if (code[i] === "}") {
+      depth--;
+      i++;
+      continue;
+    }
+    if (depth === 0 && /[a-z]/i.test(code[i]) && (i === 0 || /\s|[;{}()]/.test(code[i - 1])))
+      checkDeclaration();
+    i++;
+  }
+  return names.join(", ");
+}
+function wrapClientScript(scriptContent, tail = "") {
+  const localNames = extractExports(scriptContent).split(",").map((name) => name.trim()).filter(Boolean);
+  return `
+(function() {
+  ${buildRuntimeGlobalsDestructure("var", localNames)}
+  var __destroyHooks = [];
+  var __origOnDestroy = onDestroy;
+  onDestroy = function(fn) { __origOnDestroy(fn); __destroyHooks.push(fn); };
+
+${scriptContent}
+${tail}})();
+`;
+}
+function buildScopeRegistrationTail(scriptContent, scopeId) {
+  return `
+  // Register scope variables for STX runtime
+  if (!window.stx._scopes) window.stx._scopes = {};
+  var __scopeRegistration = { __destroyCallbacks: __destroyHooks };
+${extractExports(scriptContent).split(",").map((s) => s.trim()).filter(Boolean).map((name) => `  try { __scopeRegistration[${JSON.stringify(name)}] = ${name}; } catch (e) { /* not actually top-level */ }`).join(`
+`)}
+  // #1767: when the bundler renamed a component const that collided with an
+  // inlined import (foo -> foo2), rebind the ORIGINAL template name to the
+  // renamed declaration so it resolves to the component's value, not the
+  // shadowing import. __stxScopeRenames is emitted by bundleClientScript.
+  try { if (typeof __stxScopeRenames !== 'undefined' && __stxScopeRenames) { for (var __stxRK in __stxScopeRenames) __scopeRegistration[__stxRK] = __stxScopeRenames[__stxRK]; } } catch (e) { /* no renames */ }
+  window.stx._scopes['${scopeId}'] = __scopeRegistration;
+`;
+}
+function transformSignalScript(scriptContent, scopeId) {
+  const tail = buildScopeRegistrationTail(scriptContent, scopeId), head = `
+(function() {
+  var __stxScopeEl = (typeof document !== 'undefined') ? document.querySelector('[data-stx-scope="${scopeId}"]') : null;
+  var __stxPrevEl = (typeof window !== 'undefined') ? window.__STX_CURRENT_ELEMENT__ : undefined;
+  if (__stxScopeEl && typeof window !== 'undefined') window.__STX_CURRENT_ELEMENT__ = __stxScopeEl;
+  try {`, foot = `
+  } finally {
+    if (typeof window !== 'undefined') window.__STX_CURRENT_ELEMENT__ = __stxPrevEl;
+  }
+})();`;
+  return head + wrapClientScript(scriptContent, tail) + foot;
+}
+function addScopeToRootElement(html, scopeId) {
+  if (findBodyOpenTag(html)) {
+    const existingBodyScope = findBodyOpenTag(html).tag.match(/data-stx-scope="([^"]*)"/);
+    if (existingBodyScope)
+      return { html, mergedIntoExisting: existingBodyScope[1], stamped: !0 };
+    return {
+      html: replaceBodyOpenTag(html, (_tag, attrs) => `<body${attrs} data-stx-scope="${scopeId}">`),
+      mergedIntoExisting: null,
+      stamped: !0
+    };
+  }
+  const elementMatch = html.match(/^(\s*(?:(?:<!--[\s\S]*?-->|\x00STX_HTML_COMMENT_\d+\x00)\s*)*)(<[a-zA-Z][a-zA-Z0-9-]*)(\s[^>]*>|>)/s);
+  if (elementMatch) {
+    const existingScope = (elementMatch[2] + elementMatch[3]).match(/data-stx-scope="([^"]*)"/);
+    if (existingScope)
+      return { html, mergedIntoExisting: existingScope[1], stamped: !0 };
+    const before = elementMatch[1], tagStart = elementMatch[2], afterTag = elementMatch[3];
+    return {
+      html: `${before}${tagStart} data-stx-scope="${scopeId}"${afterTag}${html.slice(elementMatch[0].length)}`,
+      mergedIntoExisting: null,
+      stamped: !0
+    };
+  }
+  return { html, mergedIntoExisting: null, stamped: !1 };
+}
+let scopeIdCounter = 0;
+export const partialsCache = new LRUCache(500), onceStore = new Set;
+export function clearOnceStore() {
+  onceStore.clear();
+}
+function getOnceStore(context) {
+  if (context.__onceStore instanceof Set)
+    return context.__onceStore;
+  return onceStore;
+}
+export async function processIncludes(template, context, filePath, options, dependencies, includeStack = new Set) {
+  let partialsDir = options.partialsDir || path.join(path.dirname(filePath), "partials");
+  if (partialsDir && !path.isAbsolute(partialsDir))
+    partialsDir = path.resolve(process.cwd(), partialsDir);
+  let output = replaceDirectiveBalanced(template, "@partial", "@include");
+  const activeOnceStore = getOnceStore(context);
+  output = output.replace(/@once([\s\S]*?)@endonce/g, (match, content, _offset) => {
+    const contentHash = content.trim(), onceKey = `${filePath}:${contentHash}`;
+    if (activeOnceStore.has(onceKey))
+      return "";
+    activeOnceStore.add(onceKey);
+    return content;
+  });
+  {
+    const pat = /@includeIf\s*\(/g;
+    let m;
+    while ((m = pat.exec(output)) !== null) {
+      const start = m.index, oP = start + m[0].length - 1;
+      let d = 1, p = oP + 1;
+      while (p < output.length && d > 0) {
+        if (output[p] === "(")
+          d++;
+        else if (output[p] === ")")
+          d--;
+        p++;
+      }
+      if (d !== 0)
+        break;
+      const inner = output.substring(oP + 1, p - 1), pm = inner.match(/^\s*['"]([^'"]+)['"]/);
+      if (!pm) {
+        pat.lastIndex = p;
+        continue;
+      }
+      const incPath = pm[1], incFile = resolvePath(incPath, partialsDir, filePath);
+      let replacement = "";
+      if (incFile && await Bun.file(incFile).exists()) {
+        dependencies.add(incFile);
+        replacement = `@include(${inner})`;
+      }
+      output = output.substring(0, start) + replacement + output.substring(p);
+      pat.lastIndex = 0;
+    }
+  }
+  for (const [directive, invert] of [["@includeWhen", !1], ["@includeUnless", !0]]) {
+    const pat = new RegExp(`${directive.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*\\(`, "g");
+    let m;
+    while ((m = pat.exec(output)) !== null) {
+      const start = m.index, oP = start + m[0].length - 1;
+      let d = 1, p = oP + 1;
+      while (p < output.length && d > 0) {
+        if (output[p] === "(")
+          d++;
+        else if (output[p] === ")")
+          d--;
+        p++;
+      }
+      if (d !== 0)
+        break;
+      const inner = output.substring(oP + 1, p - 1), commaIdx = findTopLevelComma(inner, 0);
+      if (commaIdx === -1) {
+        pat.lastIndex = p;
+        continue;
+      }
+      const condition = inner.substring(0, commaIdx).trim(), rest = inner.substring(commaIdx + 1).trim(), pathMatch = rest.match(/^\s*['"]([^'"]+)['"]/);
+      if (!pathMatch) {
+        pat.lastIndex = p;
+        continue;
+      }
+      const includePath = pathMatch[1], afterPath = rest.substring(pathMatch[0].length);
+      let varsString;
+      const varsComma = findTopLevelComma(afterPath, 0);
+      if (varsComma !== -1)
+        varsString = afterPath.substring(varsComma + 1).trim();
+      try {
+        const condExpr = `Boolean(${condition})`;
+        let condResult;
+        if (isExpressionSafe(condExpr)) {
+          const condFn = createSafeFunction(condExpr, Object.keys(context));
+          condResult = Boolean(condFn(...Object.values(context)));
+        } else
+          condResult = Boolean(safeEvaluate(condExpr, context));
+        const shouldInclude = invert ? !condResult : condResult;
+        let replacement = "";
+        if (shouldInclude) {
+          const incFile = resolvePath(includePath, partialsDir, filePath);
+          if (incFile && await Bun.file(incFile).exists())
+            dependencies.add(incFile);
+          replacement = `@include('${includePath}'${varsString ? `, ${varsString}` : ""})`;
+        }
+        output = output.substring(0, start) + replacement + output.substring(p);
+        pat.lastIndex = 0;
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error), errHtml = createDetailedErrorMessage("Include", `Error evaluating ${directive} condition: ${errorMessage}`, filePath, template, start);
+        output = output.substring(0, start) + errHtml + output.substring(p);
+        pat.lastIndex = 0;
+      }
+    }
+  }
+  {
+    const eachPat = /@each\s*\(/g;
+    let eachMatch;
+    while ((eachMatch = eachPat.exec(output)) !== null) {
+      const eStart = eachMatch.index, openP = eStart + eachMatch[0].length - 1;
+      let d = 1, ep = openP + 1;
+      while (ep < output.length && d > 0) {
+        if (output[ep] === "(")
+          d++;
+        else if (output[ep] === ")") {
+          d--;
+          if (d === 0)
+            break;
+        }
+        ep++;
+      }
+      if (d !== 0)
+        break;
+      const innerArgs = output.substring(openP + 1, ep), fullMatch = output.substring(eStart, ep + 1), argsMatch = innerArgs.match(/^\s*['"]([^'"]+)['"]\s*,\s*([^,]+)\s*,\s*['"]([^'"]+)['"](?:\s*,\s*['"]([^'"]+)['"])?\s*$/);
+      if (!argsMatch) {
+        eachPat.lastIndex = 0;
+        output = output.replace(fullMatch, "");
+        continue;
+      }
+      const [, partialName, arrayExpr, itemVar, emptyPartial] = argsMatch;
+      try {
+        let array;
+        const trimmedExpr = arrayExpr.trim();
+        if (isExpressionSafe(trimmedExpr))
+          array = createSafeFunction(trimmedExpr, Object.keys(context))(...Object.values(context));
+        else
+          array = safeEvaluate(trimmedExpr, context);
+        let replacement = "";
+        if (Array.isArray(array) && array.length > 0)
+          for (const item of array) {
+            const itemContext = { ...context, [itemVar]: item }, processed = await processIncludeHelper(partialName, itemContext, template, eStart);
+            replacement += processed;
+          }
+        else if (emptyPartial)
+          replacement = await processIncludeHelper(emptyPartial, {}, template, eStart);
+        output = output.substring(0, eStart) + replacement + output.substring(ep + 1);
+        eachPat.lastIndex = 0;
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        output = output.substring(0, eStart) + createDetailedErrorMessage("Each", `Error in @each: ${errorMessage}`, filePath, template, eStart) + output.substring(ep + 1);
+        eachPat.lastIndex = 0;
+      }
+    }
+  }
+  {
+    const includeFirstPat = /@includeFirst\s*\(/g;
+    let includeFirstMatch;
+    while ((includeFirstMatch = includeFirstPat.exec(output)) !== null) {
+      const matchOffset = includeFirstMatch.index, openP = matchOffset + includeFirstMatch[0].length - 1;
+      let d = 1, p = openP + 1;
+      while (p < output.length && d > 0) {
+        if (output[p] === "(")
+          d++;
+        else if (output[p] === ")") {
+          d--;
+          if (d === 0)
+            break;
+        }
+        p++;
+      }
+      if (d !== 0)
+        break;
+      const innerArgs = output.substring(openP + 1, p), fullMatch = output.substring(matchOffset, p + 1), arrMatch = innerArgs.match(/^\s*(\[[^\]]+\])/);
+      if (!arrMatch) {
+        includeFirstPat.lastIndex = 0;
+        output = output.replace(fullMatch, "");
+        continue;
+      }
+      const pathArrayString = arrMatch[1];
+      let remaining = innerArgs.slice(arrMatch[0].length), varsString;
+      const varsMatch = remaining.match(/^\s*,\s*\{/);
+      if (varsMatch) {
+        remaining = remaining.slice(varsMatch[0].length - 1);
+        let bd = 1, bi = 1;
+        while (bi < remaining.length && bd > 0) {
+          if (remaining[bi] === "{")
+            bd++;
+          else if (remaining[bi] === "}") {
+            bd--;
+            if (bd === 0)
+              break;
+          }
+          bi++;
+        }
+        varsString = remaining.substring(0, bi + 1);
+        remaining = remaining.slice(bi + 1);
+      }
+      let fallbackContent;
+      const fbMatch = remaining.match(/^\s*,\s*['"]([^'"]*)['"]\s*$/);
+      if (fbMatch)
+        fallbackContent = fbMatch[1];
+      try {
+        const pathArray = JSON.parse(pathArrayString.replace(/'/g, '"'));
+        let localVars = {};
+        if (varsString)
+          try {
+            localVars = safeEvaluateObject(varsString, context);
+          } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            if (options.debug) {
+              const errMsg = createDetailedErrorMessage("Include", `Error parsing includeFirst variables: ${errorMessage}`, filePath, template, matchOffset, fullMatch);
+              output = output.replace(fullMatch, () => errMsg);
+            } else
+              output = output.replace(fullMatch, () => fallbackContent || "");
+            continue;
+          }
+        let foundValidPath = !1;
+        for (const includePath of pathArray) {
+          const includeFilePath = resolvePath(includePath, partialsDir, filePath);
+          if (!includeFilePath)
+            continue;
+          if (await fileExists(includeFilePath)) {
+            const processed = await processIncludeHelper(includePath, localVars, template, matchOffset);
+            output = output.replace(fullMatch, () => processed);
+            foundValidPath = !0;
+            break;
+          }
+        }
+        if (!foundValidPath)
+          if (fallbackContent !== void 0)
+            output = output.replace(fullMatch, () => fallbackContent);
+          else if (options.debug) {
+            const debugMsg = createDetailedErrorMessage("Include", `None of the includeFirst paths exist: ${pathArrayString}`, filePath, template, matchOffset, fullMatch);
+            output = output.replace(fullMatch, () => debugMsg);
+          } else
+            output = output.replace(fullMatch, "");
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error), errMsg = createDetailedErrorMessage("Include", `Error processing @includeFirst: ${errorMessage}`, filePath, template, matchOffset, fullMatch);
+        output = output.replace(fullMatch, () => errMsg);
+      }
+      includeFirstPat.lastIndex = 0;
+    }
+  }
+  function resolvePath(includePath, partialsDir, filePath) {
+    try {
+      let includeFilePath = includePath;
+      if (!includePath.endsWith(".stx"))
+        includeFilePath = `${includePath}.stx`;
+      const normalizedPartialsDir = path.resolve(partialsDir), templateDir = path.resolve(path.dirname(filePath));
+      let resolvedPath;
+      if (!includeFilePath.startsWith("./") && !includeFilePath.startsWith("../"))
+        resolvedPath = path.resolve(partialsDir, includeFilePath);
+      else
+        resolvedPath = path.resolve(templateDir, includeFilePath);
+      const normalizedResolvedPath = path.normalize(resolvedPath), isWithinPartialsDir = normalizedResolvedPath.startsWith(normalizedPartialsDir + path.sep) || normalizedResolvedPath === normalizedPartialsDir, isWithinTemplateDir = normalizedResolvedPath.startsWith(templateDir + path.sep) || normalizedResolvedPath === templateDir;
+      let isWithinProjectScope = !1;
+      const projectDir = path.dirname(templateDir);
+      if (normalizedResolvedPath.startsWith(projectDir + path.sep)) {
+        if (!path.relative(projectDir, normalizedResolvedPath).split(path.sep).some((s) => s.startsWith(".") && s !== "." && s !== ".."))
+          isWithinProjectScope = !0;
+      }
+      if (!isWithinPartialsDir && !isWithinTemplateDir && !isWithinProjectScope) {
+        console.error(`Security: Path traversal attempt blocked for include path: ${includePath}`);
+        console.error(`  Resolved to: ${normalizedResolvedPath}`);
+        console.error(`  Allowed dirs: ${normalizedPartialsDir}, ${templateDir}`);
+        return null;
+      }
+      return normalizedResolvedPath;
+    } catch (error) {
+      console.error(`Error resolving path ${includePath}: ${error}`);
+      return null;
+    }
+  }
+  const currentFilePath = path.resolve(filePath);
+  includeStack.add(currentFilePath);
+  function includeFailure(includePath, message, templateStr, offsetPos) {
+    options.onIncludeError?.({ includePath, templatePath: filePath, message, partialsDir });
+    return createDetailedErrorMessage("Include", message, filePath, templateStr, offsetPos);
+  }
+  async function processIncludeHelper(includePath, localVars = {}, templateStr, offsetPos) {
+    const includeFilePath = resolvePath(includePath, partialsDir, filePath);
+    if (!includeFilePath)
+      return includeFailure(includePath, `Could not resolve path for include: ${includePath}`, templateStr, offsetPos);
+    const resolvedIncludePath = path.resolve(includeFilePath);
+    if (includeStack.has(resolvedIncludePath)) {
+      const chain = [...includeStack, resolvedIncludePath].map((p) => path.basename(p)).join(" -> ");
+      return includeFailure(includePath, `Circular include detected: ${chain}`, templateStr, offsetPos);
+    }
+    try {
+      dependencies.add(includeFilePath);
+      let partialContent;
+      if (!partialContent)
+        try {
+          partialContent = await Bun.file(includeFilePath).text();
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          return includeFailure(includePath, `Error loading include file ${includePath}: ${errorMessage}`, templateStr, offsetPos);
+        }
+      if (partialContent)
+        partialContent = partialContent.replace(/\{\{--[\s\S]*?--\}\}/g, "");
+      if (partialContent && partialContent.includes("@stream")) {
+        const { processStreamDirectives } = await import("./streaming.js");
+        partialContent = processStreamDirectives(partialContent, context);
+      }
+      if (partialContent && (options.debug || !isProduction() && !isTest()))
+        try {
+          const { warnUnbalancedTags } = await import("./template-tag-balance.js");
+          warnUnbalancedTags(partialContent, includeFilePath);
+        } catch {}
+      let workingContent = partialContent;
+      try {
+        const { processESImports } = await import("./component-renderer.js");
+        await processESImports(partialContent, context, includeFilePath, options, dependencies);
+      } catch (err) {
+        if (options.debug)
+          console.warn(`[stx] partial ES import extraction skipped for ${includeFilePath}:`, err instanceof Error ? err.message : err);
+      }
+      const templateBlock = findSfcTemplateBlock(workingContent);
+      if (templateBlock)
+        workingContent = templateBlock.content.trim();
+      const styleMatch = partialContent.replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, "").match(/<style\b([^>]*)>([\s\S]*?)<\/style>/i);
+      let preservedStyle = "";
+      if (styleMatch)
+        preservedStyle = `<style${styleMatch[1]}>${styleMatch[2]}</style>`;
+      workingContent = workingContent.replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, "");
+      workingContent = workingContent.replace(/<style\b[^>]*>[\s\S]*?<\/style>/gi, "");
+      const includeContext = { ...context };
+      includeContext.__stx_signals_gate = usesSignalsInScript(partialContent, includeFilePath);
+      for (const [key, value] of Object.entries(localVars))
+        includeContext[key] = value;
+      const scriptRegex = /<script\b([^>]*)>([\s\S]*?)<\/script>/gi, scriptMatches = [...partialContent.matchAll(scriptRegex)];
+      let preservedScript = "", signalScopeId = null;
+      for (const scriptMatch of scriptMatches) {
+        const scriptAttrs = scriptMatch[1] || "";
+        let scriptContent = scriptMatch[2] || "";
+        const isServerScript = scriptAttrs.includes("server"), shouldTranspile = shouldTranspileTypeScript(scriptAttrs);
+        if (!isServerScript && scriptContent.trim()) {
+          const { interpolateScriptExpressions } = await import("./expressions.js");
+          scriptContent = interpolateScriptExpressions(scriptContent, includeContext);
+        }
+        let vendorStyleTags = "";
+        try {
+          const { extractAndStripCssImports, renderVendorStyleTags } = await import("./client-script.js"), cssExtraction = extractAndStripCssImports(scriptContent, {
+            filePath: includeFilePath,
+            projectRoot: process.cwd()
+          });
+          scriptContent = cssExtraction.code;
+          vendorStyleTags = renderVendorStyleTags(cssExtraction.styles);
+        } catch (err) {
+          if (options.debug)
+            console.warn(`[stx] vendor-css extractor skipped for ${includeFilePath}:`, err instanceof Error ? err.message : err);
+        }
+        if (shouldTranspile && scriptContent.trim())
+          scriptContent = transpileTypeScript(scriptContent);
+        if (!isServerScript) {
+          try {
+            const { injectBrowserCoreAutoImports } = await import("./client-script.js");
+            scriptContent = injectBrowserCoreAutoImports(scriptContent).code;
+            const { hasUserImports, bundleClientScript } = await import("./client-script-bundler.js");
+            if (hasUserImports(scriptContent))
+              scriptContent = await bundleClientScript(scriptContent, includeFilePath, {
+                projectRoot: process.cwd()
+              });
+          } catch (err) {
+            if (options.debug)
+              console.warn(`[stx] bundler skipped for ${includeFilePath}:`, err instanceof Error ? err.message : err);
+          }
+          const { stripStxRuntimeImports } = await import("./signal-processing.js");
+          scriptContent = stripStxRuntimeImports(scriptContent);
+        }
+        const isSignalScript = hasSignalApis(scriptContent);
+        if (isSignalScript && !isServerScript) {
+          signalScopeId = `stx_scope_${path.basename(includeFilePath, ".stx").replace(/[^a-zA-Z0-9]/g, "_")}_${++scopeIdCounter}`;
+          const resolvedContent = transformStoreImports(scriptContent), transformedScript = transformSignalScript(resolvedContent, signalScopeId);
+          preservedScript += `${vendorStyleTags}<script data-stx-scoped data-stx-run="always">${transformedScript}</script>
+`;
+          continue;
+        }
+        if (isServerScript)
+          try {
+            const { extractVariables } = await import("./variable-extractor.js");
+            await extractVariables(scriptContent, includeContext, includeFilePath);
+          } catch (e) {
+            if (options.debug)
+              console.warn(`Warning: Could not extract variables from server script in ${includeFilePath}:`, e);
+          }
+        if (!isServerScript && !isSignalScript) {
+          const extraAttrs = scriptAttrs.replace(/\bclient\b/i, "").trim();
+          signalScopeId = `stx_scope_${path.basename(includeFilePath, ".stx").replace(/[^a-zA-Z0-9]/g, "_")}_${++scopeIdCounter}`;
+          const resolvedContent = transformStoreImports(scriptContent), tail = buildScopeRegistrationTail(resolvedContent, signalScopeId), wrapped = wrapClientScript(resolvedContent, tail);
+          preservedScript += `${vendorStyleTags}<script data-stx-scoped data-stx-run="always"${extraAttrs ? ` ${extraAttrs}` : ""}>${wrapped}</script>
+`;
+        }
+      }
+      if (signalScopeId) {
+        const scopeResult = addScopeToRootElement(workingContent, signalScopeId);
+        workingContent = scopeResult.html;
+        if (scopeResult.mergedIntoExisting) {
+          preservedScript = preservedScript.replace(`window.stx._scopes['${signalScopeId}']`, `window.stx._scopes['${scopeResult.mergedIntoExisting}']`);
+          signalScopeId = scopeResult.mergedIntoExisting;
+        } else if (!scopeResult.stamped)
+          console.warn(`[stx] ${path.relative(process.cwd(), includeFilePath)} declares signals but has no element to scope them to, so nothing in it will hydrate. Wrap the partial's markup in a single root element.`);
+      }
+      if (workingContent.includes("@include") || workingContent.includes("@partial"))
+        workingContent = await processIncludes(workingContent, includeContext, includeFilePath, options, dependencies, includeStack);
+      const { processLoops } = await import("./loops.js");
+      let processedContent = processLoops(workingContent, includeContext, includeFilePath);
+      processedContent = processConditionals(processedContent, includeContext, includeFilePath);
+      processedContent = processExpressions(processedContent, includeContext, includeFilePath);
+      if (preservedStyle)
+        processedContent += `
+` + preservedStyle;
+      if (preservedScript)
+        processedContent += `
+` + preservedScript;
+      return processedContent;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      return includeFailure(includePath, `Error processing include ${includePath}: ${errorMessage}`, templateStr, offsetPos);
+    }
+  }
+  const includePattern = /@include\s*\(/g;
+  let includeMatch;
+  while ((includeMatch = includePattern.exec(output)) !== null) {
+    const matchStart = includeMatch.index, openParen = matchStart + includeMatch[0].length - 1;
+    let depth = 1, pos = openParen + 1;
+    while (pos < output.length && depth > 0) {
+      if (output[pos] === "(")
+        depth++;
+      else if (output[pos] === ")")
+        depth--;
+      pos++;
+    }
+    if (depth !== 0)
+      break;
+    const fullMatch = output.substring(matchStart, pos), inner = output.substring(openParen + 1, pos - 1), pathMatch = inner.match(/^\s*['"]([^'"]+)['"]/);
+    if (!pathMatch) {
+      includePattern.lastIndex = pos;
+      continue;
+    }
+    const includePath = pathMatch[1];
+    let varsString;
+    const afterPath = inner.substring(pathMatch[0].length), commaIdx = findTopLevelComma(afterPath, 0);
+    if (commaIdx !== -1)
+      varsString = afterPath.substring(commaIdx + 1).trim();
+    let localVars = {};
+    if (varsString)
+      try {
+        localVars = safeEvaluateObject(varsString, context);
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        output = output.replace(fullMatch, createDetailedErrorMessage("Include", `Error parsing include variables for ${includePath}: ${errorMessage}`, filePath, template, matchStart));
+        includePattern.lastIndex = 0;
+        continue;
+      }
+    const processedContent = await processIncludeHelper(includePath, localVars, template, matchStart);
+    output = output.substring(0, matchStart) + processedContent + output.substring(pos);
+    includePattern.lastIndex = 0;
+  }
+  return output;
+}
+export function processStackPushDirectives(template, stacks) {
+  let result = template;
+  function processStackDirective(src, directive, endDirective, prepend) {
+    let out = src, processedAny = !0;
+    while (processedAny) {
+      processedAny = !1;
+      const pat = new RegExp(`@${directive}\\(['"]([^'"]+)['"]\\)`), m = out.match(pat);
+      if (!m || m.index === void 0)
+        break;
+      const startPos = m.index, name = m[1], contentStart = startPos + m[0].length, openRe = new RegExp(`@${directive}\\(`), closeRe = new RegExp(`@${endDirective}(?![a-z])`);
+      let depth = 1, searchPos = contentStart, endPos = -1;
+      while (depth > 0 && searchPos < out.length) {
+        const rem = out.slice(searchPos), nextOpenMatch = rem.match(openRe), nextCloseMatch = rem.match(closeRe), nextOpen = nextOpenMatch ? searchPos + nextOpenMatch.index : 1 / 0, nextClose = nextCloseMatch ? searchPos + nextCloseMatch.index : 1 / 0;
+        if (nextOpen < nextClose) {
+          depth++;
+          searchPos = nextOpen + (nextOpenMatch[0].length || 1);
+        } else if (nextClose < 1 / 0) {
+          depth--;
+          if (depth === 0) {
+            endPos = nextClose;
+            break;
+          }
+          searchPos = nextClose + endDirective.length + 1;
+        } else
+          break;
+      }
+      if (endPos === -1)
+        break;
+      const content = out.slice(contentStart, endPos);
+      if (!stacks[name])
+        stacks[name] = [];
+      if (prepend)
+        stacks[name].unshift(content);
+      else
+        stacks[name].push(content);
+      out = out.substring(0, startPos) + out.substring(endPos + `@${endDirective}`.length);
+      processedAny = !0;
+    }
+    return out;
+  }
+  result = processStackDirective(result, "push", "endpush", !1);
+  result = processStackDirective(result, "prepend", "endprepend", !0);
+  return result;
+}
+export function processStackReplacements(template, stacks) {
+  return template.replace(/@stack\(['"]([^'"]+)['"]\)/g, (match, name) => {
+    if (!stacks[name] || stacks[name].length === 0)
+      return "";
+    return stacks[name].join(`
+`);
+  });
+}