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

package/dist/stx-virtual-ts.js

@@ -0,0 +1,670 @@
+import { BROWSER_CORE_IMPORTS } from "./browser-core-imports.js";
+import path from "node:path";
+import { stripCommentsAndLiterals } from "./strip-literals.js";
+import { STX_RUNTIME_GLOBALS } from "./runtime-globals.js";
+const SCRIPT_RE = /<script(\s[^>]*)?>([\s\S]*?)<\/script>/gi;
+function blankCommentContents(source) {
+  const blank = (match) => match.replace(/[^\n]/g, " ");
+  return source.replace(/<!--[\s\S]*?-->/g, blank).replace(/\{\{--[\s\S]*?--\}\}/g, blank);
+}
+export function extractScriptBlocks(source) {
+  const blocks = [], scannable = blankCommentContents(source);
+  SCRIPT_RE.lastIndex = 0;
+  let match;
+  while ((match = SCRIPT_RE.exec(scannable)) !== null) {
+    const attrs = (match[1] || "").trim(), openLength = (match[0].match(/^<script(?:\s[^>]*)?>/i)?.[0] ?? "<script>").length, closeLength = (match[0].match(/<\/script\s*>$/i)?.[0] ?? "</script>").length, bodyStart = match.index + openLength, bodyEnd = match.index + match[0].length - closeLength, body = source.slice(bodyStart, bodyEnd);
+    if (/\bsrc\s*=/.test(attrs))
+      continue;
+    const typeMatch = attrs.match(/\btype\s*=\s*["']([^"']+)["']/i);
+    if (typeMatch && !/^(?:module|text\/(?:javascript|typescript))$/i.test(typeMatch[1]))
+      continue;
+    const kind = /\bserver\b/.test(attrs) ? "server" : /\bclient\b/.test(attrs) ? "client" : "plain", startLine = lineAt(source, bodyStart);
+    blocks.push({ kind, code: body, startLine, attrs });
+  }
+  return blocks;
+}
+function lineAt(source, offset) {
+  let line = 1;
+  for (let i = 0;i < offset && i < source.length; i++)
+    if (source.charCodeAt(i) === 10)
+      line++;
+  return line;
+}
+function columnAt(source, offset) {
+  const lineStart = source.lastIndexOf(`
+`, offset - 1) + 1;
+  return offset - lineStart + 1;
+}
+export function maskNonTemplateRegions(source) {
+  const chars = source.split(""), blank = (start, end) => {
+    for (let i = start;i < end && i < chars.length; i++)
+      if (chars[i] !== `
+`)
+        chars[i] = " ";
+  }, regions = [
+    /<script(?:\s[^>]*)?>[\s\S]*?<\/script>/gi,
+    /<style(?:\s[^>]*)?>[\s\S]*?<\/style>/gi,
+    /<!--[\s\S]*?-->/g,
+    /\{\{--[\s\S]*?--\}\}/g,
+    /@verbatim\b[\s\S]*?@endverbatim\b/g
+  ];
+  for (const re of regions) {
+    re.lastIndex = 0;
+    let m;
+    while ((m = re.exec(source)) !== null)
+      blank(m.index, m.index + m[0].length);
+  }
+  return chars.join("");
+}
+export function stripFilterChain(expression) {
+  let depth = 0, quote = "";
+  for (let i = 0;i < expression.length; i++) {
+    const ch = expression[i];
+    if (quote) {
+      if (ch === "\\") {
+        i++;
+        continue;
+      }
+      if (ch === quote)
+        quote = "";
+      continue;
+    }
+    if (ch === '"' || ch === "'" || ch === "`") {
+      quote = ch;
+      continue;
+    }
+    if (ch === "(" || ch === "[" || ch === "{") {
+      depth++;
+      continue;
+    }
+    if (ch === ")" || ch === "]" || ch === "}") {
+      depth--;
+      continue;
+    }
+    if (ch === "|" && depth === 0) {
+      if (expression[i + 1] === "|") {
+        i++;
+        continue;
+      }
+      if (expression[i - 1] === "|")
+        continue;
+      return expression.slice(0, i);
+    }
+  }
+  return expression;
+}
+const FOR_ATTRS = new Set([":for", "x-for", "v-for"]), DIRECTIVE_ATTR_RE = /(?:^|\s)((?::|x-|v-|@)[\w.:-]+)\s*=\s*(["'])([\s\S]*?)\2/g;
+export const INTERPOLATION_PLACEHOLDER = "__stx_interpolated", ELEMENT_HELPER = "__StxElement", UNWRAP_HELPER = "__StxTemplateValue";
+const UNWRAP_HELPER_DECL = `type ${UNWRAP_HELPER}<T> = T extends { readonly _isSignal: true } | { readonly _isDerived: true } ? (T extends () => infer V ? T & V : T) : T`;
+export function substituteInterpolations(value) {
+  return value.replace(/\{\{[\s\S]*?\}\}/g, INTERPOLATION_PLACEHOLDER).replace(/\{!![\s\S]*?!!\}/g, INTERPOLATION_PLACEHOLDER);
+}
+export function substituteInterpolationsInPlace(code) {
+  return code.replace(/\{\{[\s\S]*?\}\}|\{!![\s\S]*?!!\}/g, (match) => {
+    const newlines = match.split(`
+`).length - 1, width = match.length - newlines;
+    return `0${" ".repeat(Math.max(0, width - 1))}${`
+`.repeat(newlines)}`;
+  });
+}
+const SCRIPT_BODY_DIRECTIVES = [
+  "foreach",
+  "endforeach",
+  "forelse",
+  "endforelse",
+  "for",
+  "endfor",
+  "while",
+  "endwhile",
+  "empty",
+  "if",
+  "elseif",
+  "else",
+  "endif",
+  "unless",
+  "endunless",
+  "isset",
+  "endisset",
+  "switch",
+  "case",
+  "default",
+  "endswitch",
+  "auth",
+  "endauth",
+  "guest",
+  "endguest",
+  "env",
+  "endenv",
+  "once",
+  "endonce",
+  "break",
+  "continue"
+], SCRIPT_BODY_DIRECTIVE_RE = new RegExp(String.raw`^[ \t]*@(?:${SCRIPT_BODY_DIRECTIVES.join("|")})\b[ \t]*(\([^\n)]*\))?[ \t]*$`, "gm");
+export function blankScriptDirectives(code) {
+  return code.replace(SCRIPT_BODY_DIRECTIVE_RE, (match) => match.replace(/[^\n]/g, " "));
+}
+const NON_EXPRESSION_ATTRS = new Set([
+  "x-cloak",
+  "x-ref",
+  "x-transition",
+  "x-teleport",
+  "v-slot",
+  "x-hydrate",
+  ":key",
+  "x-tooltip",
+  "x-tooltip-position"
+]);
+export function extractTemplateExpressions(source) {
+  const masked = maskNonTemplateRegions(source), found = [], interpolation = /(@?)\{\{([\s\S]*?)\}\}|(@?)\{!!([\s\S]*?)!!\}/g;
+  let m;
+  while ((m = interpolation.exec(masked)) !== null) {
+    if (m[1] || m[3])
+      continue;
+    const raw = m[2] ?? m[4] ?? "", openLength = m[2] !== void 0 ? 2 : 3, code = stripFilterChain(raw);
+    if (!code.trim())
+      continue;
+    const offset = m.index + openLength + (code.length - code.trimStart().length);
+    found.push({
+      code: code.trim(),
+      line: lineAt(masked, offset),
+      column: columnAt(masked, offset),
+      offset,
+      kind: "interpolation"
+    });
+  }
+  DIRECTIVE_ATTR_RE.lastIndex = 0;
+  while ((m = DIRECTIVE_ATTR_RE.exec(masked)) !== null) {
+    const name = m[1], value = m[3] ?? "", base = name.replace(/\..*$/, "").replace(/^([^:].*?):.*$/, "$1");
+    if (NON_EXPRESSION_ATTRS.has(base) || NON_EXPRESSION_ATTRS.has(name))
+      continue;
+    if (!value.trim())
+      continue;
+    const offset = m.index + m[0].indexOf(m[2], m[0].indexOf(name) + name.length) + 1;
+    if (FOR_ATTRS.has(base)) {
+      const inMatch = value.match(/\s+(?:in|of)\s+/);
+      if (!inMatch || inMatch.index === void 0)
+        continue;
+      const iterable = value.slice(inMatch.index + inMatch[0].length), iterableStart = inMatch.index + inMatch[0].length + (iterable.length - iterable.trimStart().length);
+      found.push({
+        code: substituteInterpolations(iterable.trim()),
+        line: lineAt(masked, offset + iterableStart),
+        column: columnAt(masked, offset + iterableStart),
+        offset: offset + iterableStart,
+        kind: "directive",
+        attribute: base
+      });
+      continue;
+    }
+    const lead = value.length - value.trimStart().length;
+    found.push({
+      code: substituteInterpolations(value.trim()),
+      line: lineAt(masked, offset + lead),
+      column: columnAt(masked, offset + lead),
+      offset: offset + lead,
+      kind: "directive",
+      attribute: base
+    });
+  }
+  found.sort((a, b) => a.line - b.line || a.column - b.column);
+  return found;
+}
+const MAX_DIRECTIVE_HEAD = 2000;
+function balancedGroup(source, openIndex) {
+  let depth = 0;
+  const limit = Math.min(source.length, openIndex + MAX_DIRECTIVE_HEAD);
+  for (let index = openIndex;index < limit; index++) {
+    const char = source[index];
+    if (char === "(")
+      depth++;
+    else if (char === ")") {
+      depth--;
+      if (depth === 0)
+        return source.slice(openIndex + 1, index);
+    }
+  }
+  return null;
+}
+export function collectTemplateBindings(source) {
+  const bindings = new Map, add = (raw, iterable) => {
+    const parts = raw.split(/[,[\]{}()\s]+/).filter(Boolean);
+    for (const part of parts) {
+      const name = part.replace(/^\.\.\./, "").trim();
+      if (!/^\$?[A-Z_$][\w$]*$/i.test(name))
+        continue;
+      const typed = parts.length === 1 ? iterable : void 0, existing = bindings.get(name);
+      if (!existing)
+        bindings.set(name, { name, iterable: typed });
+      else if (existing.iterable !== typed)
+        existing.iterable = void 0;
+    }
+  }, IDENTIFIER = /^\$?[A-Z_$][\w$]*$/i, iterableOf = (raw) => {
+    const trimmed = raw.trim();
+    return IDENTIFIER.test(trimmed) ? trimmed : void 0;
+  };
+  for (const m of source.matchAll(/@for(?:each|else)\s*\(/g)) {
+    const head = balancedGroup(source, m.index + m[0].length - 1);
+    if (head === null)
+      continue;
+    const asMatch = head.match(/^([\s\S]*?)\bas\b([\s\S]*)$/);
+    if (!asMatch)
+      continue;
+    add(asMatch[2].replace(/=>/g, " "), iterableOf(asMatch[1]));
+  }
+  for (const m of source.matchAll(/@for\s*\(\s*(?:let|const|var)\s+([\w$]+)/g))
+    add(m[1]);
+  const masked = maskNonTemplateRegions(source);
+  DIRECTIVE_ATTR_RE.lastIndex = 0;
+  let m;
+  while ((m = DIRECTIVE_ATTR_RE.exec(masked)) !== null) {
+    const base = m[1].replace(/\..*$/, "");
+    if (!FOR_ATTRS.has(base))
+      continue;
+    const inMatch = m[3].match(/\s+(?:in|of)\s+/);
+    if (!inMatch || inMatch.index === void 0)
+      continue;
+    add(m[3].slice(0, inMatch.index), iterableOf(m[3].slice(inMatch.index + inMatch[0].length)));
+  }
+  for (const block of source.matchAll(/@(?:php|js|ts)\b([\s\S]*?)@end(?:php|js|ts)\b/g))
+    for (const decl of block[1].matchAll(/\b(?:const|let|var|function|class)\s+([\w$]+)/g))
+      add(decl[1]);
+  return [...bindings.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+export function collectBlockDeclarations(code) {
+  const names = new Set;
+  for (const m of code.matchAll(/^\s*(?:export\s+)?(?:const|let|var)\s+([\w$]+)/gm))
+    names.add(m[1]);
+  for (const m of code.matchAll(/^\s*(?:export\s+)?(?:async\s+)?function\s*\*?\s*([\w$]+)/gm))
+    names.add(m[1]);
+  for (const m of code.matchAll(/^\s*(?:export\s+)?class\s+([\w$]+)/gm))
+    names.add(m[1]);
+  for (const m of code.matchAll(/^\s*(?:export\s+)?(?:const|let|var)\s*[[{]([^\]}]*)[\]}]/gm))
+    for (const part of m[1].split(",")) {
+      const name = part.split(":").pop().split("=")[0].replace(/^\.\.\./, "").trim();
+      if (/^[A-Z_$][\w$]*$/i.test(name))
+        names.add(name);
+    }
+  return [...names].sort();
+}
+const IMPORT_LINE_RE = /^\s*import\s[\s\S]*?(?:$|;)/;
+export function runtimeGlobalDeclarations() {
+  return [
+    "declare var window: any",
+    ...STX_RUNTIME_GLOBALS.map((name) => `declare var ${name}: any`)
+  ].join(`
+`);
+}
+export const STX_SERVER_CONTEXT = [
+  "params",
+  "query",
+  "cookies",
+  "host",
+  "ip",
+  "setResponseStatus",
+  "setResponseHeader",
+  "notFound",
+  "request",
+  "url",
+  "definePageMeta",
+  "defineClientPayload",
+  "defineStore",
+  "props",
+  "$props"
+];
+export function serverContextDeclarations() {
+  return STX_SERVER_CONTEXT.map((name) => `declare var ${name}: any`).join(`
+`);
+}
+export function extractClientPayloadNames(serverCode) {
+  const call = /\bdefineClientPayload\s*\(\s*\{([\s\S]*?)\}\s*\)/g;
+  let match, found = !1;
+  const names = new Set, searchable = stripCommentsAndLiterals(serverCode);
+  while ((match = call.exec(searchable)) !== null) {
+    found = !0;
+    for (const entry of splitPayloadEntries(match[1])) {
+      const name = entry.split(":")[0].trim();
+      if (/^[A-Za-z_$][\w$]*$/.test(name))
+        names.add(name);
+    }
+  }
+  return found ? [...names] : null;
+}
+function splitPayloadEntries(body) {
+  const entries = [];
+  let depth = 0, current = "";
+  for (const char of body) {
+    if (char === "," && depth === 0) {
+      entries.push(current);
+      current = "";
+      continue;
+    }
+    if (char === "(" || char === "[" || char === "{")
+      depth++;
+    else if (char === ")" || char === "]" || char === "}")
+      depth--;
+    current += char;
+  }
+  entries.push(current);
+  return entries.filter((entry) => entry.trim().length > 0);
+}
+export function splitTopLevelImports(code) {
+  const importLine = /^[ \t]*import\b[\s\S]*?(?:from\s*['"][^'"]*['"]|['"][^'"]*['"])[ \t]*;?[ \t]*$/gm, imports = [], body = code.replace(importLine, (statement) => {
+    imports.push(statement.trim());
+    return statement.split(`
+`).map(() => "").join(`
+`);
+  });
+  return { imports: imports.join(`
+`), body };
+}
+export function extractTypeDeclarations(code) {
+  const searchable = stripCommentsAndLiterals(code), depthAt = Array(searchable.length);
+  let depth = 0;
+  for (let i = 0;i < searchable.length; i++) {
+    const c = searchable[i];
+    if (c === "}" || c === ")" || c === "]")
+      depth = Math.max(0, depth - 1);
+    depthAt[i] = depth;
+    if (c === "{" || c === "(" || c === "[")
+      depth++;
+  }
+  const found = [], start = /^[ \t]*(?:export[ \t]+)?(interface|type)[ \t]+([A-Za-z_$][\w$]*)/gm;
+  let match;
+  while ((match = start.exec(searchable)) !== null) {
+    if (depthAt[match.index] !== 0)
+      continue;
+    const kind = match[1], name = match[2];
+    let end;
+    if (kind === "interface") {
+      const open = searchable.indexOf("{", match.index);
+      if (open === -1)
+        continue;
+      let depth = 0;
+      end = -1;
+      for (let i = open;i < searchable.length; i++)
+        if (searchable[i] === "{")
+          depth++;
+        else if (searchable[i] === "}" && --depth === 0) {
+          end = i + 1;
+          break;
+        }
+      if (end === -1)
+        continue;
+    } else {
+      let depth = 0;
+      end = searchable.length;
+      for (let i = searchable.indexOf("=", match.index) + 1;i < searchable.length; i++) {
+        const c = searchable[i];
+        if (c === "{" || c === "[" || c === "(" || c === "<")
+          depth++;
+        else if (c === "}" || c === "]" || c === ")" || c === ">")
+          depth--;
+        else if (depth <= 0 && (c === ";" || c === `
+` && !/[=|&,<([{]\s*$/.test(searchable.slice(Math.max(0, i - 40), i)))) {
+          end = c === ";" ? i + 1 : i;
+          break;
+        }
+      }
+    }
+    found.push({ name, text: code.slice(match.index, end).replace(/^[ \t]*export[ \t]+/, "") });
+    start.lastIndex = end;
+  }
+  return found;
+}
+function declaredTypeNames(code) {
+  return new Set(extractTypeDeclarations(code).map((entry) => entry.name));
+}
+export function clientPayloadDeclarations(serverCode, clientCode = "") {
+  const published = extractClientPayloadNames(serverCode), ownTypes = declaredTypeNames(clientCode), serverTypes = extractTypeDeclarations(serverCode).filter((entry) => !ownTypes.has(entry.name)).map((entry) => entry.text);
+  if (!published) {
+    const scraped = collectBlockDeclarations(serverCode);
+    if (scraped.length === 0 && serverTypes.length === 0)
+      return "";
+    return [
+      "",
+      `// ${SCRAPED_COMMENT}`,
+      ...serverTypes,
+      ...scraped.map((name) => `declare var ${name}: any`)
+    ].join(`
+`);
+  }
+  if (published.length === 0)
+    return serverTypes.length > 0 ? ["", `// ${PAYLOAD_COMMENT}`, ...serverTypes].join(`
+`) : "";
+  const { imports, body } = splitTopLevelImports(serverCode), scopeBody = body.replace(/^[ \t]*export[ \t]+(?=(?:const|let|var|function|async|class)\b)/gm, ""), parts = [
+    "",
+    `// ${PAYLOAD_COMMENT}`
+  ];
+  if (imports)
+    parts.push(imports);
+  parts.push(...serverTypes);
+  parts.push(`async function ${PAYLOAD_SCOPE}() {`, scopeBody, `  return { ${published.join(", ")} }`, "}", `type ${PAYLOAD_TYPE} = Awaited<ReturnType<typeof ${PAYLOAD_SCOPE}>>`, ...published.map((name) => `declare var ${name}: ${PAYLOAD_TYPE}[${JSON.stringify(name)}]`));
+  return parts.join(`
+`);
+}
+export function collectTopLevelDeclarations(code) {
+  const chars = stripCommentsAndLiterals(code).split("");
+  let depth = 0;
+  for (let i = 0;i < chars.length; i++) {
+    const c = chars[i];
+    if (c === "{" || c === "(" || c === "[") {
+      depth++;
+      continue;
+    }
+    if (c === "}" || c === ")" || c === "]") {
+      depth = Math.max(0, depth - 1);
+      continue;
+    }
+    if (depth > 0 && c !== `
+`)
+      chars[i] = " ";
+  }
+  return collectBlockDeclarations(chars.join(""));
+}
+export function scrapedBridgeNames(serverCode, clientCode) {
+  if (extractClientPayloadNames(serverCode) !== null)
+    return [];
+  const searchable = stripCommentsAndLiterals(clientCode), provided = new Set(STX_RUNTIME_GLOBALS);
+  return collectTopLevelDeclarations(serverCode).filter((name) => {
+    if (provided.has(name))
+      return !1;
+    if (collectBlockDeclarations(clientCode).includes(name))
+      return !1;
+    return new RegExp(`(?<![.#\\w$])${name}(?![\\w$])`).test(searchable);
+  });
+}
+export const PAYLOAD_COMMENT = "stx: types for the declared client payload (#1868)", SCRAPED_COMMENT = "stx: untyped bridge names \u2014 declare a defineClientPayload to check these (#1868)";
+const PAYLOAD_SCOPE = "__stxServerScope", PAYLOAD_TYPE = "__StxClientPayload", PAYLOAD_NAMESPACE = "__StxServerBlock";
+export const STX_TEMPLATE_GLOBALS = [
+  "$env",
+  "$user",
+  "$slot",
+  "$slots",
+  "$attrs",
+  "$props",
+  "$page",
+  "$route",
+  "$loop",
+  "loop",
+  "$errors",
+  "$csrf",
+  "props",
+  "slot"
+];
+export function crossScopeCollisions(blocks) {
+  const server = new Set, client = new Set;
+  for (const block of blocks) {
+    const target = block.kind === "server" ? server : client;
+    for (const name of collectBlockDeclarations(block.code))
+      target.add(name);
+  }
+  return [...server].filter((name) => client.has(name)).sort();
+}
+const DIRECT_ASSIGNMENT_RE = /^\s*[A-Z_$][\w$]*\s*=[^=]/i;
+export function guardChainAt(source, offset) {
+  const directive = /@(if|unless|elseif|else|endif|endunless)\b\s*(\()?/g, stack = [];
+  let match;
+  while ((match = directive.exec(source)) !== null) {
+    if (match.index >= offset)
+      break;
+    const name = match[1];
+    if (name === "endif" || name === "endunless") {
+      stack.pop();
+      continue;
+    }
+    let condition = "";
+    if (match[2] === "(") {
+      let depth = 0, index = match.index + match[0].length - 1;
+      const start = index + 1;
+      for (;index < source.length; index++) {
+        const char = source[index];
+        if (char === "(")
+          depth++;
+        else if (char === ")") {
+          depth--;
+          if (depth === 0)
+            break;
+        }
+      }
+      condition = source.slice(start, index).trim();
+      directive.lastIndex = index + 1;
+    }
+    if (name === "if")
+      stack.push({ seen: [], current: condition });
+    else if (name === "unless")
+      stack.push({ seen: [], current: `!(${condition})` });
+    else if (name === "elseif" || name === "else") {
+      const open = stack[stack.length - 1];
+      if (!open)
+        continue;
+      if (open.current)
+        open.seen.push(open.current);
+      open.current = name === "elseif" ? condition : null;
+    }
+  }
+  return stack.flatMap((entry) => [
+    ...entry.seen.map((seen) => `!(${seen})`),
+    ...entry.current ? [entry.current] : []
+  ]).filter(Boolean);
+}
+export function expressionStatement(expression) {
+  const code = expression.code.trim();
+  if (!code)
+    return null;
+  if (expression.attribute?.startsWith("@")) {
+    if (DIRECT_ASSIGNMENT_RE.test(code))
+      return null;
+    const prefix = ";(($event: any): void => { ";
+    return { text: `${prefix}${code} });`, prefixLength: prefix.length };
+  }
+  const prefix = ";void ((";
+  return { text: `${prefix}${code}));`, prefixLength: prefix.length };
+}
+const RELATIVE_SPECIFIER_RE = /(\bfrom\s*|\bimport\s*\(\s*|\bimport\s+)(['"])(\.{1,2}\/[^'"\n]*)\2/g;
+export function absolutizeRelativeSpecifiers(code, originDir) {
+  if (!originDir)
+    return code;
+  return code.replace(RELATIVE_SPECIFIER_RE, (_whole, prefix, quote, specifier) => {
+    const absolute = path.resolve(originDir, specifier).replace(/\\/g, "/");
+    return `${prefix}${quote}${absolute}${quote}`;
+  });
+}
+export function buildVirtualTypeScript(source, options = {}) {
+  const blocks = extractScriptBlocks(source), sourceLines = source.split(`
+`), lines = Array.from({ length: sourceLines.length }, () => ""), lineMap = new Map;
+  for (const block of blocks)
+    absolutizeRelativeSpecifiers(block.code, options.originDir ?? "").split(`
+`).forEach((text, i) => {
+      const index = block.startLine - 1 + i;
+      if (index < lines.length)
+        lines[index] = text;
+    });
+  const append = (text, origin) => {
+    lines.push(text);
+    if (origin)
+      lineMap.set(lines.length, origin);
+  };
+  if (options.globals !== !1) {
+    append("");
+    if (options.runtimeGlobals !== !1)
+      for (const decl of runtimeGlobalDeclarations().split(`
+`))
+        append(decl);
+    for (const decl of serverContextDeclarations().split(`
+`))
+      append(decl);
+    for (const name of BROWSER_CORE_IMPORTS)
+      append(`declare var ${name}: any`);
+    for (const name of STX_TEMPLATE_GLOBALS)
+      append(`declare var ${name}: any`);
+    append(`declare var ${INTERPOLATION_PLACEHOLDER}: any`);
+    const declared = new Set(blocks.flatMap((block) => collectBlockDeclarations(block.code)));
+    append(`type ${ELEMENT_HELPER}<T> = T extends readonly (infer E)[] ? E : T extends Iterable<infer E2> ? E2 : any`);
+    for (const binding of collectTemplateBindings(source)) {
+      if (declared.has(binding.name))
+        continue;
+      const type = binding.iterable && declared.has(binding.iterable) ? `${ELEMENT_HELPER}<typeof ${binding.iterable}>` : "any";
+      append(`declare var ${binding.name}: ${type}`);
+    }
+  }
+  if (options.templateExpressions !== !1) {
+    const statements = extractTemplateExpressions(source).map((expression) => ({ expression, statement: expressionStatement(expression) })).filter((entry) => entry.statement !== null);
+    if (statements.length > 0) {
+      const maskedSource = maskNonTemplateRegions(source), shadowed = [...new Set(blocks.flatMap((block) => collectBlockDeclarations(block.code)))].filter((name) => /^[A-Z_$][\w$]*$/i.test(name));
+      let indent = 0;
+      if (shadowed.length > 0) {
+        append(UNWRAP_HELPER_DECL);
+        for (const name of shadowed)
+          append(`type __StxT_${name} = ${UNWRAP_HELPER}<typeof ${name}>`);
+        append(`;((${shadowed.map((name) => `${name}: __StxT_${name}`).join(", ")}) => {`);
+        indent = 1;
+      }
+      for (const { expression, statement } of statements) {
+        const pad = "  ".repeat(indent), guards = expression.offset === void 0 ? [] : guardChainAt(maskedSource, expression.offset), guardPrefix = guards.length > 0 ? `${guards.map((condition) => `if (${condition}) `).join("")}{ ` : "", guardSuffix = guards.length > 0 ? " }" : "";
+        append(pad + guardPrefix + statement.text + guardSuffix, {
+          line: expression.line,
+          column: expression.column,
+          expression,
+          prefixLength: statement.prefixLength + pad.length + guardPrefix.length
+        });
+      }
+      if (indent > 0)
+        append("});");
+    }
+  }
+  append("export {}");
+  return { text: lines.join(`
+`), lineMap, sourceLineCount: sourceLines.length };
+}
+export function lineStarts(text) {
+  const starts = [0];
+  for (let i = 0;i < text.length; i++)
+    if (text.charCodeAt(i) === 10)
+      starts.push(i + 1);
+  return starts;
+}
+export function offsetToPosition(starts, offset) {
+  let low = 0, high = starts.length - 1;
+  while (low < high) {
+    const mid = Math.ceil((low + high) / 2);
+    if (starts[mid] <= offset)
+      low = mid;
+    else
+      high = mid - 1;
+  }
+  return { line: low + 1, column: offset - starts[low] + 1 };
+}
+export function positionToOffset(starts, line, column) {
+  const index = Math.min(Math.max(line, 1), starts.length) - 1, next = index + 1 < starts.length ? starts[index + 1] - 1 : Number.MAX_SAFE_INTEGER;
+  return Math.min(starts[index] + Math.max(column, 1) - 1, next);
+}
+export function resolvePosition(virtual, line, column) {
+  const mapped = virtual.lineMap.get(line);
+  if (!mapped)
+    return line <= virtual.sourceLineCount ? { line, column } : null;
+  const within = Math.max(0, column - 1 - (mapped.prefixLength ?? 0));
+  return {
+    line: mapped.line,
+    column: mapped.column + within,
+    expression: mapped.expression
+  };
+}