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

package/dist/variable-extractor.js

@@ -0,0 +1,1306 @@
+var {require}=import.meta;import path from "node:path";
+import process from "node:process";
+import { getSharedTranspiler } from "./utils.js";
+export const STX_ENGINE_BINDING_NAMES = [
+  "module",
+  "exports",
+  "require",
+  "props",
+  "$props",
+  "defineProps",
+  "withDefaults",
+  "defineClientPayload",
+  "state",
+  "derived",
+  "effect",
+  "batch",
+  "onMount",
+  "onDestroy",
+  "definePageMeta",
+  "useRoute",
+  "useRouter",
+  "useHead",
+  "useSeoMeta",
+  "setResponseStatus",
+  "setResponseHeader",
+  "notFound",
+  "ref",
+  "reactive",
+  "computed",
+  "watch",
+  "onMounted",
+  "onUnmounted",
+  "nextTick",
+  "defineEmits",
+  "defineExpose",
+  "defineSlots",
+  "provide",
+  "inject",
+  "useColorMode",
+  "useDark",
+  "useMediaQuery",
+  "useScrollLock",
+  "usePreferredDark",
+  "usePreferredLight",
+  "usePreferredReducedMotion",
+  "usePreferredContrast",
+  "window",
+  "document",
+  "console",
+  "confirm",
+  "alert",
+  "fetch",
+  "params"
+];
+const ENGINE_BINDINGS = new Set(STX_ENGINE_BINDING_NAMES), CONTEXT_RESERVED_BINDINGS = new Set(["props", "$props", "defineProps"]), STX_RUNTIME_SPECIFIERS = new Set(["stx", "@stacksjs/stx"]);
+import { findMatchingDelimiter } from "./parser/tokenizer.js";
+import { mergeHeadConfigs, seoMetaToHeadConfig } from "./head.js";
+import { getPublicEnvDefine } from "./public-env.js";
+import { isUsableParamName, safeEvaluate } from "./safe-evaluator.js";
+import { responseBindings } from "./page-response.js";
+import { contentKey, renderMemo } from "./render-memo.js";
+const transpiledServerScripts = renderMemo(128), compiledServerScripts = renderMemo(64);
+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 function isModuleResolutionFailure(message) {
+  return /cannot find module|could not resolve|module not found|failed to resolve/i.test(message);
+}
+export function isMissingBindingFailure(message) {
+  if (!/is not defined|can't find variable/i.test(message))
+    return !1;
+  return !/\b(document|window|navigator|localStorage|sessionStorage|self)\b/.test(message);
+}
+export async function extractVariables(scriptContent, context, filePath, options = {}) {
+  if (!scriptContent.trim())
+    return;
+  const define = getPublicEnvDefine(), transpileKey = contentKey(scriptContent, JSON.stringify(define));
+  let jsContent = transpiledServerScripts.get(transpileKey);
+  if (jsContent === void 0) {
+    try {
+      const transpiler = getSharedTranspiler({ loader: "ts", target: "browser", define });
+      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);
+    }
+    transpiledServerScripts.set(transpileKey, jsContent);
+  }
+  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:") && !["fs", "path", "os", "child_process", "crypto", "http", "https", "url", "util", "stream", "events", "buffer", "net", "querystring", "zlib", "tls"].includes(id)), unresolvable = new Map;
+  for (const id of serverRequires)
+    try {
+      if (id.startsWith(".")) {
+        preloaded[id] = await import(path.resolve(path.dirname(filePath), id));
+        continue;
+      }
+      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 (error) {
+      if (id.startsWith("."))
+        unresolvable.set(id, error instanceof Error ? error.message : String(error));
+    }
+  const requireFn = (id) => {
+    if (preloaded[id])
+      return preloaded[id];
+    const reason = unresolvable.get(id);
+    if (reason !== void 0)
+      throw Error(`Cannot require '${id}' from ${filePath}: ${reason}`);
+    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 });
+  for (const shadowed of ["name", "length", "caller", "arguments"]) {
+    if (Object.prototype.hasOwnProperty.call(propsObj, shadowed))
+      continue;
+    try {
+      Object.defineProperty($props, shadowed, { value: void 0, enumerable: !1, configurable: !0, writable: !0 });
+    } catch {}
+  }
+  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) => {}, responseApi = responseBindings(context);
+  function definePageMeta(meta) {
+    const config = meta || {};
+    if (config.title !== void 0 || config.description !== void 0)
+      useSeoMeta({ title: config.title, description: config.description });
+  }
+  function defineClientPayload(payload) {
+    if (!payload || typeof payload !== "object")
+      return;
+    const declared = context.__stxClientPayload ?? {};
+    Object.assign(declared, payload);
+    context.__stxClientPayload = declared;
+  }
+  const useRoute = () => {
+    const serveCtx = context.__stxServeContext, search = context.__stxServeSearch ?? serveCtx?.search ?? "", path = serveCtx?.path ?? "", parsed = Object.fromEntries(new URLSearchParams(search)), supplied = context.query, query = Object.keys(parsed).length > 0 ? parsed : supplied ?? {}, suffix = search || (Object.keys(query).length > 0 ? `?${new URLSearchParams(query).toString()}` : "");
+    return {
+      params: context.params ?? {},
+      query,
+      path,
+      name: "",
+      fullPath: path + suffix,
+      hash: "",
+      matched: []
+    };
+  }, useRouter = () => ({ push: (_to) => {}, replace: (_to) => {}, back: () => {}, forward: () => {}, go: (_n) => {} }), useHead = (head) => {
+    const existing = context.__stx_runtime_head || {};
+    context.__stx_runtime_head = mergeHeadConfigs(existing, head || {});
+  }, useSeoMeta = (meta) => {
+    useHead(seoMetaToHeadConfig(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 = () => state(!1), useMediaQuery = (_query) => state(!1), useScrollLock = () => state(!1), usePreferredDark = () => useMediaQuery("(prefers-color-scheme: dark)"), usePreferredLight = () => useMediaQuery("(prefers-color-scheme: light)"), usePreferredReducedMotion = () => useMediaQuery("(prefers-reduced-motion: reduce)"), usePreferredContrast = () => useMediaQuery("(prefers-contrast: more)"), 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) && !CONTEXT_RESERVED_BINDINGS.has(key) && isUsableParamName(key)), filteredContextValues = filteredContextKeys.map((key) => context[key]);
+    if (!filteredContextKeys.includes("__stxServeContext")) {
+      filteredContextKeys.push("__stxServeContext");
+      filteredContextValues.push(void 0);
+    }
+    const stxShadowedNames = new Set([
+      "async",
+      "module",
+      "exports",
+      "require",
+      "params",
+      "window",
+      "document",
+      "console",
+      "state",
+      "derived",
+      "effect"
+    ]), propArgNames = [], propArgValues = [];
+    for (const [key, value] of Object.entries(propsObj)) {
+      if (!isUsableParamName(key))
+        continue;
+      if (stxShadowedNames.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 scriptParams = [...STX_ENGINE_BINDING_NAMES, ...propArgNames, ...scriptContextKeys], scriptBody = `return (async () => {
+        ${convertedScript}
+        ${reSyncCode}
+        return module.exports
+      })()`, compileKey = contentKey(scriptBody, scriptParams.join("\x00"));
+    let scriptFn = compiledServerScripts.get(compileKey);
+    if (!scriptFn) {
+      scriptFn = Function(...scriptParams, scriptBody);
+      compiledServerScripts.set(compileKey, scriptFn);
+    }
+    const result = await scriptFn(module, exports, requireFn, propsObj, $props, defineProps, withDefaults, defineClientPayload, state, derived, effect, batch, onMount, onDestroy, definePageMeta, useRoute, useRouter, useHead, useSeoMeta, responseApi.setResponseStatus, responseApi.setResponseHeader, responseApi.notFound, ref, reactive, computed, watch, onMounted, onUnmounted, nextTick, defineEmits, defineExpose, defineSlots, provide, inject, useColorMode, useDark, useMediaQuery, useScrollLock, usePreferredDark, usePreferredLight, usePreferredReducedMotion, usePreferredContrast, 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) {
+    const msg = primaryError instanceof Error ? primaryError.message : String(primaryError);
+    if (isModuleResolutionFailure(msg))
+      console.warn(`[stx] server <script> in ${filePath ?? "<unknown>"} imports a module that does not resolve, so every variable in that script is undefined. Cause: ${msg}`);
+    else if (isMissingBindingFailure(msg))
+      console.warn(`[stx] server <script> in ${filePath ?? "<unknown>"} names something that does not exist, so every variable in that script is undefined. Optional chaining does not help here: an undefined identifier throws before the chain is reached. Cause: ${msg}`);
+    else if (process.env.STX_DEBUG)
+      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 isCompleteImport(statement) {
+  let braces = 0, quote = null, sawFrom = !1, closedSpecifier = !1;
+  for (let index = 0;index < statement.length; index++) {
+    const character = statement[index];
+    if (quote) {
+      if (character === quote) {
+        quote = null;
+        if (sawFrom || braces === 0)
+          closedSpecifier = !0;
+      }
+      continue;
+    }
+    if (character === "'" || character === '"' || character === "`") {
+      quote = character;
+      continue;
+    }
+    if (character === "{")
+      braces++;
+    else if (character === "}")
+      braces--;
+    else if (statement.startsWith("from", index) && braces === 0)
+      sawFrom = !0;
+  }
+  return quote === null && braces === 0 && closedSpecifier;
+}
+const UNINITIALIZED_DECLARATION = /^(?:export\s+)?(?:const|let|var)\s+[A-Za-z_$][\w$]*(?:\s*,\s*[A-Za-z_$][\w$]*)*\s*;?$/;
+export function convertToCommonJS(scriptContent, filePath) {
+  const templateDir = filePath ? path.dirname(filePath) : process.cwd(), projectRoot = 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;
+      const callStart = i;
+      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;
+      const callText = lines.slice(callStart, i).join(`
+`), lifted = [];
+      for (const key of ["title", "description"]) {
+        const match = new RegExp(`\\b${key}\\s*:\\s*(['"\`])((?:\\\\.|(?!\\1)[^\\\\])*)\\1`).exec(callText);
+        if (match)
+          lifted.push(`${key}: ${JSON.stringify(match[2])}`);
+      }
+      if (lifted.length > 0)
+        convertedLines.push(`useSeoMeta({ ${lifted.join(", ")} });`);
+      continue;
+    }
+    if (line.startsWith("import ") || line === "import" || line.startsWith("import{")) {
+      let statement = line, consumed = 0;
+      while (!isCompleteImport(statement) && i + consumed + 1 < lines.length) {
+        consumed++;
+        statement = `${statement} ${lines[i + consumed].trim()}`;
+      }
+      i += consumed;
+      const defaultImportMatch = statement.match(/^import\s+(\w+)\s+from\s+['"](.+?)['"]/), namedImportMatch = statement.match(/^import\s+\{([^}]*)\}\s+from\s+['"](.+?)['"]/), sideEffectMatch = statement.match(/^import\s+['"](.+?)['"]/), line_ = statement, resolveSource = (source) => {
+        if (source.startsWith("."))
+          return path.resolve(templateDir, source);
+        if (source.startsWith("~/") || source.startsWith("@/"))
+          return path.resolve(projectRoot, source.slice(2));
+        return source;
+      };
+      if (defaultImportMatch) {
+        const [, name, source] = defaultImportMatch, resolved = resolveSource(source);
+        convertedLines.push(`const ${name} = (await import('${resolved}')).default`);
+        convertedLines.push(`module.exports.${name} = ${name};`);
+      } else if (namedImportMatch) {
+        const [, names, source] = namedImportMatch, resolved = resolveSource(source), specifiers = [], exported = [], isStxRuntime = STX_RUNTIME_SPECIFIERS.has(source);
+        for (const raw of names.split(",")) {
+          const specifier = raw.trim();
+          if (!specifier)
+            continue;
+          const aliased = specifier.split(/\s+as\s+/);
+          if (aliased.length === 2) {
+            const [imported, local] = [aliased[0].trim(), aliased[1].trim()];
+            if (isStxRuntime && ENGINE_BINDINGS.has(imported)) {
+              convertedLines.push(`const ${local} = ${imported};`);
+              continue;
+            }
+            specifiers.push(`${imported}: ${local}`);
+            exported.push(local);
+          } else {
+            if (isStxRuntime && ENGINE_BINDINGS.has(specifier))
+              continue;
+            specifiers.push(specifier);
+            exported.push(specifier);
+          }
+        }
+        if (specifiers.length > 0)
+          convertedLines.push(`const { ${specifiers.join(", ")} } = await import('${resolved}')`);
+        for (const local of exported)
+          convertedLines.push(`module.exports.${local} = ${local};`);
+      } else if (sideEffectMatch) {
+        const resolved = resolveSource(sideEffectMatch[1]);
+        convertedLines.push(`await import('${resolved}')`);
+      } else
+        convertedLines.push(line_);
+      i++;
+      continue;
+    }
+    if (UNINITIALIZED_DECLARATION.test(line)) {
+      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, projectRoot);
+}
+function resolveDynamicImports(source, templateDir, projectRoot) {
+  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(".") || importPath.startsWith("~/") || importPath.startsWith("@/")) {
+          const resolved = importPath.startsWith(".") ? path.resolve(templateDir, importPath) : path.resolve(projectRoot, importPath.slice(2));
+          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 === "[") {
+      const nested = depth === 0 ? extractDestructuringPattern(inner, i) : null;
+      if (nested) {
+        names.push(...extractDestructuredNames(nested.pattern));
+        i = nested.endPos;
+        currentName = "";
+        continue;
+      }
+      depth++;
+    } 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;
+}
+export function splitDeclaration(line) {
+  const head = /^(?:export\s+)?(const|let|var)\s+([A-Za-z_$][\w$]*)/.exec(line);
+  if (!head)
+    return null;
+  let index = head[0].length;
+  const isSpace = (character) => character === " " || character === "\t";
+  while (index < line.length && isSpace(line[index]))
+    index++;
+  if (line[index] === ":") {
+    let depth = 0, quote = null;
+    index++;
+    for (;index < line.length; index++) {
+      const character = line[index];
+      if (quote) {
+        if (character === "\\") {
+          index++;
+          continue;
+        }
+        if (character === quote)
+          quote = null;
+        continue;
+      }
+      if (character === "'" || character === '"' || character === "`") {
+        quote = character;
+        continue;
+      }
+      if (character === "(" || character === "[" || character === "{" || character === "<") {
+        depth++;
+        continue;
+      }
+      if (character === ")" || character === "]" || character === "}" || character === ">") {
+        depth--;
+        continue;
+      }
+      if (character === "=" && depth <= 0) {
+        const next = line[index + 1], previous = line[index - 1];
+        if (next !== "=" && next !== ">" && previous !== "=" && previous !== "!" && previous !== "<" && previous !== ">")
+          break;
+      }
+    }
+    if (line[index] !== "=")
+      return null;
+  }
+  while (index < line.length && isSpace(line[index]))
+    index++;
+  if (line[index] !== "=")
+    return null;
+  return {
+    type: head[1],
+    name: head[2],
+    value: line.slice(index + 1).trim()
+  };
+}
+function countPatternDepth(text, openChar, closeChar, depth) {
+  let quote = null, escaped = !1;
+  for (const character of text) {
+    if (escaped) {
+      escaped = !1;
+      continue;
+    }
+    if (character === "\\") {
+      escaped = !0;
+      continue;
+    }
+    if (quote) {
+      if (character === quote)
+        quote = null;
+      continue;
+    }
+    if (character === "'" || character === '"' || character === "`") {
+      quote = character;
+      continue;
+    }
+    if (character === openChar)
+      depth++;
+    else if (character === closeChar)
+      depth--;
+  }
+  return depth;
+}
+function parseVariableDeclaration(lines, startIndex) {
+  const firstLine = lines[startIndex].trim(), split = splitDeclaration(firstLine), match = split ? [firstLine, split.type, split.name, split.value] : null;
+  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("[")) {
+        const openChar = afterKeyword[0], closeChar = openChar === "{" ? "}" : "]";
+        let depth = countPatternDepth(afterKeyword, openChar, closeChar, 0), joined = afterKeyword;
+        for (let j = startIndex + 1;j < lines.length && depth > 0; j++) {
+          joined += ` ${lines[j].trim()}`;
+          joinedEndIndex = j;
+          depth = countPatternDepth(lines[j], openChar, closeChar, depth);
+        }
+        if (depth > 0) {
+          joined = afterKeyword;
+          joinedEndIndex = startIndex;
+        }
+        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 findFunctionBodyBrace(functionLine) {
+  const parenPos = functionLine.indexOf("(");
+  if (parenPos === -1)
+    return functionLine.indexOf("{");
+  const paramsEnd = findMatchingDelimiter(functionLine, "(", ")", parenPos);
+  if (paramsEnd === -1)
+    return -1;
+  return functionLine.indexOf("{", paramsEnd);
+}
+function needsMultilineFunctionReading(functionLine) {
+  const bracePos = findFunctionBodyBrace(functionLine);
+  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 = findFunctionBodyBrace(functionCode);
+    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 } }) }, envKeys = Object.keys(processEnvContext).filter(isUsableParamName), envValues = envKeys.map((key) => processEnvContext[key]);
+  try {
+    return Function(...envKeys, `'use strict'; return (${expression});`)(...envValues);
+  } catch {
+    try {
+      return Function(...envKeys, `'use strict'; return ${expression};`)(...envValues);
+    } 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);
+}