@stacksjs/stx 0.2.95 → 0.2.96

package/dist/utils.js

@@ -1,2 +1,942 @@
-// @bun
-import{Ls as j,Ms as k,Ns as l,Os as m,Ps as n,Qs as o,Rs as p,Ss as q,Ts as r,Us as s,Vs as t,Ws as u}from"./chunk-1xz0w746.js";import"./chunk-m8448qby.js";import{$s as g,Zs as e,_s as f,at as h,bt as i}from"./chunk-kx6eb6ma.js";import{dt as a,et as b,ft as c,gt as d}from"./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{e as validateTemplate,g as validateDirective,m as userComponentFileExists,l as transpileTypeScript,k as shouldTranspileTypeScript,q as resolveTemplatePath,o as renderComponentWithSlot,j as isJavaScriptScript,n as isHydrateTrigger,d as hasVariables,h as hasDirectives,r as getSourceLineInfo,f as getPositionInfo,u as getComponentCacheStats,p as fileExists,a as extractVariables,c as extractScriptFromTemplate,i as extractDirectiveNames,s as createDetailedErrorMessage,b as convertToCommonJS,t as clearComponentCache};
+import fs from "node:fs";
+import path from "node:path";
+import { extractBridgeData, processClientScript } from "./client-script.js";
+import { processExpressions, unescapeHtml } from "./expressions.js";
+import { transformStoreImports } from "./store-imports.js";
+import { LRUCache } from "./performance-utils.js";
+import { processDirectives } from "./process.js";
+import { getPublicEnvDefine } from "./public-env.js";
+import { processScopedStyles } from "./style-scoping.js";
+export {
+  extractDirectiveNames,
+  getPositionInfo,
+  hasDirectives,
+  validateDirective,
+  validateTemplate
+} from "./validator.js";
+export {
+  convertToCommonJS,
+  extractScriptFromTemplate,
+  extractVariables,
+  hasVariables
+} from "./variable-extractor.js";
+const componentsCache = new LRUCache(500);
+let scopeIdCounter = 0;
+function escapeAttr(str) {
+  return str.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+export function isJavaScriptScript(attrs) {
+  return /\bjs\b/.test(attrs) || /\blang\s*=\s*["']?(js|javascript)["']?/i.test(attrs);
+}
+export function shouldTranspileTypeScript(attrs) {
+  return !isJavaScriptScript(attrs);
+}
+export function transpileTypeScript(code) {
+  try {
+    let processedCode = code.replace(/^\s*import\s+\w+\s+from\s+['"][^'"]*\.stx['"]\s*;?\s*$/gm, "");
+    processedCode = processedCode.replace(/^\s*import\s+['"][^'"]*\.stx['"]\s*;?\s*$/gm, "");
+    const placeholders = [];
+    processedCode = processedCode.replace(/\{!![\s\S]*?!!\}/g, (match) => {
+      const idx = placeholders.length;
+      placeholders.push(match);
+      return `"__STX_EXPR_${idx}__"`;
+    });
+    processedCode = processedCode.replace(/\{\{\{[\s\S]*?\}\}\}/g, (match) => {
+      const idx = placeholders.length;
+      placeholders.push(match);
+      return `"__STX_EXPR_${idx}__"`;
+    });
+    processedCode = processedCode.replace(/\{\{[\s\S]*?\}\}/g, (match) => {
+      const idx = placeholders.length;
+      placeholders.push(match);
+      return `"__STX_EXPR_${idx}__"`;
+    });
+    let result = new Bun.Transpiler({
+      loader: "ts",
+      target: "browser",
+      define: getPublicEnvDefine()
+    }).transformSync(processedCode);
+    for (let i = 0;i < placeholders.length; i++) {
+      result = result.replace(`"__STX_EXPR_${i}__"`, placeholders[i]);
+      result = result.replace(`'__STX_EXPR_${i}__'`, placeholders[i]);
+    }
+    return result;
+  } catch (e) {
+    if (process.env.STX_DEBUG_TS)
+      console.warn("[STX] TypeScript transpilation error:", e);
+    return code;
+  }
+}
+function extractVariableNames(code) {
+  const 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 destructMatch = code.slice(i).match(/^(const|let|var)\s*\{([^}]+)\}\s*=/);
+    if (destructMatch) {
+      const vars = destructMatch[2].split(",").map((v) => {
+        const parts = v.trim().split(":");
+        return parts[parts.length - 1].trim();
+      });
+      for (const varName of vars)
+        if (varName && /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(varName) && !seen.has(varName)) {
+          names.push(varName);
+          seen.add(varName);
+        }
+      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;
+}
+function splitTopLevelCommas(body) {
+  const parts = [];
+  let depth = 0, start = 0, quote = null;
+  for (let i = 0;i < body.length; i++) {
+    const c = body[i];
+    if (quote) {
+      if (c === "\\") {
+        i++;
+        continue;
+      }
+      if (c === quote)
+        quote = null;
+      continue;
+    }
+    if (c === '"' || c === "'" || c === "`") {
+      quote = c;
+      continue;
+    }
+    if (c === "(" || c === "[" || c === "{")
+      depth++;
+    else if (c === ")" || c === "]" || c === "}")
+      depth--;
+    else if (c === "," && depth === 0) {
+      parts.push(body.slice(start, i));
+      start = i + 1;
+    }
+  }
+  if (start < body.length)
+    parts.push(body.slice(start));
+  return parts;
+}
+function topLevelDefaultEq(entry) {
+  let depth = 0, quote = null;
+  for (let i = 0;i < entry.length; i++) {
+    const c = entry[i];
+    if (quote) {
+      if (c === "\\") {
+        i++;
+        continue;
+      }
+      if (c === quote)
+        quote = null;
+      continue;
+    }
+    if (c === '"' || c === "'" || c === "`") {
+      quote = c;
+      continue;
+    }
+    if (c === "(" || c === "[" || c === "{")
+      depth++;
+    else if (c === ")" || c === "]" || c === "}")
+      depth--;
+    else if (c === "=" && depth === 0) {
+      const prev = entry[i - 1], next = entry[i + 1];
+      if (prev === "!" || prev === "<" || prev === ">" || prev === "=")
+        continue;
+      if (next === "=" || next === ">")
+        continue;
+      return i;
+    }
+  }
+  return -1;
+}
+function applyDestructuredPropDefaults(componentContent, ctx) {
+  try {
+    const m = /=\s*(?:withDefaults\s*\([\s\S]*?defineProps|defineProps)\b/.exec(componentContent);
+    if (!m)
+      return;
+    let i = m.index - 1;
+    while (i >= 0 && /\s/.test(componentContent[i]))
+      i--;
+    if (componentContent[i] !== "}")
+      return;
+    const end = i;
+    let depth = 0, start = -1;
+    for (;i >= 0; i--) {
+      const c = componentContent[i];
+      if (c === "}")
+        depth++;
+      else if (c === "{") {
+        depth--;
+        if (depth === 0) {
+          start = i;
+          break;
+        }
+      }
+    }
+    if (start === -1)
+      return;
+    const body = componentContent.slice(start + 1, end);
+    for (const rawEntry of splitTopLevelCommas(body)) {
+      const entry = rawEntry.trim();
+      if (!entry || entry.startsWith("..."))
+        continue;
+      const eq = topLevelDefaultEq(entry);
+      if (eq === -1)
+        continue;
+      const name = entry.slice(0, eq).trim();
+      if (!/^[A-Z_$][\w$]*$/i.test(name))
+        continue;
+      if (ctx[name] !== void 0)
+        continue;
+      const expr = entry.slice(eq + 1).trim();
+      if (!expr)
+        continue;
+      try {
+        const keys = Object.keys(ctx), fn = Function(...keys, `"use strict"; return (${expr});`);
+        ctx[name] = fn(...keys.map((k) => ctx[k]));
+      } catch {}
+    }
+  } catch {}
+}
+export async function userComponentFileExists(componentPath, componentsDir, parentContext, parentFilePath, options) {
+  const baseName = componentPath.endsWith(".stx") ? componentPath.slice(0, -4) : componentPath, kebabToPascal = (str) => str.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(""), pascalToKebab = (str) => str.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase(), importedComponents = parentContext.__importedComponents;
+  if (importedComponents) {
+    for (const name of [baseName, baseName.toLowerCase(), kebabToPascal(baseName), pascalToKebab(baseName)])
+      if (importedComponents.has(name))
+        return !0;
+  }
+  const variants = [...new Set([`${baseName}.stx`, `${kebabToPascal(baseName)}.stx`, `${pascalToKebab(baseName)}.stx`])], configuredRoot = typeof options.root === "string" ? path.resolve(options.root) : void 0, resolveBase = configuredRoot ?? path.dirname(parentFilePath), searchDirs = [], push = (dir) => {
+    if (dir && !searchDirs.includes(dir))
+      searchDirs.push(dir);
+  }, originalFilePath = parentContext.__originalFilePath;
+  if (originalFilePath)
+    push(path.join(path.dirname(originalFilePath), "components"));
+  push(componentsDir);
+  push(path.join(path.dirname(parentFilePath), "components"));
+  push(options.componentsDir);
+  const pluginDirs = options._pluginComponentDirs;
+  if (Array.isArray(pluginDirs))
+    for (const dir of pluginDirs)
+      push(typeof dir === "string" ? dir : null);
+  if (configuredRoot) {
+    push(path.resolve(configuredRoot, "resources/views/components"));
+    push(path.resolve(configuredRoot, "resources/components"));
+    push(path.resolve(configuredRoot, "src/components"));
+    push(path.resolve(configuredRoot, "components"));
+  }
+  if (baseName.startsWith("./") || baseName.startsWith("../"))
+    return fileExists(path.resolve(path.dirname(parentFilePath), `${baseName}.stx`));
+  for (const dir of searchDirs) {
+    const resolvedDir = path.isAbsolute(dir) ? dir : path.resolve(resolveBase, dir);
+    for (const variant of variants)
+      if (await fileExists(path.join(resolvedDir, variant)))
+        return !0;
+  }
+  return !1;
+}
+export function isHydrateTrigger(trigger) {
+  return trigger === "visible" || trigger === "idle" || trigger === "interaction" || trigger.startsWith("media:");
+}
+export async function renderComponentWithSlot(componentPath, props, slotContent, componentsDir, parentContext, parentFilePath, options, processedComponents = new Set, dependencies) {
+  const { extractVariables } = await import("./variable-extractor.js"), components = processedComponents ?? new Set;
+  if (components.has(componentPath))
+    return `[Circular component reference: ${componentPath}]`;
+  const branchComponents = new Set(components);
+  branchComponents.add(componentPath);
+  const clientAttr = typeof props.client === "string" ? props.client.trim() : "";
+  if ("client" in props)
+    delete props.client;
+  const hydrateTrigger = clientAttr && clientAttr !== "load" && isHydrateTrigger(clientAttr) ? clientAttr : "";
+  try {
+    const kebabToPascal = (str) => str.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(""), pascalToKebab = (str) => str.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase(), baseName = componentPath.endsWith(".stx") ? componentPath.slice(0, -4) : componentPath;
+    let componentFilePath = null;
+    const importedComponents = parentContext.__importedComponents;
+    if (importedComponents) {
+      const namesToTry = [
+        baseName,
+        baseName.toLowerCase(),
+        kebabToPascal(baseName),
+        pascalToKebab(baseName)
+      ];
+      for (const name of namesToTry)
+        if (importedComponents.has(name)) {
+          componentFilePath = importedComponents.get(name);
+          break;
+        }
+    }
+    const triedPaths = [];
+    if (!componentFilePath) {
+      const fileVariants = [
+        `${baseName}.stx`,
+        `${kebabToPascal(baseName)}.stx`,
+        `${pascalToKebab(baseName)}.stx`
+      ], uniqueVariants = [...new Set(fileVariants)], originalFilePath = parentContext.__originalFilePath, searchDirs = [];
+      if (originalFilePath) {
+        const originalDir = path.join(path.dirname(originalFilePath), "components");
+        searchDirs.push(originalDir);
+      }
+      if (componentsDir)
+        searchDirs.push(componentsDir);
+      const parentRelative = path.join(path.dirname(parentFilePath), "components");
+      if (!searchDirs.includes(parentRelative))
+        searchDirs.push(parentRelative);
+      if (options.componentsDir && options.componentsDir !== componentsDir && !searchDirs.includes(options.componentsDir))
+        searchDirs.push(options.componentsDir);
+      const pluginDirs = options._pluginComponentDirs;
+      if (Array.isArray(pluginDirs)) {
+        for (const dir of pluginDirs)
+          if (typeof dir === "string" && !searchDirs.includes(dir))
+            searchDirs.push(dir);
+      }
+      const configuredRoot = typeof options.root === "string" ? path.resolve(options.root) : void 0, resolveBase = configuredRoot ?? path.dirname(parentFilePath), fallbackDirs = [];
+      if (configuredRoot) {
+        fallbackDirs.push(path.resolve(configuredRoot, "resources/views/components"));
+        fallbackDirs.push(path.resolve(configuredRoot, "resources/components"));
+        fallbackDirs.push(path.resolve(configuredRoot, "src/components"));
+        fallbackDirs.push(path.resolve(configuredRoot, "components"));
+      }
+      fallbackDirs.push(path.resolve(import.meta.dir, "components"));
+      for (const fallback of fallbackDirs)
+        if (!searchDirs.includes(fallback))
+          searchDirs.push(fallback);
+      const normalizedSearchDirs = [...new Set(searchDirs.map((dir) => {
+        if (!dir)
+          return dir;
+        return path.isAbsolute(dir) ? dir : path.resolve(resolveBase, dir);
+      }))];
+      searchDirs.length = 0;
+      searchDirs.push(...normalizedSearchDirs);
+      if (baseName.startsWith("./") || baseName.startsWith("../")) {
+        componentFilePath = path.resolve(path.dirname(parentFilePath), `${baseName}.stx`);
+        triedPaths.push(componentFilePath);
+      } else
+        for (const dir of searchDirs) {
+          if (!dir)
+            continue;
+          for (const variant of uniqueVariants) {
+            const tryPath = path.join(dir, variant);
+            triedPaths.push(tryPath);
+            if (await fileExists(tryPath)) {
+              componentFilePath = tryPath;
+              break;
+            }
+          }
+          if (componentFilePath)
+            break;
+          if (!componentFilePath)
+            try {
+              const fs = await import("node:fs");
+              if (!fs.statSync(dir, { throwIfNoEntry: !1 })?.isDirectory())
+                continue;
+              const MAX_DEPTH = 8, stack = [{ path: dir, depth: 0 }];
+              while (stack.length > 0 && !componentFilePath) {
+                const current = stack.pop();
+                if (current.depth >= MAX_DEPTH)
+                  continue;
+                let entries;
+                try {
+                  entries = fs.readdirSync(current.path, { withFileTypes: !0 });
+                } catch {
+                  continue;
+                }
+                for (const entry of entries) {
+                  if (!entry.isDirectory())
+                    continue;
+                  if (entry.name === "node_modules" || entry.name.startsWith("."))
+                    continue;
+                  const subDir = path.join(current.path, entry.name);
+                  for (const variant of uniqueVariants) {
+                    const tryPath = path.join(subDir, variant);
+                    triedPaths.push(tryPath);
+                    if (await fileExists(tryPath)) {
+                      componentFilePath = tryPath;
+                      break;
+                    }
+                  }
+                  if (componentFilePath)
+                    break;
+                  stack.push({ path: subDir, depth: current.depth + 1 });
+                }
+              }
+            } catch {}
+          if (componentFilePath)
+            break;
+        }
+    }
+    if (!componentFilePath || !await fileExists(componentFilePath)) {
+      const searchInfo = triedPaths.length > 0 ? `
+Searched paths:
+${triedPaths.map((p) => `  - ${p}`).join(`
+`)}` : "";
+      return `[Error loading component: ENOENT: no such file or directory, open '${componentPath}']${searchInfo}`;
+    }
+    dependencies.add(componentFilePath);
+    let componentContent;
+    if (componentsCache.has(componentFilePath))
+      componentContent = componentsCache.get(componentFilePath);
+    else
+      try {
+        componentContent = await Bun.file(componentFilePath).text();
+        componentsCache.set(componentFilePath, componentContent);
+      } catch (error) {
+        return `[Error loading component: ${error instanceof Error ? error.message : String(error)}]`;
+      }
+    const internalKeysToPreserve = new Set(["__originalFilePath", "__importedComponents"]), filteredParentContext = {};
+    for (const [key, val] of Object.entries(parentContext))
+      if (!key.startsWith("__") || internalKeysToPreserve.has(key))
+        filteredParentContext[key] = val;
+    const { extractSlotContent } = await import("./slots.js"), parsedSlotContent = extractSlotContent(slotContent), $slots = {};
+    if (parsedSlotContent.defaultSlot?.trim())
+      $slots.default = parsedSlotContent.defaultSlot;
+    for (const [slotName, slotDef] of parsedSlotContent.namedSlots)
+      $slots[slotName] = slotDef.content;
+    const componentContext = {
+      ...filteredParentContext,
+      ...props,
+      props,
+      slot: slotContent,
+      $slots,
+      __processedComponents: branchComponents,
+      __sections: {}
+    };
+    applyDestructuredPropDefaults(componentContent, componentContext);
+    let workingContent = componentContent;
+    const templateMatch = workingContent.match(/<template\b(?![^>]*(?:\b(?:id|x-for|x-if|@for|@if|:for|:if)\s*=|\s#[\w-]|\bv-slot|\bslot\s*=))[^>]*>([\s\S]*?)<\/template>/i);
+    if (templateMatch)
+      workingContent = templateMatch[1].trim();
+    const scriptRegex = /<script\b([^>]*)>([\s\S]*?)<\/script>/gi, scriptMatches = [...componentContent.matchAll(scriptRegex)], clientScripts = [];
+    for (const match of scriptMatches) {
+      const attrs = match[1] || "";
+      let content = match[2] || "";
+      const isServerScript = attrs.includes("server");
+      if (shouldTranspileTypeScript(attrs) && content.trim())
+        content = transpileTypeScript(content);
+      if (isServerScript && content)
+        try {
+          await extractVariables(content, componentContext, componentFilePath);
+        } catch (e) {}
+      if (!isServerScript) {
+        let cleanContent = content.replace(/^\s*const\s*\{[^}]+\}\s*=\s*window\.stx\s*;?\s*\n?/gm, "");
+        if (cleanContent.includes("{{") && cleanContent.includes("}}"))
+          cleanContent = processExpressions(cleanContent, componentContext, componentFilePath);
+        const cleanAttrs = attrs.replace(/\s*\bts\b/g, "").replace(/\s*\blang\s*=\s*["']?(ts|typescript)["']?/gi, "");
+        clientScripts.push(`<script${cleanAttrs}>${cleanContent}</script>`);
+      }
+    }
+    const styleMatch = componentContent.match(/<style\b([^>]*)>([\s\S]*?)<\/style>/i), styleAttrs = styleMatch ? styleMatch[1] : "", styleContent = styleMatch ? styleMatch[2] : "";
+    let preservedStyle = "";
+    const hasScopedStyle = styleAttrs && /\bscoped\b/i.test(styleAttrs);
+    if (styleMatch)
+      preservedStyle = `<style${styleAttrs}>${styleContent}</style>`;
+    let templateContent = workingContent;
+    templateContent = templateContent.replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, "");
+    if (styleMatch)
+      templateContent = templateContent.replace(/<style\b[^>]*>[\s\S]*?<\/style>/gi, "");
+    {
+      const pushStyleRe = /@push\s*\(\s*['"]styles['"]\s*\)([\s\S]*?)@endpush/gi, collectedStyles = [];
+      templateContent = templateContent.replace(pushStyleRe, (_full, inner) => {
+        const styleInPush = inner.match(/<style\b([^>]*)>([\s\S]*?)<\/style>/i);
+        if (styleInPush)
+          collectedStyles.push(`<style${styleInPush[1]}>${styleInPush[2]}</style>`);
+        return "";
+      });
+      templateContent = templateContent.replace(/@push\s*\(\s*['"][^'"]+['"]\s*\)[\s\S]*?@endpush/gi, "");
+      if (collectedStyles.length > 0)
+        preservedStyle = `${preservedStyle}${collectedStyles.join(`
+`)}`;
+    }
+    if (slotContent && templateContent.includes("{{ text || slot }}"))
+      templateContent = templateContent.replace(/\{\{\s*text\s*\|\|\s*slot\s*\}\}/g, () => slotContent);
+    const { applySlots } = await import("./slots.js"), { defaultSlot, namedSlots } = parsedSlotContent;
+    templateContent = await applySlots(templateContent, defaultSlot || slotContent, namedSlots, componentContext);
+    for (const [key, value] of Object.entries(componentContext))
+      if (typeof value === "string") {
+        if (value.includes("<") && value.includes(">") || value.includes("&lt;") || value.includes("&quot;")) {
+          const unescaped = unescapeHtml(value);
+          componentContext[key] = unescaped;
+        }
+      }
+    const hasSignalScripts = clientScripts.some((s) => /\b(state|derived|effect)\s*(?:<[^<>()]*>)?\s*\(/.test(s)), componentOptions = {
+      ...options,
+      componentsDir: path.dirname(componentFilePath),
+      skipSignalsRuntime: !0,
+      skipEventDirectives: hasSignalScripts,
+      defaultLayout: void 0
+    };
+    componentContext.__stxProcessingDepth = (parentContext.__stxProcessingDepth || 0) + 1;
+    const result = await processDirectives(templateContent, componentContext, componentFilePath, componentOptions, dependencies), scopeId = `stx_${baseName.replace(/[^a-zA-Z0-9]/g, "_")}_${++scopeIdCounter}_${Math.random().toString(36).slice(2, 8)}`;
+    let output = result;
+    if (hasSignalScripts) {
+      let propsJson = "";
+      if (Object.keys(props).length > 0)
+        try {
+          propsJson = ` data-stx-props="${escapeAttr(JSON.stringify(props))}"`;
+        } catch {}
+      const hydrateJson = hydrateTrigger ? ` stx-hydrate="${escapeAttr(hydrateTrigger)}"` : "";
+      output = `<div data-stx-scope="${scopeId}"${propsJson}${hydrateJson}>${result}</div>`;
+      output = clientScripts.map((script) => {
+        const scriptMatch = script.match(/<script([^>]*)>([\s\S]*)<\/script>/i);
+        if (!scriptMatch)
+          return script;
+        const [, attrs, rawContent] = scriptMatch, content = transformStoreImports(rawContent), wrappedContent = `
+(function() {
+  const { state, derived, effect, batch, defineEmits, defineExpose, defineSlots, defineProps, withDefaults, 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, inject, ref, reactive, computed, watch, watchEffect, nextTick } = window.stx;
+  const __scope = window.stx._scopes = window.stx._scopes || {};
+  const __scopeVars = __scope['${scopeId}'] = __scope['${scopeId}'] || {};
+
+  // Scope-specific lifecycle callbacks
+  __scopeVars.__mountCallbacks = __scopeVars.__mountCallbacks || [];
+  __scopeVars.__destroyCallbacks = __scopeVars.__destroyCallbacks || [];
+  const onMount = (fn) => __scopeVars.__mountCallbacks.push(fn);
+  const onDestroy = (fn) => __scopeVars.__destroyCallbacks.push(fn);
+
+${content}
+
+  // Register all defined signals and functions in this scope
+  const __localVars = {};
+  try {
+    ${extractVariableNames(content).map((v) => `if (typeof ${v} !== 'undefined') __localVars['${v}'] = ${v};`).join(`
+    `)}
+  }
+catch (e) {}
+  Object.assign(__scopeVars, __localVars);
+})();`;
+        if (hydrateTrigger)
+          return `<script type="stx/island" data-stx-island="${scopeId}" data-stx-scoped${attrs}>${wrappedContent}</script>`;
+        return `<script data-stx-scoped${attrs}>${wrappedContent}</script>`;
+      }).join(`
+`) + `
+` + output;
+      if (preservedStyle)
+        output += `
+` + preservedStyle;
+    } else {
+      if (preservedStyle)
+        output += `
+` + preservedStyle;
+      if (clientScripts.length > 0) {
+        const eventBindings = componentContext.__stx_event_bindings || [], serverData = extractBridgeData(componentContext), transformedScripts = await Promise.all(clientScripts.map(async (fullScript) => {
+          const contentMatch = fullScript.match(/<script\b[^>]*>([\s\S]*?)<\/script>/);
+          if (!contentMatch)
+            return fullScript;
+          return await processClientScript(contentMatch[1], { eventBindings, templateContent: output, filePath: componentFilePath, projectRoot: process.cwd(), serverData });
+        }));
+        output += `
+` + transformedScripts.join(`
+`);
+        componentContext.__stx_event_bindings = [];
+      }
+    }
+    if (hasScopedStyle) {
+      const scopedStyleResult = processScopedStyles(output, componentFilePath);
+      if (scopedStyleResult.hasScoped)
+        output = scopedStyleResult.html;
+    }
+    return output;
+  } catch (error) {
+    return `[Error processing component: ${error instanceof Error ? error.message : String(error)}]`;
+  } finally {
+    components.delete(componentPath);
+  }
+}
+export async function fileExists(filePath) {
+  return Bun.file(filePath).exists();
+}
+function assertInsideRoot(resolvedAbsolute, root) {
+  const r = path.resolve(root), p = path.resolve(resolvedAbsolute), rWithSep = r.endsWith(path.sep) ? r : r + path.sep;
+  if (p === r || p.startsWith(rWithSep))
+    return p;
+  return null;
+}
+export async function resolveTemplatePath(templatePath, currentFilePath, options, dependencies) {
+  const result = await resolveTemplatePathInner(templatePath, currentFilePath, options, dependencies);
+  if (result === null)
+    return null;
+  const safeUnderCwd = assertInsideRoot(result, process.cwd());
+  if (safeUnderCwd)
+    return safeUnderCwd;
+  const trustedDirs = [options.root, options.layoutsDir, options.componentsDir, options.partialsDir, options.pagesDir].filter((d) => typeof d === "string" && d.length > 0);
+  for (const dir of trustedDirs) {
+    const resolvedDir = path.isAbsolute(dir) ? dir : path.resolve(process.cwd(), dir);
+    if (assertInsideRoot(result, resolvedDir))
+      return path.resolve(result);
+  }
+  console.warn(`[stx] rejected resolved template path that escapes project root: ${result} (template: ${templatePath}, from: ${currentFilePath})`);
+  return null;
+}
+async function resolveTemplatePathInner(templatePath, currentFilePath, options, dependencies) {
+  if (options.debug)
+    console.log(`Resolving template path: ${templatePath} from ${currentFilePath}`);
+  const dirPath = path.dirname(currentFilePath), projectRoot = process.cwd();
+  if (templatePath.startsWith("/")) {
+    const absolutePath = path.join(projectRoot, templatePath), safe = assertInsideRoot(absolutePath, projectRoot);
+    if (!safe) {
+      console.warn(`[stx] rejected template path that escapes project root: ${templatePath} (from ${currentFilePath})`);
+      return null;
+    }
+    if (options.debug)
+      console.log(`Checking absolute path: ${safe}`);
+    if (await fileExists(safe) && dependencies)
+      dependencies.add(safe);
+    return safe;
+  }
+  const directPath = path.join(dirPath, templatePath);
+  if (await fileExists(directPath)) {
+    if (options.debug)
+      console.log(`Found direct path: ${directPath}`);
+    if (dependencies)
+      dependencies.add(directPath);
+    return directPath;
+  }
+  if (!templatePath.endsWith(".stx") && !templatePath.endsWith(".jsx") && !templatePath.endsWith(".tsx"))
+    for (const ext of [".stx", ".tsx", ".jsx"]) {
+      const pathWithExt = `${directPath}${ext}`;
+      if (await fileExists(pathWithExt)) {
+        if (options.debug)
+          console.log(`Found direct path with extension: ${pathWithExt}`);
+        if (dependencies)
+          dependencies.add(pathWithExt);
+        return pathWithExt;
+      }
+    }
+  let layoutsDir = "", searchDir = path.resolve(dirPath);
+  const rootDir = process.cwd();
+  for (let i = 0;i < 10; i++) {
+    const candidate = path.join(searchDir, "layouts");
+    let candidateExists = !1;
+    try {
+      candidateExists = fs.statSync(candidate, { throwIfNoEntry: !1 })?.isDirectory() ?? !1;
+    } catch {}
+    if (candidateExists) {
+      layoutsDir = candidate;
+      break;
+    }
+    const parent = path.dirname(searchDir);
+    if (parent === searchDir || parent.length < rootDir.length)
+      break;
+    searchDir = parent;
+  }
+  if (layoutsDir) {
+    const layoutTemplatePath = templatePath.startsWith("layouts/") ? templatePath.slice(8) : templatePath, fromCurrentLayouts = path.join(layoutsDir, layoutTemplatePath);
+    if (await fileExists(fromCurrentLayouts)) {
+      if (options.debug)
+        console.log(`Found in current layouts dir: ${fromCurrentLayouts}`);
+      if (dependencies)
+        dependencies.add(fromCurrentLayouts);
+      return fromCurrentLayouts;
+    }
+    if (!layoutTemplatePath.endsWith(".stx")) {
+      const fromCurrentLayoutsWithExt = `${fromCurrentLayouts}.stx`;
+      if (await fileExists(fromCurrentLayoutsWithExt)) {
+        if (options.debug)
+          console.log(`Found in current layouts dir with extension: ${fromCurrentLayoutsWithExt}`);
+        if (dependencies)
+          dependencies.add(fromCurrentLayoutsWithExt);
+        return fromCurrentLayoutsWithExt;
+      }
+    }
+  }
+  if (options.layoutsDir) {
+    const resolvedLayoutsDir = path.isAbsolute(options.layoutsDir) ? options.layoutsDir : path.resolve(process.cwd(), options.layoutsDir), strippedPath = templatePath.startsWith("layouts/") ? templatePath.slice(8) : templatePath, fromLayoutsDir = path.join(resolvedLayoutsDir, strippedPath);
+    if (await fileExists(fromLayoutsDir)) {
+      if (options.debug)
+        console.log(`Found in options.layoutsDir: ${fromLayoutsDir}`);
+      if (dependencies)
+        dependencies.add(fromLayoutsDir);
+      return fromLayoutsDir;
+    }
+    if (!templatePath.endsWith(".stx")) {
+      const fromLayoutsDirWithExt = `${fromLayoutsDir}.stx`;
+      if (await fileExists(fromLayoutsDirWithExt)) {
+        if (options.debug)
+          console.log(`Found in options.layoutsDir with extension: ${fromLayoutsDirWithExt}`);
+        if (dependencies)
+          dependencies.add(fromLayoutsDirWithExt);
+        return fromLayoutsDirWithExt;
+      }
+    }
+  }
+  if (templatePath.startsWith("layouts/") || templatePath.includes("/layouts/")) {
+    const parts = templatePath.split("layouts/"), layoutsPath = path.join(options.partialsDir || dirPath, "layouts", parts[1]);
+    if (await fileExists(layoutsPath)) {
+      if (options.debug)
+        console.log(`Found in layouts path: ${layoutsPath}`);
+      if (dependencies)
+        dependencies.add(layoutsPath);
+      return layoutsPath;
+    }
+    if (!layoutsPath.endsWith(".stx")) {
+      const layoutsPathWithExt = `${layoutsPath}.stx`;
+      if (await fileExists(layoutsPathWithExt)) {
+        if (options.debug)
+          console.log(`Found in layouts path with extension: ${layoutsPathWithExt}`);
+        if (dependencies)
+          dependencies.add(layoutsPathWithExt);
+        return layoutsPathWithExt;
+      }
+    }
+  }
+  if (options.partialsDir) {
+    layoutsDir = path.join(options.partialsDir, "layouts");
+    if (await fileExists(layoutsDir)) {
+      const fromPartialsLayouts = path.join(layoutsDir, templatePath);
+      if (await fileExists(fromPartialsLayouts)) {
+        if (options.debug)
+          console.log(`Found in partials layouts dir: ${fromPartialsLayouts}`);
+        if (dependencies)
+          dependencies.add(fromPartialsLayouts);
+        return fromPartialsLayouts;
+      }
+      if (!templatePath.endsWith(".stx")) {
+        const fromPartialsLayoutsWithExt = `${fromPartialsLayouts}.stx`;
+        if (await fileExists(fromPartialsLayoutsWithExt)) {
+          if (options.debug)
+            console.log(`Found in partials layouts dir with extension: ${fromPartialsLayoutsWithExt}`);
+          if (dependencies)
+            dependencies.add(fromPartialsLayoutsWithExt);
+          return fromPartialsLayoutsWithExt;
+        }
+      }
+    }
+  }
+  const viewsPath = options.partialsDir || path.join(process.cwd(), "views"), fromRoot = path.join(viewsPath, templatePath);
+  if (await fileExists(fromRoot)) {
+    if (options.debug)
+      console.log(`Found in views path: ${fromRoot}`);
+    if (dependencies)
+      dependencies.add(fromRoot);
+    return fromRoot;
+  }
+  if (!templatePath.endsWith(".stx")) {
+    const fromRootWithExt = `${fromRoot}.stx`;
+    if (await fileExists(fromRootWithExt)) {
+      if (options.debug)
+        console.log(`Found in views path with extension: ${fromRootWithExt}`);
+      if (dependencies)
+        dependencies.add(fromRootWithExt);
+      return fromRootWithExt;
+    }
+  }
+  if (dirPath.includes("temp")) {
+    const tempDirLayouts = path.join(path.dirname(dirPath), "layouts", templatePath);
+    if (await fileExists(tempDirLayouts)) {
+      if (options.debug)
+        console.log(`Found in temp layouts dir: ${tempDirLayouts}`);
+      if (dependencies)
+        dependencies.add(tempDirLayouts);
+      return tempDirLayouts;
+    }
+    if (!templatePath.endsWith(".stx")) {
+      const tempDirLayoutsWithExt = `${tempDirLayouts}.stx`;
+      if (await fileExists(tempDirLayoutsWithExt)) {
+        if (options.debug)
+          console.log(`Found in temp layouts dir with extension: ${tempDirLayoutsWithExt}`);
+        if (dependencies)
+          dependencies.add(tempDirLayoutsWithExt);
+        return tempDirLayoutsWithExt;
+      }
+    }
+  }
+  if (options.debug)
+    console.warn(`Template not found after trying all paths: ${templatePath} (referenced from ${currentFilePath})`);
+  else
+    console.warn(`Template not found: ${templatePath} (referenced from ${currentFilePath})`);
+  return null;
+}
+export function getSourceLineInfo(template, errorPosition, errorPattern) {
+  let lineNumber = 0, lineContent = "", context = "";
+  try {
+    if (typeof errorPosition === "number" && errorPosition >= 0) {
+      const lines = template.split(`
+`);
+      let currentPos = 0;
+      for (let i = 0;i < lines.length; i++) {
+        currentPos += lines[i].length + 1;
+        if (currentPos >= errorPosition) {
+          lineNumber = i + 1;
+          lineContent = lines[i].trim();
+          const start = Math.max(0, i - 2), end = Math.min(lines.length, i + 3);
+          context = lines.slice(start, end).map((line, idx) => {
+            const contextLineNum = start + idx + 1;
+            return `${contextLineNum === lineNumber ? "> " : "  "}${contextLineNum}: ${line}`;
+          }).join(`
+`);
+          break;
+        }
+      }
+    } else if (errorPattern) {
+      const patternPos = template.indexOf(errorPattern);
+      if (patternPos >= 0)
+        return getSourceLineInfo(template, patternPos);
+    }
+  } catch {}
+  return { lineNumber, lineContent, context };
+}
+const colors = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  cyan: "\x1B[36m",
+  gray: "\x1B[90m",
+  bgRed: "\x1B[41m",
+  bgYellow: "\x1B[43m"
+};
+export function createDetailedErrorMessage(errorType, errorMessage, filePath, template, errorPosition, errorPattern) {
+  const { lineNumber, context } = getSourceLineInfo(template, errorPosition, errorPattern), fileName = filePath.split("/").pop();
+  let column = 0;
+  if (typeof errorPosition === "number" && errorPosition >= 0 && template) {
+    const lastNl = template.lastIndexOf(`
+`, Math.max(0, errorPosition - 1));
+    column = errorPosition - (lastNl + 1) + 1;
+  }
+  let detailedMessage = "";
+  if (lineNumber > 0)
+    detailedMessage += `
+${filePath}:${lineNumber}${column > 0 ? `:${column}` : ""}: ${errorType.toLowerCase()} error: ${errorMessage}
+`;
+  detailedMessage += `
+${colors.bold}${colors.red}\u256D\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256E${colors.reset}
+`;
+  detailedMessage += `${colors.bold}${colors.red}\u2502${colors.reset} ${colors.bold}${colors.bgRed} ERROR ${colors.reset} ${colors.red}${errorType} Error${colors.reset}${" ".repeat(Math.max(0, 43 - errorType.length))}${colors.bold}${colors.red}\u2502${colors.reset}
+`;
+  detailedMessage += `${colors.bold}${colors.red}\u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256F${colors.reset}
+`;
+  detailedMessage += `
+${colors.cyan}${colors.bold}File:${colors.reset} ${colors.dim}${fileName}${colors.reset}`;
+  if (lineNumber > 0)
+    detailedMessage += ` ${colors.gray}(line ${lineNumber}${column > 0 ? `, col ${column}` : ""})${colors.reset}`;
+  detailedMessage += `
+${colors.yellow}${colors.bold}Message:${colors.reset} ${errorMessage}
+`;
+  if (context)
+    detailedMessage += `
+${colors.blue}${colors.bold}Context:${colors.reset}
+${colors.dim}${context}${colors.reset}
+`;
+  return detailedMessage;
+}
+export function clearComponentCache() {
+  componentsCache.clear();
+}
+export function getComponentCacheStats() {
+  return {
+    size: componentsCache.size,
+    maxSize: 500
+  };
+}