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

package/dist/client-script.js

@@ -0,0 +1,865 @@
+import path from "node:path";
+import fs from "node:fs";
+import { asInvocableStatement } from "./events.js";
+import { transformStoreImports } from "./store-imports.js";
+import { findInterpolationEnd, stripCommentsAndLiterals } from "./strip-literals.js";
+export { findInterpolationEnd, stripCommentsAndLiterals } from "./strip-literals.js";
+import { shouldTranspileTypeScript, transpileTypeScript } from "./utils.js";
+import { importOnce } from "./lazy-module.js";
+import { STX_RUNTIME_GLOBALS, usesReactiveRuntime } from "./runtime-globals.js";
+import { escapeScriptBody } from "./script-emit.js";
+const CSS_SIDE_EFFECT_IMPORT_REGEX = /^[ \t]*import\s+['"]([^'"]+?\.css)(\?[^'"]*)?['"]\s*;?\s*$/gm;
+function splitBareSpecifier(spec) {
+  if (spec.startsWith(".") || spec.startsWith("/"))
+    return null;
+  if (spec.startsWith("@")) {
+    const m = spec.match(/^(@[^/]+\/[^/]+)(\/.*)?$/);
+    if (!m)
+      return null;
+    return { pkg: m[1], subpath: m[2] || "" };
+  }
+  const m = spec.match(/^([^/]+)(\/.*)?$/);
+  if (!m)
+    return null;
+  return { pkg: m[1], subpath: m[2] || "" };
+}
+function findPackageDir(pkg, fromDir) {
+  let dir = fromDir;
+  while (!0) {
+    const candidate = path.join(dir, "node_modules", pkg, "package.json");
+    if (fs.existsSync(candidate))
+      return path.dirname(candidate);
+    const parent = path.dirname(dir);
+    if (parent === dir)
+      return null;
+    dir = parent;
+  }
+}
+function resolveExportsSubpath(exports, request) {
+  if (!exports || typeof exports !== "object")
+    return null;
+  const pickTarget = (target) => {
+    if (typeof target === "string")
+      return target;
+    if (target && typeof target === "object") {
+      if (typeof target.import === "string")
+        return target.import;
+      if (typeof target.default === "string")
+        return target.default;
+      if (typeof target.import === "object")
+        return pickTarget(target.import);
+      if (typeof target.default === "object")
+        return pickTarget(target.default);
+    }
+    return null;
+  };
+  if (Object.prototype.hasOwnProperty.call(exports, request))
+    return pickTarget(exports[request]);
+  let bestMatch = null;
+  for (const pattern of Object.keys(exports)) {
+    const starIdx = pattern.indexOf("*");
+    if (starIdx === -1)
+      continue;
+    const prefix = pattern.slice(0, starIdx), suffix = pattern.slice(starIdx + 1);
+    if (!request.startsWith(prefix) || !request.endsWith(suffix))
+      continue;
+    if (request.length < prefix.length + suffix.length)
+      continue;
+    if (!bestMatch || prefix.length > bestMatch.prefix.length)
+      bestMatch = { pattern, prefix, suffix };
+  }
+  if (bestMatch) {
+    const matchedInner = request.slice(bestMatch.prefix.length, request.length - bestMatch.suffix.length), target = pickTarget(exports[bestMatch.pattern]);
+    if (target)
+      return target.replace("*", matchedInner);
+  }
+  return null;
+}
+function resolveByPackageExports(spec, fromDir) {
+  const split = splitBareSpecifier(spec);
+  if (!split || !split.subpath)
+    return null;
+  const pkgDir = findPackageDir(split.pkg, fromDir);
+  if (!pkgDir)
+    return null;
+  let manifest;
+  try {
+    manifest = JSON.parse(fs.readFileSync(path.join(pkgDir, "package.json"), "utf8"));
+  } catch {
+    return null;
+  }
+  const request = `.${split.subpath}`, target = resolveExportsSubpath(manifest.exports, request);
+  if (!target)
+    return null;
+  const abs = path.resolve(pkgDir, target);
+  return fs.existsSync(abs) ? abs : null;
+}
+export function extractAndStripCssImports(code, options) {
+  const templateDir = options.filePath ? path.dirname(options.filePath) : options.projectRoot || process.cwd(), projectRoot = options.projectRoot || process.cwd(), seen = new Set, styles = [], unresolved = [];
+  return { code: code.replace(CSS_SIDE_EFFECT_IMPORT_REGEX, (_match, spec) => {
+    let resolvedPath;
+    try {
+      if (spec.startsWith("./") || spec.startsWith("../") || spec.startsWith("/")) {
+        resolvedPath = spec.startsWith("/") ? spec : path.resolve(templateDir, spec);
+        if (!fs.existsSync(resolvedPath))
+          throw Error(`file not found: ${resolvedPath}`);
+      } else {
+        let resolved = null;
+        try {
+          resolved = Bun.resolveSync(spec, projectRoot);
+        } catch {
+          resolved = resolveByPackageExports(spec, projectRoot);
+        }
+        if (!resolved)
+          throw Error(`could not resolve ${spec} (Bun.resolveSync + exports fallback both failed)`);
+        resolvedPath = resolved;
+      }
+    } catch (err) {
+      console.warn(`[stx:vendor-css] could not resolve ${JSON.stringify(spec)} (from ${options.filePath || "<unknown>"}): ${err?.message || err}`);
+      unresolved.push(spec);
+      return "";
+    }
+    if (seen.has(resolvedPath))
+      return "";
+    seen.add(resolvedPath);
+    try {
+      const contents = fs.readFileSync(resolvedPath, "utf8");
+      styles.push({ source: spec, resolvedPath, contents });
+    } catch (err) {
+      console.warn(`[stx:vendor-css] could not read ${resolvedPath}: ${err?.message || err}`);
+      unresolved.push(spec);
+    }
+    return "";
+  }), styles, unresolved };
+}
+function escapeAttr(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+export function renderVendorStyleTags(styles) {
+  if (styles.length === 0)
+    return "";
+  return `${styles.map((s) => {
+    return `<style data-stx-vendor="${escapeAttr(s.source)}" data-stx-layer="vendor">
+@layer vendor {
+${s.contents}
+}
+</style>`;
+  }).join(`
+`)}
+`;
+}
+export const STX_AUTO_IMPORTS = STX_RUNTIME_GLOBALS;
+export { BROWSER_CORE_IMPORTS } from "./browser-core-imports.js";
+import { BROWSER_CORE_IMPORTS } from "./browser-core-imports.js";
+export function injectBrowserCoreAutoImports(code) {
+  const searchable = stripCommentsAndLiterals(code), explicitlyImported = new Set;
+  for (const match of code.matchAll(/^\s*import\s+(?:type\s+)?\{([^}]*)\}\s+from\s+['"][^'"]+['"]\s*;?\s*$/gm))
+    for (const specifier of match[1].split(",")) {
+      const localName = specifier.trim().split(/\s+as\s+/).pop()?.replace(/^type\s+/, "").trim();
+      if (localName)
+        explicitlyImported.add(localName);
+    }
+  const locallyDeclared = new Set;
+  for (const match of searchable.matchAll(/\b(?:const|let|var|function|class)\s+([A-Za-z_$][\w$]*)/g))
+    locallyDeclared.add(match[1]);
+  for (const match of searchable.matchAll(/\b(?:const|let|var)\s*\{([^}]*)\}/g))
+    for (const binding of match[1].split(",")) {
+      const localName = binding.trim().split(/[:=]/).pop()?.trim();
+      if (localName)
+        locallyDeclared.add(localName);
+    }
+  const imports = BROWSER_CORE_IMPORTS.filter((symbol) => {
+    if (explicitlyImported.has(symbol) || locallyDeclared.has(symbol))
+      return !1;
+    return new RegExp(`\\b${symbol}\\s*\\(`).test(searchable);
+  }), models = detectModelUsage(searchable).filter((model) => !explicitlyImported.has(model) && !locallyDeclared.has(model));
+  if (imports.length === 0 && models.length === 0)
+    return { code, imports, models };
+  return {
+    code: `${[
+      imports.length > 0 ? `import { ${imports.join(", ")} } from '@stacksjs/browser'` : "",
+      models.length > 0 ? "import '@stacksjs/browser'" : "",
+      models.length > 0 ? `const { ${models.join(", ")} } = window.StacksBrowser || {}` : ""
+    ].filter(Boolean).join(`
+`)}
+${code}`,
+    imports,
+    models
+  };
+}
+const JS_BUILTINS = new Set([
+  "Promise",
+  "Object",
+  "Array",
+  "Map",
+  "Set",
+  "Date",
+  "Error",
+  "JSON",
+  "Math",
+  "Number",
+  "String",
+  "RegExp",
+  "Symbol",
+  "WeakMap",
+  "WeakSet",
+  "Proxy",
+  "Reflect",
+  "Intl",
+  "URL",
+  "URLSearchParams",
+  "FormData",
+  "Headers",
+  "Request",
+  "Response",
+  "AbortController",
+  "EventTarget",
+  "Element",
+  "Document",
+  "Node",
+  "Window",
+  "Console",
+  "Storage",
+  "Navigator",
+  "Blob",
+  "File",
+  "FileReader",
+  "HTMLElement",
+  "SVGElement",
+  "Event",
+  "CustomEvent",
+  "DOMParser",
+  "XMLSerializer",
+  "WebSocket",
+  "Worker",
+  "SharedWorker",
+  "IntersectionObserver",
+  "MutationObserver",
+  "ResizeObserver",
+  "PerformanceObserver",
+  "Notification",
+  "Bun",
+  "Buffer",
+  "Process",
+  "Modal",
+  "Intl"
+]);
+function detectModelUsage(code) {
+  const models = new Set, modelPattern = /\b([A-Z][a-zA-Z0-9]*)\s*\.\s*(all|find|first|get|where|orderBy|orderByDesc|limit|select|pluck|create|update|delete)\s*\(/g;
+  let match;
+  while ((match = modelPattern.exec(code)) !== null)
+    if (!JS_BUILTINS.has(match[1]))
+      models.add(match[1]);
+  return Array.from(models);
+}
+function collectLocalBindings(code) {
+  const bindings = new Set;
+  for (const match of code.matchAll(/\b(?:const|let|var|function|class)\s+([A-Za-z_$][\w$]*)/g))
+    bindings.add(match[1]);
+  for (const match of code.matchAll(/\b(?:const|let|var)\s*\{([^}]*)\}/g))
+    for (const binding of match[1].split(",")) {
+      const localName = binding.trim().split(/[:=]/).pop()?.trim();
+      if (localName && /^[A-Za-z_$][\w$]*$/.test(localName))
+        bindings.add(localName);
+    }
+  return bindings;
+}
+export function transformAutoImports(code) {
+  const usedStxImports = new Set, usedBrowserImports = new Set;
+  let transformedCode = code;
+  transformedCode = transformedCode.replace(/^\s*import\s+type\s+\{[^}]*\}\s+from\s+['"][^'"]+['"]\s*;?\s*$/gm, "// [type import stripped]");
+  const existingImports = new Set, importRegex = /^\s*import\s+(?:type\s+)?{\s*([^}]+)\s*}\s+from\s+['"](@stacksjs\/browser|@stacksjs\/stx|stx)['"]\s*;?\s*$/gm;
+  let match;
+  while ((match = importRegex.exec(code)) !== null) {
+    const imports = match[1], source = match[2];
+    if (match[0].includes("import type"))
+      continue;
+    const aliases = [];
+    for (const rawSpecifier of imports.split(",")) {
+      const specifier = rawSpecifier.trim();
+      if (!specifier || specifier.startsWith("type "))
+        continue;
+      const aliasMatch = specifier.match(/^([A-Za-z_$][\w$]*)(?:\s+as\s+([A-Za-z_$][\w$]*))?$/);
+      if (!aliasMatch)
+        continue;
+      const importedName = aliasMatch[1], localName = aliasMatch[2] || importedName;
+      existingImports.add(importedName);
+      existingImports.add(localName);
+      if (source === "stx" || source === "@stacksjs/stx")
+        usedStxImports.add(importedName);
+      else
+        usedBrowserImports.add(importedName);
+      if (localName !== importedName)
+        aliases.push(`${localName} = ${importedName}`);
+    }
+    const replacement = aliases.length > 0 ? `var ${aliases.join(", ")}; /* [auto-import processed] */` : "// [auto-import processed]";
+    transformedCode = transformedCode.replace(match[0], replacement);
+  }
+  const locallyDeclared = collectLocalBindings(transformedCode);
+  for (const symbol of STX_AUTO_IMPORTS) {
+    if (existingImports.has(symbol) || locallyDeclared.has(symbol))
+      continue;
+    if (new RegExp(`\\b${symbol}\\s*(?:<[^>]*>)?\\s*\\(`, "g").test(transformedCode))
+      usedStxImports.add(symbol);
+  }
+  const searchableForBrowser = stripCommentsAndLiterals(transformedCode), importedFromAnywhere = new Set;
+  for (const importMatch of transformedCode.matchAll(/^\s*import\s+(?:type\s+)?\{([^}]*)\}\s+from\s+['"][^'"]+['"]\s*;?\s*$/gm))
+    for (const specifier of importMatch[1].split(",")) {
+      const parts = specifier.trim().replace(/^type\s+/, "").split(/\s+as\s+/);
+      for (const part of parts) {
+        const name = part.trim();
+        if (name)
+          importedFromAnywhere.add(name);
+      }
+    }
+  for (const symbol of BROWSER_CORE_IMPORTS) {
+    if (existingImports.has(symbol) || locallyDeclared.has(symbol) || importedFromAnywhere.has(symbol))
+      continue;
+    if (new RegExp(`\\b${symbol}\\b`, "g").test(searchableForBrowser))
+      usedBrowserImports.add(symbol);
+  }
+  const detectedModels = detectModelUsage(transformedCode);
+  for (const model of detectedModels)
+    if (!existingImports.has(model) && !locallyDeclared.has(model))
+      usedBrowserImports.add(model);
+  return {
+    code: transformedCode,
+    stxImports: Array.from(usedStxImports),
+    browserImports: Array.from(usedBrowserImports)
+  };
+}
+export function generateAutoImportDestructuring(stxImports, browserImports) {
+  const lines = [];
+  if (stxImports.length > 0)
+    lines.push(`  var { ${stxImports.join(", ")} } = window.stx || window;`);
+  if (browserImports.length > 0)
+    lines.push(`  var { ${browserImports.join(", ")} } = window.StacksBrowser || {};`);
+  if (lines.length > 0)
+    return `  // STX: auto-imported from stx and @stacksjs/browser
+${lines.join(`
+`)}
+${generateAutoImportGuard(stxImports, browserImports)}`;
+  return "";
+}
+export function generateBrowserAutoImportDestructuring(code, exclude = []) {
+  const { browserImports } = transformAutoImports(code), excluded = new Set(exclude);
+  return generateAutoImportDestructuring([], browserImports.filter((name) => !excluded.has(name)));
+}
+function generateAutoImportGuard(stxImports, browserImports) {
+  const entries = [
+    ...stxImports.map((name) => `['${name}', typeof ${name}, 'stx']`),
+    ...browserImports.map((name) => `['${name}', typeof ${name}, '@stacksjs/browser']`)
+  ];
+  if (entries.length === 0)
+    return "";
+  return `  // STX: report auto-imports the client runtime did not provide
+  [${entries.join(", ")}].forEach(function (e) {
+    if (e[1] !== 'undefined') return;
+    console.error(
+      '[stx] "' + e[0] + '" is used in this client script and auto-imported from ' + e[2] + ', '
+      + 'but the client runtime does not provide it. Either it is not exported to the browser, '
+      + 'or it should be imported from a relative path so the bundler includes it.'
+    );
+  });
+`;
+}
+export function extractBridgeData(context) {
+  const declared = context.__stxClientPayload;
+  if (declared && typeof declared === "object") {
+    const picked = {};
+    for (const key in declared) {
+      const value = declared[key];
+      if (typeof value === "function")
+        continue;
+      picked[key] = value;
+    }
+    picked.__stxDeclaredPayload = !0;
+    return picked;
+  }
+  const out = {};
+  for (const key in context) {
+    if (key.startsWith("__") || key.startsWith("$"))
+      continue;
+    const value = context[key];
+    if (typeof value === "function")
+      continue;
+    out[key] = value;
+  }
+  return out;
+}
+function extractDestructuredBindings(pattern, objectPattern) {
+  const bindings = new Set;
+  for (const rawPart of pattern.split(",")) {
+    let part = rawPart.trim().replace(/^\.\.\./, "").trim();
+    if (!part)
+      continue;
+    if (objectPattern) {
+      const colon = part.lastIndexOf(":");
+      if (colon !== -1)
+        part = part.slice(colon + 1).trim();
+    }
+    part = part.split("=")[0].trim();
+    if (/^[A-Za-z_$][\w$]*$/.test(part))
+      bindings.add(part);
+  }
+  return bindings;
+}
+function bracketDepths(stripped) {
+  const depths = new Uint16Array(stripped.length);
+  let depth = 0;
+  for (let i = 0;i < stripped.length; i++) {
+    const char = stripped[i];
+    if (char === ")" || char === "]" || char === "}")
+      depth = depth > 0 ? depth - 1 : 0;
+    depths[i] = depth;
+    if (char === "(" || char === "[" || char === "{")
+      depth++;
+  }
+  return depths;
+}
+function declaresClientIdentifier(code, name) {
+  const stripped = stripCommentsAndLiterals(code), depths = bracketDepths(stripped), keyword = new RegExp(`(?:^|[^\\w$.])((?:const|let|var|function|class)\\s+${name}\\b)`, "g");
+  for (const match of stripped.matchAll(keyword)) {
+    const keywordIndex = (match.index ?? 0) + match[0].length - match[1].length;
+    if (depths[keywordIndex] === 0)
+      return !0;
+  }
+  for (const match of stripped.matchAll(/(?:const|let|var)\s*\{([^}]*)\}/g))
+    if (depths[match.index ?? 0] === 0 && extractDestructuredBindings(match[1], !0).has(name))
+      return !0;
+  for (const match of stripped.matchAll(/(?:const|let|var)\s*\[([^\]]*)\]/g))
+    if (depths[match.index ?? 0] === 0 && extractDestructuredBindings(match[1], !1).has(name))
+      return !0;
+  return !1;
+}
+function referencesIdentifier(searchable, name) {
+  return new RegExp(`(?<![.#\\w$])${name}(?![\\w$])`).test(searchable);
+}
+const CREDENTIAL_NAME = /token|secret|passw|apikey|api_key|privatekey|private_key|credential|webhook|bearer|jwt|signature/i, warnedBridgeKeys = new Set;
+function warnAboutBridgedValue(name, json) {
+  const credential = CREDENTIAL_NAME.test(name), oversized = json.length > 32768;
+  if (!credential && !oversized)
+    return;
+  if (warnedBridgeKeys.has(name))
+    return;
+  warnedBridgeKeys.add(name);
+  if (credential)
+    console.warn(`[stx] server\u2192client bridge is publishing "${name}" into the page body. If it holds a credential, rename it with a "__" prefix (never bridged) and pass only what the template needs. See stacksjs/stx#1831.`);
+  if (oversized)
+    console.warn(`[stx] server\u2192client bridge is publishing ${(json.length / 1024).toFixed(1)}KB under "${name}". Every byte ships in the HTML on each request; prefix the binding with "__" and project just the fields the client reads.`);
+}
+export function generateServerDataBridge(code, serverData) {
+  if (!serverData)
+    return "";
+  const searchable = stripCommentsAndLiterals(code), declaredPayload = serverData.__stxDeclaredPayload === !0, lines = [];
+  for (const [name, value] of Object.entries(serverData)) {
+    if (!/^[A-Za-z_$][\w$]*$/.test(name))
+      continue;
+    if (name.startsWith("__") || name.startsWith("$"))
+      continue;
+    if (!declaredPayload && !referencesIdentifier(searchable, name))
+      continue;
+    if (declaresClientIdentifier(code, name)) {
+      if (declaredPayload)
+        console.warn(`[stx] defineClientPayload declares "${name}", but this client block also declares "${name}" at the top level, so the server value is not published (emitting it would be a duplicate binding). Rename the local, or drop "${name}" from defineClientPayload.`);
+      continue;
+    }
+    let json;
+    try {
+      json = JSON.stringify(value);
+    } catch {
+      continue;
+    }
+    if (json === void 0)
+      continue;
+    warnAboutBridgedValue(name, json);
+    lines.push(`  var ${name} = ${json.replace(/</g, "\\u003c")};`);
+  }
+  if (lines.length === 0)
+    return "";
+  return `  // stx: server -> client data bridge (seeded from server scope)
+${lines.join(`
+`)}
+`;
+}
+const MOUSE_BUTTONS = {
+  left: 0,
+  middle: 1,
+  right: 2
+};
+function generateModifierChecks(modifiers) {
+  const checks = [];
+  if (modifiers.self)
+    checks.push("if ($event.target !== $el) return");
+  for (const key of modifiers.systemKeys)
+    checks.push(`if (!$event.${key}Key) return`);
+  if (modifiers.keys.length > 0) {
+    const keyChecks = modifiers.keys.map((k) => `$event.key === '${k}'`).join(" || ");
+    checks.push(`if (!(${keyChecks})) return`);
+  }
+  if (modifiers.mouse !== null) {
+    const button = MOUSE_BUTTONS[modifiers.mouse];
+    checks.push(`if ($event.button !== ${button}) return`);
+  }
+  if (modifiers.prevent)
+    checks.push("$event.preventDefault()");
+  if (modifiers.stop)
+    checks.push("$event.stopPropagation()");
+  return checks.join("; ");
+}
+function generateSingleEventBinding(binding, index) {
+  const { elementId, event, modifiers } = binding, handler = asInvocableStatement(binding.handler), checks = generateModifierChecks(modifiers), options = [];
+  if (modifiers.once)
+    options.push("once: true");
+  if (modifiers.capture)
+    options.push("capture: true");
+  if (modifiers.passive)
+    options.push("passive: true");
+  const optionsStr = options.length > 0 ? `, { ${options.join(", ")} }` : "";
+  let handlerBody = "";
+  if (checks)
+    handlerBody += `${checks}; `;
+  const escapedHandler = handler.replace(/\\/g, "\\\\").replace(/'/g, "\\'"), emitHelper = `var $emit = function(name, detail) {
+        $el.dispatchEvent(new CustomEvent(name, { detail: detail, bubbles: true, cancelable: true }))
+      };`;
+  function scopeAwareHandler(h) {
+    if (/\$emit\s*\(/.test(h))
+      return `${emitHelper}
+      ${h}`;
+    return `var scope = $el.closest('[data-stx-scope]');
+      if (scope && scope.__stx_execute) {
+        scope.__stx_execute('${escapedHandler}', $event, $el);
+      }
+else {
+        ${h}
+      }`;
+  }
+  if (modifiers.debounce !== null)
+    return `  ;(function() {
+    // eslint-disable-next-line pickier/no-unused-vars
+    var $el = document.getElementById('${elementId}')
+    if (!$el) return
+    var __timer
+    $el.addEventListener('${event}', function($event) {
+      ${checks ? checks + "; " : ""}clearTimeout(__timer)
+      __timer = setTimeout(function() { ${scopeAwareHandler(handler)} }, ${modifiers.debounce})
+    }${optionsStr})
+  })()`;
+  if (modifiers.throttle !== null)
+    return `  ;(function() {
+    // eslint-disable-next-line pickier/no-unused-vars
+    var $el = document.getElementById('${elementId}')
+    if (!$el) return
+    var __last = 0
+    $el.addEventListener('${event}', function($event) {
+      ${checks ? checks + "; " : ""}var __now = Date.now()
+      if (__now - __last >= ${modifiers.throttle}) {
+        __last = __now
+        ${scopeAwareHandler(handler)}
+      }
+    }${optionsStr})
+  })()`;
+  if (/\$emit\s*\(/.test(handler))
+    return `  var $el = document.getElementById('${elementId}')
+  if ($el) $el.addEventListener('${event}', function($event) {
+    ${handlerBody}${emitHelper}
+    ${handler}
+  }${optionsStr})`;
+  return `  var $el = document.getElementById('${elementId}')
+  if ($el) $el.addEventListener('${event}', function($event) {
+    ${handlerBody}var scope = $el.closest('[data-stx-scope]');
+    if (scope && scope.__stx_execute) {
+      scope.__stx_execute('${escapedHandler}', $event, $el);
+    }
+else {
+      ${handler}
+    }
+  }${optionsStr})`;
+}
+function generateInlineEventBindings(bindings) {
+  if (bindings.length === 0)
+    return "";
+  return `
+  // STX: auto-generated event bindings
+${bindings.map((b, i) => generateSingleEventBinding(b, i)).join(`
+`)}`;
+}
+function extractTopLevelDeclarations(code) {
+  const names = [], seen = new Set, cleaned = code.replace(/^\s*import\s+.*$/gm, "");
+  let depth = 0;
+  const len = cleaned.length;
+  let i = 0;
+  while (i < len) {
+    const ch = cleaned[i];
+    if (ch === "'" || ch === '"' || ch === "`") {
+      const quote = ch;
+      i++;
+      if (quote === "`") {
+        let tplDepth = 0;
+        while (i < len) {
+          if (cleaned[i] === "\\") {
+            i += 2;
+            continue;
+          }
+          if (cleaned[i] === "`" && tplDepth === 0) {
+            i++;
+            break;
+          }
+          if (cleaned[i] === "$" && cleaned[i + 1] === "{") {
+            tplDepth++;
+            i += 2;
+            continue;
+          }
+          if (cleaned[i] === "}" && tplDepth > 0) {
+            tplDepth--;
+            i++;
+            continue;
+          }
+          i++;
+        }
+      } else
+        while (i < len) {
+          if (cleaned[i] === "\\") {
+            i += 2;
+            continue;
+          }
+          if (cleaned[i] === quote) {
+            i++;
+            break;
+          }
+          i++;
+        }
+      continue;
+    }
+    if (ch === "/" && cleaned[i + 1] === "/") {
+      while (i < len && cleaned[i] !== `
+`)
+        i++;
+      continue;
+    }
+    if (ch === "/" && cleaned[i + 1] === "*") {
+      i += 2;
+      while (i < len - 1 && !(cleaned[i] === "*" && cleaned[i + 1] === "/"))
+        i++;
+      i += 2;
+      continue;
+    }
+    if (ch === "{") {
+      depth++;
+      i++;
+      continue;
+    }
+    if (ch === "}") {
+      depth--;
+      i++;
+      continue;
+    }
+    if (depth === 0) {
+      const rest = cleaned.slice(i), simpleMatch = rest.match(/^(?:const|let|var)\s+([a-zA-Z_$]\w*)\s*(?::[^=]*)?=/);
+      if (simpleMatch) {
+        const name = simpleMatch[1];
+        if (!name.startsWith("_") && !seen.has(name)) {
+          names.push(name);
+          seen.add(name);
+        }
+        i += simpleMatch[0].length;
+        continue;
+      }
+      const destructMatch = rest.match(/^(?:const|let|var)\s+\{([^}]+)\}\s*=/);
+      if (destructMatch) {
+        destructMatch[1].split(",").forEach((s) => {
+          const trimmed = s.trim(), colonIdx = trimmed.indexOf(":"), name = colonIdx >= 0 ? trimmed.slice(colonIdx + 1).trim().split(/[\s=]/)[0] : trimmed.split(/[\s=]/)[0];
+          if (name && !name.startsWith("_") && !seen.has(name)) {
+            names.push(name);
+            seen.add(name);
+          }
+        });
+        i += destructMatch[0].length;
+        continue;
+      }
+      const fnMatch = rest.match(/^(?:async\s+)?function\s+([a-zA-Z_$]\w*)/);
+      if (fnMatch) {
+        const name = fnMatch[1];
+        if (!name.startsWith("_") && !seen.has(name)) {
+          names.push(name);
+          seen.add(name);
+        }
+        i += fnMatch[0].length;
+        continue;
+      }
+    }
+    i++;
+  }
+  return names;
+}
+const JS_KEYWORDS = new Set([
+  "if",
+  "else",
+  "true",
+  "false",
+  "null",
+  "undefined",
+  "typeof",
+  "instanceof",
+  "in",
+  "of",
+  "new",
+  "this",
+  "return",
+  "void",
+  "delete",
+  "throw",
+  "switch",
+  "case",
+  "break",
+  "continue",
+  "for",
+  "while",
+  "do",
+  "try",
+  "catch",
+  "finally",
+  "const",
+  "let",
+  "var",
+  "function",
+  "class",
+  "import",
+  "export",
+  "default",
+  "async",
+  "await",
+  "yield",
+  "with",
+  "debugger",
+  "console",
+  "window",
+  "document",
+  "Math",
+  "JSON",
+  "Date",
+  "Array",
+  "Object",
+  "String",
+  "Number",
+  "Boolean",
+  "Symbol",
+  "Map",
+  "Set",
+  "Promise",
+  "Error",
+  "parseInt",
+  "parseFloat",
+  "isNaN",
+  "isFinite",
+  "encodeURIComponent",
+  "decodeURIComponent",
+  "setTimeout",
+  "setInterval",
+  "clearTimeout",
+  "clearInterval",
+  "fetch",
+  "alert",
+  "confirm",
+  "prompt",
+  "event"
+]);
+function extractTemplateReferences(templateHtml) {
+  const refs = new Set, identifierRegex = /[a-zA-Z_$][a-zA-Z0-9_$]*/g;
+  function addIdentifiers(expr) {
+    let match;
+    while ((match = identifierRegex.exec(expr)) !== null) {
+      const name = match[0];
+      if (!JS_KEYWORDS.has(name))
+        refs.add(name);
+    }
+  }
+  const mustacheRegex = /\{\{([\s\S]*?)\}\}/g;
+  let m;
+  while ((m = mustacheRegex.exec(templateHtml)) !== null)
+    addIdentifiers(m[1]);
+  const colonBindRegex = /:[a-z][\w.-]*\s*=\s*"([^"]*)"/gi;
+  while ((m = colonBindRegex.exec(templateHtml)) !== null)
+    addIdentifiers(m[1]);
+  const colonBindSingleRegex = /:[a-z][\w.-]*\s*=\s*'([^']*)'/gi;
+  while ((m = colonBindSingleRegex.exec(templateHtml)) !== null)
+    addIdentifiers(m[1]);
+  const eventRegex = /@[a-z]+(?:\.[a-z]+)*\s*=\s*"([^"]*)"/gi;
+  while ((m = eventRegex.exec(templateHtml)) !== null)
+    addIdentifiers(m[1]);
+  const eventSingleRegex = /@[a-z]+(?:\.[a-z]+)*\s*=\s*'([^']*)'/gi;
+  while ((m = eventSingleRegex.exec(templateHtml)) !== null)
+    addIdentifiers(m[1]);
+  const modelRegex = /@model\s*=\s*["']([^"']*)["']/gi;
+  while ((m = modelRegex.exec(templateHtml)) !== null)
+    addIdentifiers(m[1]);
+  const forRegex = /@for\s*=\s*["'][^"']*\bin\s+([^"']+)["']/gi;
+  while ((m = forRegex.exec(templateHtml)) !== null)
+    addIdentifiers(m[1]);
+  return refs;
+}
+export async function processClientScript(scriptContent, options = {}) {
+  let code = scriptContent, autoImportCode = "", wasBundled = !1, bundledBrowserImports = [];
+  const cssExtraction = extractAndStripCssImports(code, {
+    filePath: options.filePath,
+    projectRoot: options.projectRoot
+  });
+  code = cssExtraction.code;
+  const vendorStyleTags = renderVendorStyleTags(cssExtraction.styles), browserCoreImports = injectBrowserCoreAutoImports(code);
+  code = browserCoreImports.code;
+  bundledBrowserImports = [...browserCoreImports.imports, ...browserCoreImports.models];
+  const { hasUserImports, bundleClientScript } = await importOnce("stx/client-script-bundler", () => import("./client-script-bundler.js"));
+  if (hasUserImports(code)) {
+    code = await bundleClientScript(code, options.filePath || "", {
+      projectRoot: options.projectRoot,
+      minify: options.production
+    });
+    wasBundled = !0;
+  }
+  if (options.autoImports !== !1) {
+    const autoImportResult = transformAutoImports(code);
+    code = autoImportResult.code;
+    autoImportCode = generateAutoImportDestructuring(autoImportResult.stxImports, autoImportResult.browserImports.filter((name) => !bundledBrowserImports.includes(name)));
+  }
+  autoImportCode = `${generateServerDataBridge(code, options.serverData)}${autoImportCode}`;
+  code = transformStoreImports(code);
+  if (!wasBundled && shouldTranspileTypeScript(options.attrs || ""))
+    code = transpileTypeScript(code);
+  const eventCode = generateInlineEventBindings(options.eventBindings || []), attrs = (options.attrs || "").trim();
+  if (/\btype\s*=\s*["']module["']/i.test(attrs)) {
+    const extraAttrs = attrs.replace(/\btype\s*=\s*["']module["']/i, "").trim(), attrStr = `type="module" data-stx-scoped${extraAttrs ? ` ${extraAttrs}` : ""}`;
+    return `${vendorStyleTags}<script ${attrStr}>
+${escapeScriptBody(`${autoImportCode}${code}
+${eventCode}`)}
+</script>`;
+  }
+  const usesSignals = usesReactiveRuntime(scriptContent), isSfcWrapped = /function __stx_setup_/.test(code), alreadyMounts = /\bstx\.mount\s*\(|\bstx\.mountEl\s*\(/.test(scriptContent);
+  function wrapInMount(declarations) {
+    const returnStmt = declarations.length > 0 ? `
+  return { ${declarations.join(", ")} };` : "";
+    return `${vendorStyleTags}<script data-stx-scoped data-stx-run="always">
+window.stx.mount(function() {
+  'use strict';
+${escapeScriptBody(`${autoImportCode}${code}
+${eventCode}${returnStmt}`)}
+})</script>`;
+  }
+  if (!alreadyMounts && !isSfcWrapped) {
+    if (usesSignals)
+      return wrapInMount(extractTopLevelDeclarations(scriptContent));
+    if (options.templateContent) {
+      const declarations = extractTopLevelDeclarations(scriptContent);
+      if (declarations.length > 0) {
+        const templateRefs = extractTemplateReferences(options.templateContent);
+        if (declarations.some((name) => templateRefs.has(name)))
+          return wrapInMount(declarations);
+      }
+    }
+  }
+  return `${vendorStyleTags}<script data-stx-scoped data-stx-run="always">
+;(function() {
+  'use strict';
+${escapeScriptBody(`${autoImportCode}${code}
+${eventCode}`)}
+})()</script>`;
+}