@stacksjs/stx 0.2.95 → 0.2.96

package/dist/variable-extractor.js

@@ -1,2 +1,1094 @@
-// @bun
-import{ct as a,dt as b,et as c,ft as d,gt as e}from"./chunk-g1vt329s.js";import"./chunk-pa9zb7ty.js";import"./chunk-bs3gmfxz.js";import"./chunk-7ed3tean.js";import"./chunk-w3b6m427.js";import"./chunk-xv34zbp4.js";export{a as stripTypeScript,e as hasVariables,b as extractVariables,d as extractScriptFromTemplate,c as convertToCommonJS};
+var {require}=import.meta;import path from "node:path";
+import process from "node:process";
+import { findMatchingDelimiter } from "./parser/tokenizer.js";
+import { useHead as headUseHead, useSeoMeta as headUseSeoMeta, getHead as headGetHead } from "./head.js";
+import { getPublicEnvDefine } from "./public-env.js";
+import { safeEvaluate } from "./safe-evaluator.js";
+function extractDeclaredVariableNames(script) {
+  const names = [];
+  let depth = 0;
+  const lines = script.split(`
+`);
+  for (const line of lines) {
+    const depthAtLineStart = depth;
+    let inString = null, escaped = !1;
+    for (let i = 0;i < line.length; i++) {
+      const ch = line[i];
+      if (escaped) {
+        escaped = !1;
+        continue;
+      }
+      if (ch === "\\") {
+        escaped = !0;
+        continue;
+      }
+      if (inString) {
+        if (ch === inString)
+          inString = null;
+        continue;
+      }
+      if (ch === "'" || ch === '"' || ch === "`") {
+        inString = ch;
+        continue;
+      }
+      if (ch === "/" && i + 1 < line.length && line[i + 1] === "/")
+        break;
+      if (ch === "{")
+        depth++;
+      else if (ch === "}")
+        depth--;
+    }
+    if (depthAtLineStart === 0) {
+      const match = line.match(/(?:const|let|var)\s+(\w+)\s*=/);
+      if (match)
+        names.push(match[1]);
+      else if (/^\s*(?:const|let|var)\s+\w+\s*;?\s*$/.test(line)) {
+        const declOnly = line.match(/(?:const|let|var)\s+(\w+)/);
+        if (declOnly)
+          names.push(declOnly[1]);
+      } else {
+        const destructMatch = line.match(/(?:const|let|var)\s+(\{[^}]+\}|\[[^\]]+\])\s*=/);
+        if (destructMatch) {
+          const vars = destructMatch[1].slice(1, -1).split(",").map((v) => {
+            const parts = v.split(":");
+            return (parts.length > 1 ? parts[1] : parts[0]).trim();
+          }).filter((v) => /^\w+$/.test(v));
+          names.push(...vars);
+        }
+      }
+    }
+  }
+  return [...new Set(names)];
+}
+export function stripTypeScript(scriptContent) {
+  let result = scriptContent;
+  result = result.replace(/^\s*import\s+.*?from\s+['"][^'"]+['"]\s*;?\s*$/gm, "");
+  result = result.replace(/^\s*import\s+['"][^'"]+['"]\s*;?\s*$/gm, "");
+  result = result.replace(/^\s*interface\s+\w+\s*\{[\s\S]*?\n\}\s*$/gm, "");
+  result = result.replace(/^\s*type\s+\w+\s*=[\s\S]*?(?=\n(?:const|let|var|function|export|interface|type|$))/gm, "");
+  result = result.replace(/^(\s*(?:export\s+)?(?:const|let|var)\s+)(\w+|\{[^}]+\}|\[[^\]]+\])\s*:\s*[^=]+(\s*=)/gm, "$1$2$3");
+  function stripParamTypes(params) {
+    if (!params.includes(":"))
+      return params;
+    const paramParts = [];
+    let current = "", angleDepth = 0, parenDepth = 0, inStr = null;
+    for (let i = 0;i < params.length; i++) {
+      const c = params[i];
+      if (inStr) {
+        current += c;
+        if (c === inStr)
+          inStr = null;
+        continue;
+      }
+      if (c === '"' || c === "'" || c === "`") {
+        inStr = c;
+        current += c;
+        continue;
+      }
+      if (c === "<")
+        angleDepth++;
+      else if (c === ">" && angleDepth > 0)
+        angleDepth--;
+      else if (c === "(")
+        parenDepth++;
+      else if (c === ")")
+        parenDepth--;
+      if (c === "," && angleDepth === 0 && parenDepth === 0) {
+        paramParts.push(current);
+        current = "";
+        continue;
+      }
+      current += c;
+    }
+    if (current)
+      paramParts.push(current);
+    return paramParts.map((param) => {
+      const trimmedParam = param.trim(), isRest = trimmedParam.startsWith("..."), paramBody = isRest ? trimmedParam.slice(3) : trimmedParam;
+      let colonIdx = -1, aDepth = 0;
+      for (let i = 0;i < paramBody.length; i++)
+        if (paramBody[i] === "<")
+          aDepth++;
+        else if (paramBody[i] === ">")
+          aDepth--;
+        else if (paramBody[i] === ":" && aDepth === 0) {
+          colonIdx = i;
+          break;
+        }
+      if (colonIdx === -1)
+        return param;
+      const namePart = paramBody.substring(0, colonIdx).trim().replace(/\?$/, ""), afterColon = paramBody.substring(colonIdx + 1);
+      let eqIdx = -1, eqADepth = 0;
+      for (let i = 0;i < afterColon.length; i++)
+        if (afterColon[i] === "<")
+          eqADepth++;
+        else if (afterColon[i] === ">")
+          eqADepth--;
+        else if (afterColon[i] === "=" && eqADepth === 0) {
+          eqIdx = i;
+          break;
+        }
+      const prefix = isRest ? "..." : "";
+      if (eqIdx !== -1)
+        return `${prefix}${namePart} = ${afterColon.substring(eqIdx + 1).trim()}`;
+      return `${prefix}${namePart}`;
+    }).join(", ");
+  }
+  result = result.replace(/\b(function\s+\w*\s*)\(([^)]*)\)/g, (match, prefix, params) => {
+    if (!params.includes(":"))
+      return match;
+    return `${prefix}(${stripParamTypes(params)})`;
+  });
+  {
+    const funcPattern = /\b(function\s+\w*\s*)\(/g;
+    let funcMatch;
+    const replacements = [];
+    while ((funcMatch = funcPattern.exec(result)) !== null) {
+      const openParen = funcMatch.index + funcMatch[0].length - 1;
+      let depth = 1, pos = openParen + 1, aDepth = 0, inStr = null;
+      while (pos < result.length && depth > 0) {
+        const ch = result[pos];
+        if (inStr) {
+          if (ch === inStr)
+            inStr = null;
+          pos++;
+          continue;
+        }
+        if (ch === '"' || ch === "'" || ch === "`") {
+          inStr = ch;
+          pos++;
+          continue;
+        }
+        if (ch === "<")
+          aDepth++;
+        else if (ch === ">" && aDepth > 0)
+          aDepth--;
+        else if (aDepth === 0) {
+          if (ch === "(")
+            depth++;
+          else if (ch === ")")
+            depth--;
+        }
+        if (depth > 0)
+          pos++;
+      }
+      if (depth !== 0)
+        continue;
+      const params = result.substring(openParen + 1, pos);
+      if (!params.includes(":"))
+        continue;
+      const cleaned = stripParamTypes(params);
+      replacements.push({ start: openParen + 1, end: pos, replacement: cleaned });
+    }
+    for (let i = replacements.length - 1;i >= 0; i--) {
+      const { start, end, replacement } = replacements[i];
+      result = result.substring(0, start) + replacement + result.substring(end);
+    }
+  }
+  result = result.replace(/\(([^)]*)\)\s*(?::\s*[^=]+)?\s*=>/g, (match, params) => {
+    if (!params.includes(":"))
+      return match;
+    if (params.includes("{") || params.includes("}"))
+      return match;
+    return `(${params.split(",").map((param) => {
+      const [nameWithType, ...defaultParts] = param.split("="), name = nameWithType.split(":")[0].trim();
+      if (defaultParts.length > 0)
+        return `${name} = ${defaultParts.join("=").trim()}`;
+      return name;
+    }).join(", ")}) =>`;
+  });
+  result = result.replace(/(\))\s*:\s*([A-Z]\w*|void|string|number|boolean|any|unknown|never|null|undefined)(?:<[^>]+>)?(?:\s*\|\s*(?:[A-Z]\w*|void|string|number|boolean|any|unknown|never|null|undefined))*\s*(\{)/g, "$1$3");
+  result = result.replace(/(\b(?:function|class|interface|type|extends|implements)\s+\w+)\s*<[^<>()]*>/g, "$1");
+  result = result.replace(/(\b(?:defineProps|withDefaults|defineEmits|defineSlots|Array|Promise|Map|Set|Record|Partial|Required|Readonly|Pick|Omit|Exclude|Extract))\s*<[^<>()]*>/g, "$1");
+  result = result.replace(/(\w+)\s*<[A-Z][^<>()]*>\s*(?=\()/g, "$1");
+  result = result.replace(/\s+as\s+(?:const|[A-Za-z]\w*(?:\[\])?(?:\s*\|\s*\w+(?:\[\])?)*)/g, "");
+  result = result.replace(/\s+satisfies\s+\w+(?:<[^>]*>)?/g, "");
+  result = result.replace(/(\w|\)|\])\s*!(?!=)/g, "$1");
+  result = result.replace(/^\s*(?:export\s+)?(?:const\s+)?enum\s+\w+\s*\{[^}]*\}\s*$/gm, "");
+  result = result.replace(/(?<=[\s=,(])<[A-Z]\w*(?:\[\])?>/g, "");
+  result = result.replace(/\n\s*\n\s*\n/g, `
+
+`);
+  return result;
+}
+export async function extractVariables(scriptContent, context, filePath, options = {}) {
+  if (!scriptContent.trim())
+    return;
+  let jsContent;
+  try {
+    const transpiler = new Bun.Transpiler({ loader: "ts", target: "browser", define: getPublicEnvDefine() });
+    let processedCode = scriptContent.replace(/^\s*import\s+\w+\s+from\s+['"][^'"]*\.stx['"]\s*;?\s*$/gm, "");
+    processedCode = processedCode.replace(/^\s*import\s+['"][^'"]*\.stx['"]\s*;?\s*$/gm, "");
+    jsContent = transpiler.transformSync(processedCode);
+  } catch {
+    jsContent = stripTypeScript(scriptContent);
+  }
+  const module = { exports: {} }, exports = module.exports, projectRoot = process.cwd(), preloaded = {}, serverRequires = [...jsContent.matchAll(/require\s*\(\s*['"]([^'"]+)['"]\s*\)/g) || []].map((m) => m[1]).filter((id) => !id.startsWith("node:") && !id.startsWith(".") && !["fs", "path", "os", "child_process", "crypto", "http", "https", "url", "util", "stream", "events", "buffer", "net", "querystring", "zlib", "tls"].includes(id));
+  for (const id of serverRequires)
+    try {
+      const pkgDir = path.resolve(projectRoot, "node_modules", id), pkgJsonPath = path.join(pkgDir, "package.json"), pkgJson = JSON.parse(require("fs").readFileSync(pkgJsonPath, "utf8"));
+      let entry = pkgJson.main || "index.js";
+      if (pkgJson.exports) {
+        const exp = typeof pkgJson.exports === "string" ? pkgJson.exports : pkgJson.exports["."];
+        if (typeof exp === "string")
+          entry = exp;
+        else if (exp?.bun)
+          entry = exp.bun;
+        else if (exp?.import)
+          entry = exp.import;
+        else if (exp?.default)
+          entry = exp.default;
+      }
+      preloaded[id] = await import(path.resolve(pkgDir, entry));
+    } catch {}
+  const requireFn = (id) => {
+    if (preloaded[id])
+      return preloaded[id];
+    return require(id);
+  }, propsObj = context.props || {}, $props = (defaults) => {
+    if (!defaults)
+      return propsObj;
+    const result = {};
+    for (const [key, defaultValue] of Object.entries(defaults)) {
+      const propValue = propsObj[key];
+      if (propValue !== void 0)
+        result[key] = propValue;
+      else if (typeof defaultValue === "function")
+        result[key] = defaultValue();
+      else
+        result[key] = defaultValue;
+    }
+    return result;
+  };
+  for (const [key, value] of Object.entries(propsObj))
+    Object.defineProperty($props, key, { value, enumerable: !0, configurable: !0, writable: !0 });
+  const defineProps = (definitions) => {
+    if (!definitions)
+      return propsObj;
+    const result = { ...propsObj };
+    for (const [key, def] of Object.entries(definitions)) {
+      const opts = def && typeof def === "object" && !Array.isArray(def) ? def : { type: def };
+      if (result[key] === void 0 && opts.default !== void 0)
+        result[key] = typeof opts.default === "function" ? opts.default() : opts.default;
+    }
+    return result;
+  }, defineSlots = () => context.slots || {}, withDefaults = (props, defaults) => {
+    const result = { ...props };
+    for (const [key, defaultValue] of Object.entries(defaults))
+      if (result[key] === void 0)
+        if (typeof defaultValue === "function")
+          result[key] = defaultValue();
+        else
+          result[key] = defaultValue;
+    return result;
+  }, state = (initialValue) => {
+    const getter = () => initialValue;
+    getter.set = (_v) => {};
+    getter.update = (_fn) => {};
+    return getter;
+  }, derived = (fn) => {
+    let cached, computed = !1;
+    return () => {
+      if (!computed)
+        try {
+          cached = fn();
+          computed = !0;
+        } catch {
+          cached = void 0;
+        }
+      return cached;
+    };
+  }, effect = (_fn) => {}, batch = (fn) => fn(), onMount = (_fn) => {}, onDestroy = (_fn) => {}, definePageMeta = (_meta) => {}, useRoute = () => {
+    const serveCtx = context.__stxServeContext, search = context.__stxServeSearch ?? serveCtx?.search ?? "", path = serveCtx?.path ?? "";
+    return {
+      params: context.params ?? {},
+      query: Object.fromEntries(new URLSearchParams(search)),
+      path,
+      name: "",
+      fullPath: path + search,
+      hash: "",
+      matched: []
+    };
+  }, useRouter = () => ({ push: (_to) => {}, replace: (_to) => {}, back: () => {}, forward: () => {}, go: (_n) => {} }), useHead = (head) => {
+    headUseHead(head);
+    const existing = context.__stx_runtime_head || {}, incoming = head || {};
+    context.__stx_runtime_head = {
+      ...existing,
+      ...incoming.title && { title: incoming.title },
+      meta: [...existing.meta || [], ...incoming.meta || []],
+      link: [...existing.link || [], ...incoming.link || []],
+      script: [...existing.script || [], ...incoming.script || []],
+      htmlAttrs: { ...existing.htmlAttrs || {}, ...incoming.htmlAttrs || {} },
+      bodyAttrs: { ...existing.bodyAttrs || {}, ...incoming.bodyAttrs || {} }
+    };
+  }, useSeoMeta = (meta) => {
+    headUseSeoMeta(meta);
+    const head = headGetHead();
+    context.__stx_runtime_head = {
+      ...context.__stx_runtime_head || {},
+      ...head.title && { title: head.title },
+      meta: head.meta ? [...head.meta] : []
+    };
+  }, ref = (val) => ({ value: val }), reactive = (obj) => obj, computed = (fn) => ({ value: typeof fn === "function" ? fn() : fn }), watch = (_source, _cb) => {}, onMounted = (_fn) => {}, onUnmounted = (_fn) => {}, nextTick = (fn) => fn ? fn() : Promise.resolve(), defineEmits = (_events) => (_event, ..._args) => {}, defineExpose = (_exposed) => {}, provide = (_key, _value) => {}, inject = (_key, defaultValue) => defaultValue, useColorMode = () => ({ value: "light" }), useDark = () => ({ value: !1 }), mockWindow = {
+    siteId: void 0,
+    API_ENDPOINT: "",
+    ANALYTICS_SITE_ID: void 0,
+    location: {
+      href: "",
+      pathname: "",
+      search: "",
+      hash: "",
+      origin: "",
+      host: "",
+      hostname: "",
+      protocol: "https:",
+      assign: () => {},
+      replace: () => {},
+      reload: () => {}
+    },
+    localStorage: {
+      getItem: () => null,
+      setItem: () => {},
+      removeItem: () => {},
+      clear: () => {}
+    },
+    sessionStorage: {
+      getItem: () => null,
+      setItem: () => {},
+      removeItem: () => {},
+      clear: () => {}
+    },
+    fetch: globalThis.fetch,
+    addEventListener: () => {},
+    removeEventListener: () => {},
+    setTimeout: () => 0,
+    clearTimeout: () => {},
+    setInterval: () => 0,
+    clearInterval: () => {},
+    requestAnimationFrame: () => 0,
+    cancelAnimationFrame: () => {},
+    alert: () => {},
+    confirm: () => !1,
+    prompt: () => null,
+    getComputedStyle: () => ({}),
+    matchMedia: () => ({ matches: !1, addListener: () => {}, removeListener: () => {} }),
+    getDateRangeParams: () => "",
+    stx: {}
+  }, windowProxy = new Proxy(mockWindow, {
+    get(target, prop) {
+      if (prop in target)
+        return target[prop];
+      return;
+    },
+    set(target, prop, value) {
+      target[prop] = value;
+      return !0;
+    }
+  }), mockDocument = {
+    getElementById: () => null,
+    querySelector: () => null,
+    querySelectorAll: () => [],
+    createElement: () => ({}),
+    createTextNode: () => ({}),
+    body: {},
+    head: {},
+    documentElement: {},
+    addEventListener: () => {},
+    removeEventListener: () => {}
+  }, mockConsole = console;
+  try {
+    const convertedScript = convertToCommonJS(jsContent, filePath), propsKeys = new Set(Object.keys(propsObj)), filteredContextKeys = Object.keys(context).filter((key) => !propsKeys.has(key) && key !== "props"), filteredContextValues = filteredContextKeys.map((key) => context[key]), jsReserved = new Set([
+      "break",
+      "case",
+      "catch",
+      "class",
+      "const",
+      "continue",
+      "debugger",
+      "default",
+      "delete",
+      "do",
+      "else",
+      "export",
+      "extends",
+      "finally",
+      "for",
+      "function",
+      "if",
+      "import",
+      "in",
+      "instanceof",
+      "let",
+      "new",
+      "return",
+      "super",
+      "switch",
+      "this",
+      "throw",
+      "try",
+      "typeof",
+      "var",
+      "void",
+      "while",
+      "with",
+      "yield",
+      "enum",
+      "await",
+      "async",
+      "module",
+      "exports",
+      "require",
+      "params",
+      "window",
+      "document",
+      "console",
+      "state",
+      "derived",
+      "effect"
+    ]), propArgNames = [], propArgValues = [];
+    for (const [key, value] of Object.entries(propsObj)) {
+      if (!/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key))
+        continue;
+      if (jsReserved.has(key))
+        continue;
+      if (new RegExp(`(?:^|[\\s;{])(?:const|let|var|function)\\s+${key}\\b`).test(convertedScript))
+        continue;
+      propArgNames.push(key);
+      propArgValues.push(value);
+    }
+    const reSyncCode = extractDeclaredVariableNames(convertedScript).map((name) => `module.exports.${name} = typeof ${name} !== 'undefined' ? ${name} : module.exports.${name};`).join(`
+        `), paramsObj = context.params ?? {}, scriptContextKeys = [], scriptContextValues = [];
+    for (let i = 0;i < filteredContextKeys.length; i++) {
+      if (filteredContextKeys[i] === "params")
+        continue;
+      scriptContextKeys.push(filteredContextKeys[i]);
+      scriptContextValues.push(filteredContextValues[i]);
+    }
+    const result = await Function("module", "exports", "require", "props", "$props", "defineProps", "withDefaults", "state", "derived", "effect", "batch", "onMount", "onDestroy", "definePageMeta", "useRoute", "useRouter", "useHead", "useSeoMeta", "ref", "reactive", "computed", "watch", "onMounted", "onUnmounted", "nextTick", "defineEmits", "defineExpose", "defineSlots", "provide", "inject", "useColorMode", "useDark", "window", "document", "console", "confirm", "alert", "fetch", "params", ...propArgNames, ...scriptContextKeys, `return (async () => {
+        ${convertedScript}
+        ${reSyncCode}
+        return module.exports
+      })()`)(module, exports, requireFn, propsObj, $props, defineProps, withDefaults, state, derived, effect, batch, onMount, onDestroy, definePageMeta, useRoute, useRouter, useHead, useSeoMeta, ref, reactive, computed, watch, onMounted, onUnmounted, nextTick, defineEmits, defineExpose, defineSlots, provide, inject, useColorMode, useDark, windowProxy, mockDocument, mockConsole, mockWindow.confirm, mockWindow.alert, mockWindow.fetch, paramsObj, ...propArgValues, ...scriptContextValues);
+    if (options.preserveExisting) {
+      for (const [key, value] of Object.entries(result))
+        if (!(key in context) || context[key] === void 0)
+          context[key] = value;
+    } else
+      Object.assign(context, result);
+    for (const [key, value] of Object.entries(propsObj))
+      if (!(key in context))
+        context[key] = value;
+  } catch (primaryError) {
+    if (process.env.STX_DEBUG) {
+      const msg = primaryError instanceof Error ? primaryError.message : String(primaryError);
+      console.warn(`[stx] server <script> did not execute in ${filePath ?? "<unknown>"} \u2014 falling back to static extraction. Cause: ${msg}`);
+    }
+    try {
+      await fallbackVariableExtraction(jsContent, context, filePath);
+    } catch (fallbackError) {
+      if (process.env.STX_DEBUG) {
+        const msg = fallbackError instanceof Error ? fallbackError.message : String(fallbackError);
+        console.warn(`[stx] fallback extraction also failed in ${filePath ?? "<unknown>"}: ${msg}`);
+      }
+    }
+  }
+}
+export function convertToCommonJS(scriptContent, filePath) {
+  const templateDir = filePath ? path.dirname(filePath) : process.cwd(), lines = scriptContent.split(`
+`), convertedLines = [];
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i].trim();
+    if (line.startsWith("interface ") || line.startsWith("export interface ") || line.startsWith("type ") || line.startsWith("export type ")) {
+      if (line.includes("{") && !line.includes("}")) {
+        let braceDepth = 0;
+        for (;i < lines.length; i++) {
+          for (const ch of lines[i])
+            if (ch === "{")
+              braceDepth++;
+            else if (ch === "}")
+              braceDepth--;
+          if (braceDepth <= 0)
+            break;
+        }
+      }
+      i++;
+      continue;
+    }
+    if (line.startsWith("definePageMeta(")) {
+      let depth = 0, done = !1;
+      for (let j = i;j < lines.length && !done; j++) {
+        let inString = null, escaped = !1;
+        const text = lines[j];
+        for (let k = 0;k < text.length; k++) {
+          const ch = text[k];
+          if (escaped) {
+            escaped = !1;
+            continue;
+          }
+          if (ch === "\\") {
+            escaped = !0;
+            continue;
+          }
+          if (inString) {
+            if (ch === inString)
+              inString = null;
+            continue;
+          }
+          if (ch === '"' || ch === "'" || ch === "`") {
+            inString = ch;
+            continue;
+          }
+          if (ch === "(")
+            depth++;
+          else if (ch === ")") {
+            depth--;
+            if (depth === 0) {
+              i = j + 1;
+              done = !0;
+              break;
+            }
+          }
+        }
+      }
+      if (!done)
+        i = lines.length;
+      continue;
+    }
+    if (line.startsWith("import ")) {
+      const defaultImportMatch = line.match(/^import\s+(\w+)\s+from\s+['"](.+)['"]/), namedImportMatch = line.match(/^import\s+\{([^}]+)\}\s+from\s+['"](.+)['"]/), sideEffectMatch = line.match(/^import\s+['"](.+)['"]/), resolveSource = (source) => {
+        if (source.startsWith("."))
+          return path.resolve(templateDir, source);
+        return source;
+      };
+      if (defaultImportMatch) {
+        const [, name, source] = defaultImportMatch, resolved = resolveSource(source);
+        convertedLines.push(`const ${name} = await import('${resolved}')`);
+        convertedLines.push(`module.exports.${name} = ${name};`);
+      } else if (namedImportMatch) {
+        const [, names, source] = namedImportMatch, cleanNames = names.trim(), resolved = resolveSource(source);
+        convertedLines.push(`const { ${cleanNames} } = await import('${resolved}')`);
+        for (const n of cleanNames.split(",")) {
+          const cleanName = n.trim().split(/\s+as\s+/).pop()?.trim();
+          if (cleanName)
+            convertedLines.push(`module.exports.${cleanName} = ${cleanName};`);
+        }
+      } else if (sideEffectMatch) {
+        const resolved = resolveSource(sideEffectMatch[1]);
+        convertedLines.push(`await import('${resolved}')`);
+      } else
+        convertedLines.push(line);
+      i++;
+      continue;
+    }
+    if ((line.startsWith("const ") || line.startsWith("let ") || line.startsWith("var ") || line.startsWith("export const ") || line.startsWith("export let ") || line.startsWith("export var ")) && !line.includes("=")) {
+      convertedLines.push(lines[i]);
+      i++;
+    } else if (line.startsWith("export const ") || line.startsWith("export let ") || line.startsWith("export var ")) {
+      const result = parseVariableDeclaration(lines, i), { type, name, value } = result;
+      convertedLines.push(`${type} ${name} = ${value};`);
+      convertedLines.push(`module.exports.${name} = ${name};`);
+      i = result.nextIndex;
+    } else if (line.startsWith("export function ") || line.startsWith("export async function ")) {
+      const result = parseFunctionDeclaration(lines, i);
+      convertedLines.push(result.functionCode);
+      convertedLines.push(`module.exports.${result.name} = ${result.name};`);
+      i = result.nextIndex;
+    } else if (line.startsWith("const ") || line.startsWith("let ") || line.startsWith("var ")) {
+      const result = parseVariableDeclaration(lines, i), { type, name, value } = result;
+      convertedLines.push(`${type} ${name} = ${value};`);
+      convertedLines.push(`module.exports.${name} = ${name};`);
+      i = result.nextIndex;
+    } else if (line.startsWith("function ") || line.startsWith("async function ")) {
+      const result = parseFunctionDeclaration(lines, i);
+      convertedLines.push(result.functionCode);
+      convertedLines.push(`module.exports.${result.name} = ${result.name};`);
+      i = result.nextIndex;
+    } else if (line.startsWith("export default function ") || line.startsWith("export default async function ")) {
+      const strippedLine = lines[i].replace(/^(\s*)export\s+default\s+/, "$1"), tempLines = [...lines];
+      tempLines[i] = strippedLine;
+      const result = parseFunctionDeclaration(tempLines, i);
+      convertedLines.push(result.functionCode);
+      if (result.name)
+        convertedLines.push(`module.exports.default = ${result.name};`);
+      i = result.nextIndex;
+    } else if (line.startsWith("export default ")) {
+      const value = line.replace(/^export\s+default\s+/, "").replace(/;$/, "");
+      convertedLines.push(`module.exports.default = ${value};`);
+      i++;
+    } else if (line.startsWith("class ") || line.startsWith("export class ")) {
+      const classMatch = line.match(/(?:export\s+)?class\s+(\w+)/);
+      if (classMatch) {
+        const className = classMatch[1];
+        let classCode = lines[i].replace(/^export\s+/, ""), braceDepth = 0, j = i;
+        for (;j < lines.length; j++) {
+          const l = lines[j];
+          for (const ch of l)
+            if (ch === "{")
+              braceDepth++;
+            else if (ch === "}")
+              braceDepth--;
+          if (j > i)
+            classCode += `
+` + l;
+          if (braceDepth <= 0 && j >= i)
+            break;
+        }
+        convertedLines.push(classCode);
+        convertedLines.push(`module.exports.${className} = ${className};`);
+        i = j + 1;
+      } else {
+        convertedLines.push(line);
+        i++;
+      }
+    } else if (line.includes("module.exports")) {
+      convertedLines.push(line);
+      i++;
+    } else if (line.trim() && !line.startsWith("//")) {
+      convertedLines.push(line);
+      i++;
+    } else
+      i++;
+  }
+  return resolveDynamicImports(convertedLines.join(`
+`), templateDir);
+}
+function resolveDynamicImports(source, templateDir) {
+  const len = source.length;
+  let out = "", i = 0, inString = null, inLineComment = !1, inBlockComment = !1, inTemplateExpr = 0;
+  while (i < len) {
+    const ch = source[i], next = source[i + 1];
+    if (inLineComment) {
+      out += ch;
+      if (ch === `
+`)
+        inLineComment = !1;
+      i++;
+      continue;
+    }
+    if (inBlockComment) {
+      out += ch;
+      if (ch === "*" && next === "/") {
+        out += next;
+        i += 2;
+        inBlockComment = !1;
+        continue;
+      }
+      i++;
+      continue;
+    }
+    if (!inString && ch === "/" && next === "/") {
+      inLineComment = !0;
+      out += ch;
+      i++;
+      continue;
+    }
+    if (!inString && ch === "/" && next === "*") {
+      inBlockComment = !0;
+      out += ch;
+      i++;
+      continue;
+    }
+    if (inString) {
+      out += ch;
+      if (ch === "\\") {
+        out += next;
+        i += 2;
+        continue;
+      }
+      if (ch === inString && inString !== "`") {
+        inString = null;
+        i++;
+        continue;
+      }
+      if (inString === "`") {
+        if (ch === "$" && next === "{") {
+          inTemplateExpr++;
+          out += next;
+          i += 2;
+          continue;
+        }
+        if (ch === "`") {
+          inString = null;
+          i++;
+          continue;
+        }
+      }
+      i++;
+      continue;
+    }
+    if (inTemplateExpr > 0) {
+      if (ch === "{")
+        inTemplateExpr++;
+      else if (ch === "}")
+        inTemplateExpr--;
+    }
+    if (ch === '"' || ch === "'" || ch === "`") {
+      inString = ch;
+      out += ch;
+      i++;
+      continue;
+    }
+    if (ch === "a" && source.startsWith("await", i)) {
+      const match = matchDynamicImportAt(source, i);
+      if (match) {
+        const { quote, path: importPath, end } = match;
+        if (importPath.startsWith(".")) {
+          const resolved = path.resolve(templateDir, importPath);
+          out += `await import(${quote}${resolved}${quote})`;
+          i = end;
+          continue;
+        }
+      }
+    }
+    out += ch;
+    i++;
+  }
+  return out;
+}
+function matchDynamicImportAt(src, start) {
+  let pos = start + 5;
+  if (pos >= src.length)
+    return null;
+  if (!/\s/.test(src[pos]))
+    return null;
+  while (pos < src.length && /\s/.test(src[pos]))
+    pos++;
+  if (!src.startsWith("import", pos))
+    return null;
+  pos += 6;
+  while (pos < src.length && /\s/.test(src[pos]))
+    pos++;
+  if (src[pos] !== "(")
+    return null;
+  pos++;
+  while (pos < src.length && /\s/.test(src[pos]))
+    pos++;
+  const quote = src[pos];
+  if (quote !== "'" && quote !== '"')
+    return null;
+  pos++;
+  const pathStart = pos;
+  while (pos < src.length && src[pos] !== quote)
+    if (src[pos] === "\\")
+      pos += 2;
+    else
+      pos++;
+  if (pos >= src.length)
+    return null;
+  const importPath = src.slice(pathStart, pos);
+  pos++;
+  while (pos < src.length && /\s/.test(src[pos]))
+    pos++;
+  if (src[pos] !== ")")
+    return null;
+  return { quote, path: importPath, end: pos + 1 };
+}
+function extractDestructuringPattern(str, startPos) {
+  const openChar = str[startPos];
+  if (openChar !== "{" && openChar !== "[")
+    return null;
+  const endPos = findMatchingDelimiter(str, openChar, openChar === "{" ? "}" : "]", startPos);
+  if (endPos === -1)
+    return null;
+  return {
+    pattern: str.slice(startPos, endPos + 1),
+    endPos: endPos + 1
+  };
+}
+function extractDestructuredNames(pattern) {
+  const names = [], inner = pattern.slice(1, -1).trim();
+  if (!inner)
+    return names;
+  let i = 0, depth = 0, currentName = "";
+  while (i < inner.length) {
+    const char = inner[i];
+    if (char === "{" || char === "[") {
+      depth++;
+      if (depth === 1) {
+        const nested = extractDestructuringPattern(inner, i);
+        if (nested) {
+          const nestedNames = extractDestructuredNames(nested.pattern);
+          names.push(...nestedNames);
+          i = nested.endPos;
+          currentName = "";
+          continue;
+        }
+      }
+    } else if (char === "}" || char === "]")
+      depth--;
+    if (depth > 0) {
+      i++;
+      continue;
+    }
+    if (char === ",") {
+      if (currentName.trim())
+        names.push(currentName.trim());
+      currentName = "";
+      i++;
+      continue;
+    }
+    if (char === ":") {
+      currentName = "";
+      i++;
+      continue;
+    }
+    if (char === "=") {
+      if (currentName.trim())
+        names.push(currentName.trim());
+      currentName = "";
+      i++;
+      while (i < inner.length && inner[i] !== "," && depth === 0) {
+        if (inner[i] === "{" || inner[i] === "[")
+          depth++;
+        else if (inner[i] === "}" || inner[i] === "]")
+          depth--;
+        i++;
+      }
+      continue;
+    }
+    if (/[\w$]/.test(char))
+      currentName += char;
+    i++;
+  }
+  if (currentName.trim())
+    names.push(currentName.trim());
+  return names;
+}
+function parseVariableDeclaration(lines, startIndex) {
+  const firstLine = lines[startIndex].trim(), match = firstLine.match(/^(?:export\s+)?(const|let|var)\s+(\w+)\s*=\s*(.*)$/);
+  if (!match) {
+    const destructuringPrefix = firstLine.match(/^(?:export\s+)?(const|let|var)\s+/);
+    if (destructuringPrefix) {
+      let afterKeyword = firstLine.slice(destructuringPrefix[0].length), joinedEndIndex = startIndex;
+      if ((afterKeyword.startsWith("{") || afterKeyword.startsWith("[")) && !afterKeyword.includes(afterKeyword.startsWith("{") ? "}" : "]")) {
+        const closeChar = afterKeyword.startsWith("{") ? "}" : "]";
+        let joined = afterKeyword;
+        for (let j = startIndex + 1;j < lines.length; j++) {
+          joined += " " + lines[j].trim();
+          joinedEndIndex = j;
+          if (lines[j].includes(closeChar))
+            break;
+        }
+        afterKeyword = joined;
+      }
+      const patternResult = extractDestructuringPattern(afterKeyword, 0);
+      if (patternResult) {
+        const type = destructuringPrefix[1], destructuringPattern = patternResult.pattern, afterPattern = afterKeyword.slice(patternResult.endPos).trim();
+        if (afterPattern.startsWith("=")) {
+          const initialValue = afterPattern.slice(1).trim();
+          let value = initialValue, currentIndex = Math.max(joinedEndIndex, startIndex);
+          if (needsMultilineReading(initialValue)) {
+            const result = readMultilineValue(lines, currentIndex, initialValue);
+            value = result.value;
+            currentIndex = result.nextIndex;
+          } else
+            currentIndex = currentIndex + 1;
+          value = value.trim().replace(/;$/, "");
+          const destructuredNames = extractDestructuredNames(destructuringPattern), uniqueName = `__stx_src_${startIndex}`, destructuredExports = destructuredNames.map((name) => `module.exports.${name} = ${name};`).join(`
+`);
+          return {
+            type,
+            name: uniqueName,
+            value: `${value}; ${type} ${destructuringPattern} = ${uniqueName};
+${destructuredExports}`,
+            nextIndex: currentIndex
+          };
+        }
+      }
+    }
+    throw Error(`Failed to parse variable declaration: ${firstLine}`);
+  }
+  const [, type, name, initialValue] = match;
+  let value = initialValue, currentIndex = startIndex;
+  if (needsMultilineReading(initialValue)) {
+    const result = readMultilineValue(lines, startIndex, initialValue);
+    value = result.value;
+    currentIndex = result.nextIndex;
+  } else
+    currentIndex = startIndex + 1;
+  while (currentIndex < lines.length) {
+    const nextLine = lines[currentIndex].trim();
+    if (nextLine.startsWith(".") || nextLine.startsWith("?.")) {
+      value += `
+${lines[currentIndex]}`;
+      currentIndex++;
+    } else
+      break;
+  }
+  value = value.trim().replace(/;$/, "");
+  return {
+    type,
+    name,
+    value,
+    nextIndex: currentIndex
+  };
+}
+function parseFunctionDeclaration(lines, startIndex) {
+  const firstLine = lines[startIndex].trim(), match = firstLine.match(/^(?:export\s+)?(?:async\s+)?function\s+(\w+)/);
+  if (!match)
+    throw Error(`Failed to parse function declaration: ${firstLine}`);
+  const [, name] = match;
+  let functionCode = firstLine.replace(/^export\s+/, ""), currentIndex = startIndex;
+  if (needsMultilineFunctionReading(firstLine)) {
+    const result = readMultilineFunction(lines, startIndex, functionCode);
+    functionCode = result.functionCode;
+    currentIndex = result.nextIndex;
+  } else
+    currentIndex = startIndex + 1;
+  return {
+    name,
+    functionCode,
+    nextIndex: currentIndex
+  };
+}
+function needsMultilineReading(value) {
+  const trimmed = value.trim();
+  if (trimmed.startsWith("{"))
+    return findMatchingDelimiter(trimmed, "{", "}", 0) === -1;
+  if (trimmed.startsWith("["))
+    return findMatchingDelimiter(trimmed, "[", "]", 0) === -1;
+  return !isValueComplete(trimmed);
+}
+function isValueComplete(value) {
+  const depth = { paren: 0, bracket: 0, brace: 0 };
+  let inString = null, inTemplateExpr = 0;
+  for (let i = 0;i < value.length; i++) {
+    const char = value[i];
+    if ((i > 0 ? value[i - 1] : "") === "\\" && inString)
+      continue;
+    if ((char === '"' || char === "'") && !inString) {
+      inString = char;
+      continue;
+    }
+    if (char === inString && inString !== "`") {
+      inString = null;
+      continue;
+    }
+    if (char === "`" && !inString) {
+      inString = "`";
+      continue;
+    }
+    if (char === "`" && inString === "`" && inTemplateExpr === 0) {
+      inString = null;
+      continue;
+    }
+    if (inString === "`" && char === "$" && value[i + 1] === "{") {
+      inTemplateExpr++;
+      i++;
+      continue;
+    }
+    if (inTemplateExpr > 0 && char === "{") {
+      inTemplateExpr++;
+      continue;
+    }
+    if (inTemplateExpr > 0 && char === "}") {
+      inTemplateExpr--;
+      continue;
+    }
+    if (inString)
+      continue;
+    if (char === "(")
+      depth.paren++;
+    else if (char === ")")
+      depth.paren--;
+    else if (char === "[")
+      depth.bracket++;
+    else if (char === "]")
+      depth.bracket--;
+    else if (char === "{")
+      depth.brace++;
+    else if (char === "}")
+      depth.brace--;
+  }
+  return depth.paren === 0 && depth.bracket === 0 && depth.brace === 0 && inString === null;
+}
+function needsMultilineFunctionReading(functionLine) {
+  const bracePos = functionLine.indexOf("{");
+  if (bracePos === -1)
+    return !0;
+  return findMatchingDelimiter(functionLine, "{", "}", bracePos) === -1;
+}
+function readMultilineValue(lines, startIndex, initialValue) {
+  let value = initialValue, i = startIndex + 1;
+  while (i < lines.length && !isValueComplete(value)) {
+    const nextLine = lines[i];
+    value += `
+${nextLine}`;
+    i++;
+  }
+  while (i < lines.length) {
+    const nextLine = lines[i].trim();
+    if (nextLine.startsWith(".") || nextLine.startsWith("?.")) {
+      value += `
+${lines[i]}`;
+      i++;
+    } else
+      break;
+  }
+  return { value, nextIndex: i };
+}
+function readMultilineFunction(lines, startIndex, initialFunction) {
+  let functionCode = initialFunction, i = startIndex + 1;
+  while (i < lines.length) {
+    const bracePos = functionCode.indexOf("{");
+    if (bracePos !== -1) {
+      if (findMatchingDelimiter(functionCode, "{", "}", bracePos) !== -1)
+        break;
+    }
+    const nextLine = lines[i];
+    functionCode += `
+${nextLine}`;
+    i++;
+  }
+  return { functionCode, nextIndex: i };
+}
+function evaluateFallbackExpression(expression, context) {
+  const direct = safeEvaluate(expression, context) ?? safeEvaluate(`(${expression})`, context);
+  if (direct !== void 0)
+    return direct;
+  if (!/\bprocess\b/.test(expression))
+    return;
+  const processEnvContext = { ...context, process: Object.freeze({ env: { ...process.env } }) };
+  try {
+    return Function(...Object.keys(processEnvContext), `'use strict'; return (${expression});`)(...Object.values(processEnvContext));
+  } catch {
+    try {
+      return Function(...Object.keys(processEnvContext), `'use strict'; return ${expression};`)(...Object.values(processEnvContext));
+    } catch {
+      return;
+    }
+  }
+}
+async function fallbackVariableExtraction(scriptContent, context, _filePath) {
+  const exportMatches = scriptContent.matchAll(/export\s+(const|let|var)\s+(\w+)\s*=\s*([\s\S]*?)(?=\s*(?:export\s+|$))/g);
+  for (const match of exportMatches) {
+    const [, , name, value] = match;
+    try {
+      const cleanValue = value.trim().replace(/;$/, ""), evaluated = evaluateFallbackExpression(cleanValue, context);
+      if (evaluated !== void 0)
+        context[name] = evaluated;
+    } catch (e2) {
+      console.warn(`Failed to parse export ${name} in fallback:`, e2);
+    }
+  }
+  const varMatches = scriptContent.matchAll(/(?:^|\n)\s*(const|let|var)\s+(\w+)\s*=\s*([\s\S]*?)(?=\s*(?:(?:const|let|var|function|export)\s+|$))/g);
+  for (const match of varMatches) {
+    const [, , name, value] = match;
+    if (!(name in context))
+      try {
+        const cleanValue = value.trim().replace(/;$/, ""), evaluated = evaluateFallbackExpression(cleanValue, context);
+        if (evaluated !== void 0)
+          context[name] = evaluated;
+      } catch {}
+  }
+}
+export function extractScriptFromTemplate(template) {
+  const scriptMatch = template.match(/<script\b[^>]*>([\s\S]*?)<\/script>/i), scriptContent = scriptMatch ? scriptMatch[1] : "", templateWithoutScript = scriptMatch ? template.replace(/<script\b[^>]*>[\s\S]*?<\/script>/i, "") : template;
+  return { scriptContent, templateWithoutScript };
+}
+export function hasVariables(scriptContent) {
+  const trimmed = scriptContent.trim();
+  if (!trimmed)
+    return !1;
+  return /(?:const|let|var|function)\s+\w+/.test(trimmed);
+}