@vobs/compiler 1.1.0 → 1.2.1

package/dist/compile.cjs

@@ -0,0 +1,1149 @@
+'use strict';
+
+var ts = require('typescript');
+var error = require('@vobs/runtime/error');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var ts__default = /*#__PURE__*/_interopDefault(ts);
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function createCompiler(options = {}) {
+  const basePlugins = options.plugins ?? [];
+  return {
+    compile(code, overrides = {}) {
+      return compile(code, {
+        ...overrides,
+        plugins: [...basePlugins, ...overrides.plugins ?? []]
+      });
+    },
+    compileWithSourceMap(code, overrides = {}) {
+      return compileWithSourceMap(code, {
+        ...overrides,
+        plugins: [...basePlugins, ...overrides.plugins ?? []]
+      });
+    }
+  };
+}
+__name(createCompiler, "createCompiler");
+function compile(code, options = {}) {
+  const result = compileWithSourceMap(code, options);
+  const firstError = result.diagnostics.find((diagnostic) => diagnostic.severity === "error");
+  if (firstError) {
+    throw new error.VobsError({
+      code: firstError.code,
+      layer: "compiler",
+      message: firstError.message,
+      location: firstError.location,
+      codeFrame: firstError.codeFrame,
+      fix: firstError.fix
+    });
+  }
+  return result.code;
+}
+__name(compile, "compile");
+function compileWithSourceMap(code, options = {}) {
+  const filename = options.filename ?? "component.tsx";
+  let sourceFile = ts__default.default.createSourceFile(
+    filename,
+    code,
+    ts__default.default.ScriptTarget.Latest,
+    true,
+    ts__default.default.ScriptKind.TSX
+  );
+  const state = {
+    generatedId: 0,
+    filename,
+    sourceFile,
+    statementSources: /* @__PURE__ */ new WeakMap(),
+    takenNames: collectDeclaredNames(sourceFile),
+    helperAliases: /* @__PURE__ */ new Map(),
+    templates: /* @__PURE__ */ new Map(),
+    sourceLocation: options.sourceLocation ?? true,
+    stateAliases: collectStateAliases(sourceFile),
+    localBindings: collectLocallyDeclaredNames(sourceFile),
+    diagnostics: []
+  };
+  const cleanFilename = filename.split(/[?#]/u, 1)[0] || filename;
+  const diagnostics = ts__default.default.transpileModule(code, {
+    // Vite appends query strings (for example `?direct`) to module IDs;
+    // strip them so TypeScript still recognizes TSX syntax for diagnostics.
+    fileName: cleanFilename,
+    reportDiagnostics: true,
+    compilerOptions: { jsx: ts__default.default.JsxEmit.Preserve, target: ts__default.default.ScriptTarget.Latest }
+  }).diagnostics?.map((diagnostic) => toCompilerDiagnostic(diagnostic, sourceFile, cleanFilename)) ?? [];
+  const plugins = options.plugins ?? [];
+  validatePlugins(plugins);
+  const context = {
+    filename,
+    factory: ts__default.default.factory,
+    addRuntimeImport(name) {
+      resolveHelperName(state, name);
+    },
+    helperRef: /* @__PURE__ */ __name((name) => helperRef(state, name), "helperRef")
+  };
+  for (const plugin of plugins) plugin.analyze?.(sourceFile, context);
+  for (const plugin of plugins) {
+    sourceFile = plugin.transform?.program?.(sourceFile, context) ?? sourceFile;
+  }
+  for (const plugin of plugins) sourceFile = transformPluginNodes(sourceFile, plugin, context);
+  const statements = sourceFile.statements.map(
+    (statement) => ts__default.default.isImportDeclaration(statement) ? rebuildImport(state, statement) : transformStatement(state, statement)
+  );
+  const templateDeclarations = createTemplateDeclarations(state);
+  const resultFile = ts__default.default.factory.updateSourceFile(sourceFile, [
+    ...createRuntimeImports(state),
+    ...templateDeclarations,
+    ...statements
+  ]);
+  const generated = ts__default.default.createPrinter().printFile(resultFile);
+  return {
+    code: generated,
+    map: buildSourceMap(state, filename, code, generated, resultFile),
+    diagnostics: [...diagnostics, ...state.diagnostics]
+  };
+}
+__name(compileWithSourceMap, "compileWithSourceMap");
+function toCompilerDiagnostic(diagnostic, sourceFile, filename) {
+  const start = diagnostic.start ?? 0;
+  const length = diagnostic.length ?? 1;
+  const message = ts__default.default.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+  const { line, column, codeFrame } = buildCodeFrame(sourceFile, start, length);
+  return {
+    code: `VOBS_C${String(diagnostic.code).padStart(3, "0")}`,
+    severity: diagnostic.category === ts__default.default.DiagnosticCategory.Warning ? "warning" : "error",
+    message,
+    location: { file: filename, line, column },
+    codeFrame
+  };
+}
+__name(toCompilerDiagnostic, "toCompilerDiagnostic");
+function buildCodeFrame(sourceFile, start, length) {
+  const position = sourceFile.getLineAndCharacterOfPosition(start);
+  const lineText = sourceFile.text.split(/\r?\n/u)[position.line] ?? "";
+  const markerLength = Math.max(1, Math.min(length, Math.max(1, lineText.length - position.character)));
+  return {
+    line: position.line + 1,
+    column: position.character + 1,
+    codeFrame: `${position.line + 1} | ${lineText}
+${" ".repeat(String(position.line + 1).length + 3 + position.character)}${"^".repeat(markerLength)}`
+  };
+}
+__name(buildCodeFrame, "buildCodeFrame");
+function reportUnsupportedTag(state, tagName) {
+  const sourceFile = tagName.getSourceFile() ?? state.sourceFile;
+  if (!sourceFile) return;
+  const label = tagName.getText();
+  const kindNote = tagName.kind === ts__default.default.SyntaxKind.JsxNamespacedName ? "\uFF08JSX \u547D\u540D\u7A7A\u95F4\u6807\u7B7E\uFF09" : "";
+  const { line, column, codeFrame } = buildCodeFrame(sourceFile, tagName.getStart(sourceFile), tagName.getWidth(sourceFile));
+  state.diagnostics.push({
+    code: "VOBS_C101",
+    severity: "error",
+    message: `\u4E0D\u652F\u6301\u7684 JSX \u6807\u7B7E\u5F62\u6001\uFF1A<${label}>${kindNote}\u3002\u7EC4\u4EF6\u5FC5\u987B\u662F\u5927\u5199\u5F00\u5934\u7684\u6807\u8BC6\u7B26\uFF0CDOM \u5143\u7D20\u5FC5\u987B\u662F\u5C0F\u5199\u6807\u7B7E\u540D\u3002`,
+    location: { file: state.filename, line, column },
+    codeFrame,
+    fix: `\u628A <${label}> \u6539\u4E3A <Component /> \u5F62\u5F0F\u7684\u7EC4\u4EF6\u6216\u5C0F\u5199 DOM \u6807\u7B7E\uFF1BFragment \u8BF7\u4F7F\u7528 <Fragment> \u6216 <>...</>\u3002`
+  });
+}
+__name(reportUnsupportedTag, "reportUnsupportedTag");
+function buildSourceMap(state, filename, source, generated, resultFile) {
+  const reparsed = ts__default.default.createSourceFile(filename, generated, ts__default.default.ScriptTarget.Latest, true, ts__default.default.ScriptKind.TSX);
+  const segments = [];
+  walkPairedTrees(state, resultFile, reparsed, reparsed, segments);
+  segments.sort((a, b) => a.genLine - b.genLine || a.genCol - b.genCol);
+  return {
+    version: 3,
+    file: filename,
+    sources: [filename],
+    sourcesContent: [source],
+    names: [],
+    mappings: encodeMappings(segments, generated.split("\n").length)
+  };
+}
+__name(buildSourceMap, "buildSourceMap");
+function statementLists(node) {
+  if (ts__default.default.isSourceFile(node) || ts__default.default.isBlock(node) || ts__default.default.isModuleBlock(node)) return node.statements;
+  if (ts__default.default.isCaseClause(node) || ts__default.default.isDefaultClause(node)) return node.statements;
+  return null;
+}
+__name(statementLists, "statementLists");
+function walkPairedTrees(state, original, generated, reparsed, segments) {
+  const originalStatements = statementLists(original);
+  const generatedStatements = statementLists(generated);
+  if (originalStatements && generatedStatements) {
+    if (originalStatements.length !== generatedStatements.length) return;
+    for (let index = 0; index < originalStatements.length; index++) {
+      const originalStatement = originalStatements[index];
+      const generatedStatement = generatedStatements[index];
+      recordSegment(state, originalStatement, generatedStatement, reparsed, segments);
+      walkPairedTrees(state, originalStatement, generatedStatement, reparsed, segments);
+    }
+    return;
+  }
+  const originalChildren = [];
+  const generatedChildren = [];
+  ts__default.default.forEachChild(original, (node) => {
+    originalChildren.push(node);
+  });
+  ts__default.default.forEachChild(generated, (node) => {
+    generatedChildren.push(node);
+  });
+  if (originalChildren.length !== generatedChildren.length) return;
+  for (let index = 0; index < originalChildren.length; index++) {
+    walkPairedTrees(state, originalChildren[index], generatedChildren[index], reparsed, segments);
+  }
+}
+__name(walkPairedTrees, "walkPairedTrees");
+function recordSegment(state, originalStatement, generatedStatement, reparsed, segments) {
+  const source = state.statementSources.get(originalStatement) ?? positionOfOriginalStatement(state, originalStatement);
+  if (!source) return;
+  const position = reparsed.getLineAndCharacterOfPosition(generatedStatement.getStart(reparsed));
+  segments.push({
+    genLine: position.line,
+    genCol: position.character,
+    srcLine: source.line,
+    srcCol: source.column
+  });
+}
+__name(recordSegment, "recordSegment");
+function positionOfOriginalStatement(state, statement) {
+  if (statement.pos < 0 || !state.sourceFile) return null;
+  const { line, character } = state.sourceFile.getLineAndCharacterOfPosition(
+    statement.getStart(state.sourceFile)
+  );
+  return { line, column: character };
+}
+__name(positionOfOriginalStatement, "positionOfOriginalStatement");
+function encodeMappings(segments, lineCount) {
+  const lines = Array.from({ length: lineCount }, () => []);
+  let prevGenLine = -1;
+  let prevGenCol = 0;
+  let prevSrcLine = 0;
+  let prevSrcCol = 0;
+  for (const segment of segments) {
+    if (segment.genLine !== prevGenLine) {
+      prevGenCol = 0;
+      prevGenLine = segment.genLine;
+    }
+    const values = [
+      segment.genCol - prevGenCol,
+      0,
+      segment.srcLine - prevSrcLine,
+      segment.srcCol - prevSrcCol
+    ];
+    lines[segment.genLine].push(values.map(encodeVlq).join(""));
+    prevGenCol = segment.genCol;
+    prevSrcLine = segment.srcLine;
+    prevSrcCol = segment.srcCol;
+  }
+  return lines.map((line) => line.join(",")).join(";");
+}
+__name(encodeMappings, "encodeMappings");
+var base64Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function encodeVlq(value) {
+  let encoded = value < 0 ? -value << 1 | 1 : value << 1;
+  let result = "";
+  do {
+    let digit = encoded & 31;
+    encoded >>>= 5;
+    if (encoded > 0) digit |= 32;
+    result += base64Chars[digit];
+  } while (encoded > 0);
+  return result;
+}
+__name(encodeVlq, "encodeVlq");
+function validatePlugins(plugins) {
+  const names = /* @__PURE__ */ new Set();
+  for (const plugin of plugins) {
+    if (!plugin.name) throw new error.VobsError({ code: "VOBS_C007", layer: "compiler", message: "\u7F16\u8BD1\u5668\u63D2\u4EF6\u5FC5\u987B\u63D0\u4F9B name", fix: "\u4E3A\u63D2\u4EF6\u6DFB\u52A0\u7A33\u5B9A\u4E14\u552F\u4E00\u7684 name\u3002" });
+    if (names.has(plugin.name)) throw new error.VobsError({ code: "VOBS_C007", layer: "compiler", message: `\u68C0\u6D4B\u5230\u91CD\u590D\u63D2\u4EF6: ${plugin.name}`, fix: "\u4E3A\u6BCF\u4E2A\u7F16\u8BD1\u5668\u63D2\u4EF6\u4F7F\u7528\u552F\u4E00\u7684 name\u3002" });
+    names.add(plugin.name);
+  }
+}
+__name(validatePlugins, "validatePlugins");
+function transformPluginNodes(sourceFile, plugin, context) {
+  const transformNode = plugin.transform?.node ?? plugin.transformNode;
+  if (!transformNode) return sourceFile;
+  const transformer = /* @__PURE__ */ __name((transformContext) => (root) => {
+    const visit = /* @__PURE__ */ __name((node) => {
+      const replacement = transformNode(node, context);
+      if (replacement === null) return void 0;
+      return ts__default.default.visitEachChild(replacement ?? node, visit, transformContext);
+    }, "visit");
+    return ts__default.default.visitNode(root, visit);
+  }, "transformer");
+  const result = ts__default.default.transform(sourceFile, [transformer]);
+  try {
+    return result.transformed[0];
+  } finally {
+    result.dispose();
+  }
+}
+__name(transformPluginNodes, "transformPluginNodes");
+function collectDeclaredNames(sourceFile) {
+  const names = /* @__PURE__ */ new Set();
+  const visit = /* @__PURE__ */ __name((node) => {
+    if (ts__default.default.isIdentifier(node) && isBindingName(node)) names.add(node.text);
+    ts__default.default.forEachChild(node, visit);
+  }, "visit");
+  visit(sourceFile);
+  return names;
+}
+__name(collectDeclaredNames, "collectDeclaredNames");
+function collectStateAliases(sourceFile) {
+  const aliases = /* @__PURE__ */ new Set();
+  for (const statement of sourceFile.statements) {
+    if (!ts__default.default.isImportDeclaration(statement) || !ts__default.default.isStringLiteral(statement.moduleSpecifier)) continue;
+    const module = statement.moduleSpecifier.text;
+    if (module !== "@vobs/reactivity" && module !== "@vobs/vobs") continue;
+    const clause = statement.importClause;
+    if (!clause?.namedBindings || !ts__default.default.isNamedImports(clause.namedBindings)) continue;
+    for (const element of clause.namedBindings.elements) {
+      if (element.propertyName ? element.propertyName.text === "state" : element.name.text === "state") {
+        aliases.add(element.name.text);
+      }
+    }
+  }
+  return aliases;
+}
+__name(collectStateAliases, "collectStateAliases");
+function collectLocallyDeclaredNames(sourceFile) {
+  const names = /* @__PURE__ */ new Set();
+  const visit = /* @__PURE__ */ __name((node) => {
+    if (ts__default.default.isImportDeclaration(node)) return;
+    if (ts__default.default.isIdentifier(node) && isBindingName(node)) names.add(node.text);
+    ts__default.default.forEachChild(node, visit);
+  }, "visit");
+  visit(sourceFile);
+  return names;
+}
+__name(collectLocallyDeclaredNames, "collectLocallyDeclaredNames");
+function isBindingName(node) {
+  const parent = node.parent;
+  if (!parent) return false;
+  if (ts__default.default.isPropertyAccessExpression(parent) && parent.name === node) return false;
+  if (ts__default.default.isQualifiedName(parent) && parent.right === node) return false;
+  if (ts__default.default.isJsxAttribute(parent)) return false;
+  return parent.name === node;
+}
+__name(isBindingName, "isBindingName");
+function resolveHelperName(state, name) {
+  const existing = state.helperAliases.get(name);
+  if (existing) return existing;
+  let alias = name;
+  if (state.takenNames.has(alias)) {
+    alias = `_vobs_${name}`;
+    let suffix = 1;
+    while (state.takenNames.has(alias)) alias = `_vobs_${name}_${suffix++}`;
+  }
+  state.helperAliases.set(name, alias);
+  return alias;
+}
+__name(resolveHelperName, "resolveHelperName");
+function helperRef(state, name) {
+  return ts__default.default.factory.createIdentifier(resolveHelperName(state, name));
+}
+__name(helperRef, "helperRef");
+function createRuntimeImports(state) {
+  const modules = /* @__PURE__ */ new Map();
+  for (const [name, alias] of state.helperAliases) {
+    const module = name === "insertResourceBoundary" ? "@vobs/resource" : "@vobs/vobs";
+    const imported = modules.get(module) ?? [];
+    imported.push(ts__default.default.factory.createImportSpecifier(
+      false,
+      alias === name ? void 0 : ts__default.default.factory.createIdentifier(name),
+      ts__default.default.factory.createIdentifier(alias)
+    ));
+    modules.set(module, imported);
+  }
+  return [...modules.entries()].map(([module, imported]) => ts__default.default.factory.createImportDeclaration(
+    void 0,
+    ts__default.default.factory.createImportClause(
+      false,
+      void 0,
+      ts__default.default.factory.createNamedImports(imported)
+    ),
+    ts__default.default.factory.createStringLiteral(module)
+  ));
+}
+__name(createRuntimeImports, "createRuntimeImports");
+function rebuildImport(state, node) {
+  if (!ts__default.default.isStringLiteral(node.moduleSpecifier)) return node;
+  return tagStatement(state, ts__default.default.factory.createImportDeclaration(
+    node.modifiers,
+    node.importClause,
+    ts__default.default.factory.createStringLiteral(node.moduleSpecifier.text),
+    node.attributes
+  ), node);
+}
+__name(rebuildImport, "rebuildImport");
+function transformStatement(state, node) {
+  if (ts__default.default.isFunctionDeclaration(node) && node.body) {
+    return tagStatement(state, ts__default.default.factory.updateFunctionDeclaration(
+      node,
+      node.modifiers,
+      node.asteriskToken,
+      node.name,
+      node.typeParameters,
+      node.parameters,
+      node.type,
+      transformBlock(state, node.body)
+    ), node);
+  }
+  if (ts__default.default.isVariableStatement(node)) return transformVariableStatement(state, node);
+  if (ts__default.default.isExportAssignment(node) && containsJsx(node.expression)) {
+    return tagStatement(state, ts__default.default.factory.updateExportAssignment(node, node.modifiers, transformEmbeddedExpression(state, node.expression)), node);
+  }
+  if (ts__default.default.isExpressionStatement(node) && containsJsx(node.expression)) {
+    return tagStatement(state, ts__default.default.factory.updateExpressionStatement(node, transformEmbeddedExpression(state, node.expression)), node);
+  }
+  if (ts__default.default.isReturnStatement(node) && node.expression && containsJsx(node.expression)) {
+    return tagStatement(state, ts__default.default.factory.updateReturnStatement(node, transformEmbeddedExpression(state, node.expression)), node);
+  }
+  return node;
+}
+__name(transformStatement, "transformStatement");
+function transformVariableStatement(state, node) {
+  let changed = false;
+  const declarations = node.declarationList.declarations.map((declaration) => {
+    const initializer = declaration.initializer;
+    if (!initializer) return declaration;
+    let nextInitializer = inferStateDebugName(state, declaration, initializer) ?? initializer;
+    if (containsJsx(nextInitializer)) {
+      nextInitializer = transformEmbeddedExpression(state, nextInitializer);
+    }
+    if (nextInitializer === initializer) return declaration;
+    changed = true;
+    return ts__default.default.factory.updateVariableDeclaration(
+      declaration,
+      declaration.name,
+      declaration.exclamationToken,
+      declaration.type,
+      nextInitializer
+    );
+  });
+  if (!changed) return node;
+  return tagStatement(state, ts__default.default.factory.updateVariableStatement(
+    node,
+    node.modifiers,
+    ts__default.default.factory.updateVariableDeclarationList(node.declarationList, declarations)
+  ), node);
+}
+__name(transformVariableStatement, "transformVariableStatement");
+function inferStateDebugName(state, declaration, initializer) {
+  if (state.stateAliases.size === 0) return void 0;
+  if (!ts__default.default.isIdentifier(declaration.name)) return void 0;
+  let call = initializer;
+  while (ts__default.default.isParenthesizedExpression(call) || ts__default.default.isAsExpression(call) || ts__default.default.isTypeAssertionExpression(call) || ts__default.default.isSatisfiesExpression(call)) {
+    call = call.expression;
+  }
+  if (!ts__default.default.isCallExpression(call)) return void 0;
+  const callee = call.expression;
+  if (!ts__default.default.isIdentifier(callee) || !state.stateAliases.has(callee.text)) return void 0;
+  if (state.localBindings.has(callee.text)) return void 0;
+  if (call.arguments.length !== 1) return void 0;
+  return ts__default.default.factory.createCallExpression(callee, call.typeArguments, [
+    ...call.arguments,
+    ts__default.default.factory.createStringLiteral(declaration.name.text)
+  ]);
+}
+__name(inferStateDebugName, "inferStateDebugName");
+function containsJsx(expression) {
+  let found = false;
+  const visit = /* @__PURE__ */ __name((node) => {
+    if (isJsxExpression(node)) {
+      found = true;
+      return;
+    }
+    ts__default.default.forEachChild(node, visit);
+  }, "visit");
+  visit(expression);
+  return found;
+}
+__name(containsJsx, "containsJsx");
+function transformBlock(state, block) {
+  const statements = block.statements.map((statement) => {
+    if (!ts__default.default.isReturnStatement(statement) || !statement.expression) return transformStatement(state, statement);
+    const expression = ts__default.default.isParenthesizedExpression(statement.expression) ? statement.expression.expression : statement.expression;
+    return isJsxExpression(expression) ? tagStatement(state, ts__default.default.factory.updateReturnStatement(statement, transformJsxExpression(state, expression)), statement) : statement;
+  });
+  return ts__default.default.factory.updateBlock(block, statements);
+}
+__name(transformBlock, "transformBlock");
+function isJsxExpression(node) {
+  return ts__default.default.isJsxElement(node) || ts__default.default.isJsxSelfClosingElement(node) || ts__default.default.isJsxFragment(node);
+}
+__name(isJsxExpression, "isJsxExpression");
+function transformJsxExpression(state, node) {
+  if (ts__default.default.isJsxFragment(node)) return transformFragment(state, node.children);
+  if (ts__default.default.isJsxElement(node)) {
+    return transformElement(state, node, node.openingElement.tagName, node.openingElement.attributes, node.children);
+  }
+  return transformElement(state, node, node.tagName, node.attributes, []);
+}
+__name(transformJsxExpression, "transformJsxExpression");
+function transformElement(state, node, tagName, attributes, children) {
+  if (isFragmentTag(tagName)) return transformFragment(state, children);
+  if (!ts__default.default.isIdentifier(tagName)) {
+    reportUnsupportedTag(state, tagName);
+  }
+  if (ts__default.default.isIdentifier(tagName) && tagName.text === "ResourceBoundary") {
+    return transformResourceBoundary(state, node, attributes, children);
+  }
+  if (ts__default.default.isIdentifier(tagName) && tagName.text === "AsyncBoundary") {
+    return transformAsyncBoundary(state, node, attributes, children);
+  }
+  if (ts__default.default.isIdentifier(tagName) && tagName.text === "ErrorBoundary") {
+    return transformErrorBoundary(state, node, attributes, children);
+  }
+  if (ts__default.default.isIdentifier(tagName) && tagName.text === "Profiler") {
+    return transformProfiler(state, node, attributes, children);
+  }
+  if (ts__default.default.isIdentifier(tagName) && /^[A-Z]/.test(tagName.text)) {
+    const args = [
+      ts__default.default.factory.createCallExpression(helperRef(state, "resolveComponent"), void 0, [
+        tagName,
+        ts__default.default.factory.createStringLiteral(state.filename),
+        ts__default.default.factory.createStringLiteral(tagName.text)
+      ]),
+      createComponentProps(state, attributes, children)
+    ];
+    if (state.sourceLocation) args.push(createSourceLocation(tagName));
+    return ts__default.default.factory.createCallExpression(helperRef(state, "createComponent"), void 0, args);
+  }
+  if (isStaticElement(tagName, attributes, children)) {
+    return ts__default.default.factory.createCallExpression(
+      helperRef(state, "cloneTemplate"),
+      void 0,
+      [registerTemplate(state, serializeStaticHtml(node))]
+    );
+  }
+  const elementName = tagName.getText();
+  const elementId = nextIdentifier(state, "_el");
+  const statements = [
+    createConstStatement(
+      state,
+      elementId,
+      ts__default.default.factory.createCallExpression(
+        helperRef(state, "createElement"),
+        void 0,
+        [ts__default.default.factory.createStringLiteral(elementName)]
+      ),
+      node
+    )
+  ];
+  appendAttributes(state, statements, elementId, attributes);
+  appendChildren(state, statements, elementId, children);
+  statements.push(tagStatement(state, ts__default.default.factory.createReturnStatement(elementId), node));
+  return ts__default.default.factory.createCallExpression(
+    ts__default.default.factory.createArrowFunction(
+      void 0,
+      void 0,
+      [],
+      void 0,
+      ts__default.default.factory.createToken(ts__default.default.SyntaxKind.EqualsGreaterThanToken),
+      ts__default.default.factory.createBlock(statements, true)
+    ),
+    void 0,
+    []
+  );
+}
+__name(transformElement, "transformElement");
+function isFragmentTag(tagName) {
+  return tagName.getText() === "Fragment" || tagName.getText() === "Vobs.Fragment";
+}
+__name(isFragmentTag, "isFragmentTag");
+function transformFragment(state, children) {
+  const parent = nextIdentifier(state, "_fragmentParent");
+  const anchor = nextIdentifier(state, "_fragmentAnchor");
+  const statements = [];
+  appendChildren(state, statements, parent, children, anchor);
+  return ts__default.default.factory.createCallExpression(
+    helperRef(state, "createFragment"),
+    void 0,
+    [ts__default.default.factory.createArrowFunction(
+      void 0,
+      void 0,
+      [
+        ts__default.default.factory.createParameterDeclaration(void 0, void 0, parent),
+        ts__default.default.factory.createParameterDeclaration(void 0, void 0, anchor)
+      ],
+      void 0,
+      ts__default.default.factory.createToken(ts__default.default.SyntaxKind.EqualsGreaterThanToken),
+      ts__default.default.factory.createBlock(statements, true)
+    )]
+  );
+}
+__name(transformFragment, "transformFragment");
+function transformResourceBoundary(state, node, attributes, children) {
+  const resource = getAttributeExpression(attributes, "resource");
+  if (!resource) throw new error.VobsError({ code: "VOBS_C002", layer: "compiler", message: "ResourceBoundary \u5FC5\u987B\u63D0\u4F9B resource \u5C5E\u6027", fix: "\u4E3A ResourceBoundary \u6DFB\u52A0 resource={resource}\u3002" });
+  const options = [
+    ts__default.default.factory.createPropertyAssignment("resource", transformEmbeddedExpression(state, resource)),
+    ts__default.default.factory.createPropertyAssignment("children", createBoundaryFactory(state, children))
+  ];
+  appendBoundaryOptionalProperty(state, options, attributes, "loading");
+  appendBoundaryOptionalProperty(state, options, attributes, "empty");
+  appendBoundaryOptionalProperty(state, options, attributes, "fallback");
+  return createBoundaryFragment(state, node, "insertResourceBoundary", options);
+}
+__name(transformResourceBoundary, "transformResourceBoundary");
+function transformErrorBoundary(state, node, attributes, children) {
+  const fallback = getAttributeExpression(attributes, "fallback");
+  if (!fallback) throw new error.VobsError({ code: "VOBS_C002", layer: "compiler", message: "ErrorBoundary \u5FC5\u987B\u63D0\u4F9B fallback \u5C5E\u6027", fix: "\u4E3A ErrorBoundary \u6DFB\u52A0 fallback={(error, retry) => ...}\u3002" });
+  return createBoundaryFragment(state, node, "insertErrorBoundary", [
+    ts__default.default.factory.createPropertyAssignment("children", createBoundaryFactory(state, children)),
+    ts__default.default.factory.createPropertyAssignment("fallback", transformEmbeddedExpression(state, fallback))
+  ]);
+}
+__name(transformErrorBoundary, "transformErrorBoundary");
+function transformAsyncBoundary(state, node, attributes, children) {
+  const promise = getAttributeExpression(attributes, "promise");
+  if (!promise) throw new error.VobsError({ code: "VOBS_C002", layer: "compiler", message: "AsyncBoundary \u5FC5\u987B\u63D0\u4F9B promise \u5C5E\u6027", fix: "\u4E3A AsyncBoundary \u6DFB\u52A0 promise={promise}\u3002" });
+  const options = [
+    ts__default.default.factory.createPropertyAssignment("promise", transformEmbeddedExpression(state, promise)),
+    ts__default.default.factory.createPropertyAssignment("children", createAsyncFactory(state, children))
+  ];
+  appendBoundaryOptionalProperty(state, options, attributes, "loading");
+  appendBoundaryOptionalProperty(state, options, attributes, "fallback");
+  const resetKey = getAttributeExpression(attributes, "resetKey");
+  if (resetKey) options.push(ts__default.default.factory.createPropertyAssignment("resetKey", createGetter(resetKey)));
+  return createBoundaryFragment(state, node, "insertAsyncBoundary", options);
+}
+__name(transformAsyncBoundary, "transformAsyncBoundary");
+function transformProfiler(state, node, attributes, children) {
+  const idAttribute = attributes.properties.find((attribute) => ts__default.default.isJsxAttribute(attribute) && attribute.name.getText() === "id");
+  const id = idAttribute && ts__default.default.isJsxAttribute(idAttribute) && idAttribute.initializer && ts__default.default.isStringLiteral(idAttribute.initializer) ? ts__default.default.factory.createStringLiteral(idAttribute.initializer.text) : idAttribute && ts__default.default.isJsxAttribute(idAttribute) && idAttribute.initializer && ts__default.default.isJsxExpression(idAttribute.initializer) ? idAttribute.initializer.expression : null;
+  if (!id) throw new error.VobsError({ code: "VOBS_C002", layer: "compiler", message: "Profiler \u5FC5\u987B\u63D0\u4F9B id \u5C5E\u6027", fix: '\u4E3A Profiler \u6DFB\u52A0 id="ComponentName"\u3002' });
+  const options = [
+    ts__default.default.factory.createPropertyAssignment("id", transformEmbeddedExpression(state, id)),
+    ts__default.default.factory.createPropertyAssignment("children", createBoundaryFactory(state, children))
+  ];
+  appendBoundaryOptionalProperty(state, options, attributes, "onRender");
+  return createBoundaryFragment(state, node, "insertProfiler", options);
+}
+__name(transformProfiler, "transformProfiler");
+function createBoundaryFragment(state, node, helper, options) {
+  const parent = nextIdentifier(state, "_boundaryParent");
+  const anchor = nextIdentifier(state, "_boundaryAnchor");
+  return ts__default.default.factory.createCallExpression(
+    helperRef(state, "createFragment"),
+    void 0,
+    [ts__default.default.factory.createArrowFunction(
+      void 0,
+      void 0,
+      [
+        ts__default.default.factory.createParameterDeclaration(void 0, void 0, parent),
+        ts__default.default.factory.createParameterDeclaration(void 0, void 0, anchor)
+      ],
+      void 0,
+      ts__default.default.factory.createToken(ts__default.default.SyntaxKind.EqualsGreaterThanToken),
+      ts__default.default.factory.createBlock([callStatement(state, helper, [
+        parent,
+        anchor,
+        ts__default.default.factory.createObjectLiteralExpression(options, true)
+      ], node)], true)
+    )]
+  );
+}
+__name(createBoundaryFragment, "createBoundaryFragment");
+function createBoundaryFactory(state, children) {
+  const content = transformFragment(state, children);
+  return ts__default.default.factory.createArrowFunction(
+    void 0,
+    void 0,
+    [],
+    void 0,
+    ts__default.default.factory.createToken(ts__default.default.SyntaxKind.EqualsGreaterThanToken),
+    content
+  );
+}
+__name(createBoundaryFactory, "createBoundaryFactory");
+function createAsyncFactory(state, children) {
+  const value = ts__default.default.factory.createIdentifier("value");
+  const expressionChild = children.length === 1 && children[0].kind === ts__default.default.SyntaxKind.JsxExpression ? children[0].expression : void 0;
+  if (expressionChild && ts__default.default.isArrowFunction(expressionChild)) {
+    const transformed = transformEmbeddedExpression(state, expressionChild);
+    return transformed;
+  }
+  const content = transformFragment(state, children);
+  return ts__default.default.factory.createArrowFunction(void 0, void 0, [
+    ts__default.default.factory.createParameterDeclaration(void 0, void 0, value)
+  ], void 0, ts__default.default.factory.createToken(ts__default.default.SyntaxKind.EqualsGreaterThanToken), content);
+}
+__name(createAsyncFactory, "createAsyncFactory");
+function appendBoundaryOptionalProperty(state, properties, attributes, name) {
+  const expression = getAttributeExpression(attributes, name);
+  if (expression) {
+    const transformed = transformEmbeddedExpression(state, expression);
+    const value = isJsxExpression(unwrapExpression(expression)) ? createGetter(transformed) : transformed;
+    properties.push(ts__default.default.factory.createPropertyAssignment(name, value));
+  }
+}
+__name(appendBoundaryOptionalProperty, "appendBoundaryOptionalProperty");
+function getAttributeExpression(attributes, name) {
+  for (const attribute of attributes.properties) {
+    if (!ts__default.default.isJsxAttribute(attribute) || attribute.name.getText() !== name) continue;
+    if (attribute.initializer && ts__default.default.isJsxExpression(attribute.initializer)) {
+      return attribute.initializer.expression ?? null;
+    }
+  }
+  return null;
+}
+__name(getAttributeExpression, "getAttributeExpression");
+function transformEmbeddedExpression(state, expression) {
+  const result = ts__default.default.transform(expression, [(context) => (root) => {
+    const visit = /* @__PURE__ */ __name((node) => {
+      if (ts__default.default.isJsxElement(node) || ts__default.default.isJsxSelfClosingElement(node) || ts__default.default.isJsxFragment(node)) {
+        return transformJsxExpression(state, node);
+      }
+      return ts__default.default.visitEachChild(node, visit, context);
+    }, "visit");
+    return ts__default.default.visitNode(root, visit);
+  }]);
+  try {
+    return result.transformed[0];
+  } finally {
+    result.dispose();
+  }
+}
+__name(transformEmbeddedExpression, "transformEmbeddedExpression");
+function isStaticElement(tagName, attributes, children) {
+  if (!ts__default.default.isIdentifier(tagName) || !/^[a-z]/.test(tagName.text)) return false;
+  for (const attribute of attributes.properties) {
+    if (ts__default.default.isJsxSpreadAttribute(attribute)) return false;
+    if (!ts__default.default.isJsxAttribute(attribute)) return false;
+    const name = attribute.name.getText();
+    if (name === "key" || name === "ref" || name.startsWith("on")) return false;
+    if (isPropertyAttribute(name)) return false;
+    const initializer = attribute.initializer;
+    if (initializer && !ts__default.default.isStringLiteral(initializer)) return false;
+  }
+  for (const child of children) {
+    if (ts__default.default.isJsxText(child)) continue;
+    if (ts__default.default.isJsxElement(child) || ts__default.default.isJsxSelfClosingElement(child)) {
+      const nested = ts__default.default.isJsxElement(child) ? { tagName: child.openingElement.tagName, attributes: child.openingElement.attributes, children: child.children } : { tagName: child.tagName, attributes: child.attributes, children: [] };
+      if (!isStaticElement(nested.tagName, nested.attributes, nested.children)) return false;
+      continue;
+    }
+    return false;
+  }
+  return true;
+}
+__name(isStaticElement, "isStaticElement");
+function serializeStaticHtml(node) {
+  const { tagName, attributes, children } = ts__default.default.isJsxElement(node) ? { tagName: node.openingElement.tagName, attributes: node.openingElement.attributes, children: node.children } : { tagName: node.tagName, attributes: node.attributes, children: [] };
+  return serializeStaticElement(tagName, attributes, children);
+}
+__name(serializeStaticHtml, "serializeStaticHtml");
+function serializeStaticElement(tagName, attributes, children) {
+  const name = tagName.getText();
+  let html = `<${name}`;
+  for (const attribute of attributes.properties) {
+    if (!ts__default.default.isJsxAttribute(attribute)) continue;
+    const attributeName = attribute.name.getText() === "className" ? "class" : attribute.name.getText();
+    const initializer = attribute.initializer;
+    if (!initializer) {
+      html += ` ${attributeName}=""`;
+      continue;
+    }
+    if (ts__default.default.isStringLiteral(initializer)) {
+      html += ` ${attributeName}="${escapeHtmlAttribute(initializer.text)}"`;
+    }
+  }
+  html += ">";
+  for (const child of children) {
+    if (ts__default.default.isJsxText(child)) {
+      const text = child.text.replace(/\s+/g, " ").trimStart();
+      if (text.trim()) html += escapeHtmlText(text);
+      continue;
+    }
+    if (ts__default.default.isJsxElement(child)) {
+      html += serializeStaticElement(
+        child.openingElement.tagName,
+        child.openingElement.attributes,
+        child.children
+      );
+      continue;
+    }
+    if (ts__default.default.isJsxSelfClosingElement(child)) {
+      html += serializeStaticElement(child.tagName, child.attributes, []);
+    }
+  }
+  html += `</${name}>`;
+  return html;
+}
+__name(serializeStaticElement, "serializeStaticElement");
+function escapeHtmlAttribute(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
+}
+__name(escapeHtmlAttribute, "escapeHtmlAttribute");
+function escapeHtmlText(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+__name(escapeHtmlText, "escapeHtmlText");
+function registerTemplate(state, html) {
+  const existing = state.templates.get(html);
+  if (existing) return existing;
+  const identifier = nextIdentifier(state, "_tpl");
+  state.templates.set(html, identifier);
+  return identifier;
+}
+__name(registerTemplate, "registerTemplate");
+function createTemplateDeclarations(state) {
+  return [...state.templates.entries()].map(
+    ([html, identifier]) => ts__default.default.factory.createVariableStatement(void 0, ts__default.default.factory.createVariableDeclarationList([
+      ts__default.default.factory.createVariableDeclaration(identifier, void 0, void 0, ts__default.default.factory.createCallExpression(
+        helperRef(state, "createTemplate"),
+        void 0,
+        [ts__default.default.factory.createStringLiteral(html)]
+      ))
+    ], ts__default.default.NodeFlags.Const))
+  );
+}
+__name(createTemplateDeclarations, "createTemplateDeclarations");
+function appendAttributes(state, statements, element, attributes) {
+  const staticProps = [];
+  const hasSpread = attributes.properties.some((attribute) => ts__default.default.isJsxSpreadAttribute(attribute));
+  for (const attribute of attributes.properties) {
+    if (ts__default.default.isJsxSpreadAttribute(attribute)) {
+      statements.push(callStatement(state, "spreadProps", [element, transformEmbeddedExpression(state, attribute.expression)], attribute));
+      continue;
+    }
+    if (!ts__default.default.isJsxAttribute(attribute)) continue;
+    const name = attribute.name.getText();
+    if (name === "key") continue;
+    if (name === "ref") {
+      const initializer2 = attribute.initializer;
+      if (initializer2 && ts__default.default.isJsxExpression(initializer2) && initializer2.expression) {
+        statements.push(callStatement(state, "setRef", [element, transformEmbeddedExpression(state, initializer2.expression)], attribute));
+      }
+      continue;
+    }
+    const initializer = attribute.initializer;
+    if (name.startsWith("on") && initializer && ts__default.default.isJsxExpression(initializer) && initializer.expression) {
+      statements.push(callStatement(state, "addEventListener", [
+        element,
+        ts__default.default.factory.createStringLiteral(name.slice(2).toLowerCase()),
+        initializer.expression
+      ], attribute));
+      continue;
+    }
+    if (!initializer) {
+      if (hasSpread) {
+        statements.push(callStatement(state, isPropertyAttribute(name) ? "setProperty" : "setAttribute", [element, ts__default.default.factory.createStringLiteral(isPropertyAttribute(name) ? name : name === "className" ? "class" : name), isPropertyAttribute(name) ? ts__default.default.factory.createTrue() : ts__default.default.factory.createStringLiteral("")], attribute));
+        continue;
+      }
+      if (isPropertyAttribute(name)) staticProps.push(createStaticProperty(name, ts__default.default.factory.createTrue()));
+      else staticProps.push(createStaticProperty(name === "className" ? "class" : name, ts__default.default.factory.createStringLiteral("")));
+      continue;
+    }
+    if (ts__default.default.isStringLiteral(initializer)) {
+      if (hasSpread) {
+        statements.push(callStatement(state, isPropertyAttribute(name) ? "setProperty" : "setAttribute", [element, ts__default.default.factory.createStringLiteral(isPropertyAttribute(name) ? name : name === "className" ? "class" : name), ts__default.default.factory.createStringLiteral(initializer.text)], attribute));
+        continue;
+      }
+      staticProps.push(createStaticProperty(
+        isPropertyAttribute(name) ? name : name === "className" ? "class" : name,
+        ts__default.default.factory.createStringLiteral(initializer.text)
+      ));
+      continue;
+    }
+    const attributeName = name === "className" ? "class" : name;
+    const propertyAttribute = isPropertyAttribute(name);
+    if (ts__default.default.isJsxExpression(initializer) && initializer.expression) {
+      statements.push(callStatement(state, propertyAttribute ? "bindProperty" : "bindAttribute", [
+        element,
+        ts__default.default.factory.createStringLiteral(propertyAttribute ? name : attributeName),
+        createGetter(initializer.expression)
+      ], attribute));
+    }
+  }
+  if (staticProps.length) statements.splice(1, 0, callStatement(state, "setStaticProps", [
+    element,
+    ts__default.default.factory.createObjectLiteralExpression(staticProps, true)
+  ], attributes));
+}
+__name(appendAttributes, "appendAttributes");
+function createStaticProperty(name, value) {
+  return ts__default.default.factory.createPropertyAssignment(ts__default.default.factory.createStringLiteral(name), value);
+}
+__name(createStaticProperty, "createStaticProperty");
+function isPropertyAttribute(name) {
+  return name === "value" || name === "checked" || name === "selected" || name === "disabled" || name === "multiple" || name === "readOnly" || name === "required" || name === "autofocus" || name === "hidden" || name === "tabIndex";
+}
+__name(isPropertyAttribute, "isPropertyAttribute");
+function appendChildren(state, statements, element, children, anchor = ts__default.default.factory.createNull()) {
+  for (const child of children) {
+    if (ts__default.default.isJsxText(child)) {
+      const text = child.text.replace(/\s+/g, " ").trimStart();
+      if (text.trim()) {
+        statements.push(callStatement(state, "insertBefore", [
+          element,
+          ts__default.default.factory.createCallExpression(helperRef(state, "createText"), void 0, [
+            ts__default.default.factory.createStringLiteral(text)
+          ]),
+          anchor
+        ], child));
+      }
+      continue;
+    }
+    if (ts__default.default.isJsxElement(child) || ts__default.default.isJsxSelfClosingElement(child) || ts__default.default.isJsxFragment(child)) {
+      statements.push(callStatement(state, "insertBefore", [
+        element,
+        transformJsxExpression(state, child),
+        anchor
+      ], child));
+      continue;
+    }
+    if (child.kind === ts__default.default.SyntaxKind.JsxExpression) {
+      const expression = child.expression;
+      if (!expression) continue;
+      const list = transformListExpression(state, element, expression, anchor);
+      if (list) {
+        statements.push(callStatement(state, "insertList", list, child));
+        continue;
+      }
+      const dynamic = transformDynamicExpression(state, expression);
+      if (dynamic) {
+        statements.push(callStatement(state, "insertDynamic", [element, anchor, dynamic], child));
+        continue;
+      }
+      if (!containsJsx(expression) && !ts__default.default.isIdentifier(expression)) {
+        const textId = nextIdentifier(state, "_text");
+        statements.push(createConstStatement(state, textId, ts__default.default.factory.createCallExpression(helperRef(state, "createText"), void 0, [ts__default.default.factory.createStringLiteral("")]), child));
+        statements.push(callStatement(state, "insertBefore", [element, textId, anchor], child));
+        statements.push(callStatement(state, "bindText", [textId, createGetter(expression)], child));
+        continue;
+      }
+      const value = transformEmbeddedExpression(state, expression);
+      statements.push(callStatement(state, "insertDynamicValue", [element, anchor, createGetter(value)], child));
+    }
+  }
+}
+__name(appendChildren, "appendChildren");
+function createComponentProps(state, attributes, children) {
+  const properties = [];
+  for (const attribute of attributes.properties) {
+    if (ts__default.default.isJsxSpreadAttribute(attribute)) {
+      properties.push(ts__default.default.factory.createSpreadAssignment(attribute.expression));
+      continue;
+    }
+    const name = propertyName(attribute.name.getText());
+    if (attribute.name.getText() === "key") continue;
+    const initializer = attribute.initializer;
+    if (!initializer) {
+      properties.push(ts__default.default.factory.createPropertyAssignment(name, ts__default.default.factory.createTrue()));
+    } else if (ts__default.default.isStringLiteral(initializer)) {
+      properties.push(ts__default.default.factory.createPropertyAssignment(name, ts__default.default.factory.createStringLiteral(initializer.text)));
+    } else if (ts__default.default.isJsxExpression(initializer) && initializer.expression) {
+      properties.push(createGetterProperty(name, transformEmbeddedExpression(state, initializer.expression)));
+    }
+  }
+  const childExpressions = children.flatMap((child) => childToComponentExpression(state, child));
+  if (childExpressions.length === 1) {
+    properties.push(createGetterProperty("children", childExpressions[0]));
+  } else if (childExpressions.length > 1) {
+    properties.push(createGetterProperty("children", ts__default.default.factory.createArrayLiteralExpression(childExpressions)));
+  }
+  return ts__default.default.factory.createObjectLiteralExpression(properties, true);
+}
+__name(createComponentProps, "createComponentProps");
+function createSourceLocation(node) {
+  const sourceFile = node.getSourceFile();
+  const position = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+  return ts__default.default.factory.createObjectLiteralExpression([
+    ts__default.default.factory.createPropertyAssignment("file", ts__default.default.factory.createStringLiteral(sourceFile.fileName)),
+    ts__default.default.factory.createPropertyAssignment("line", ts__default.default.factory.createNumericLiteral(position.line + 1)),
+    ts__default.default.factory.createPropertyAssignment("column", ts__default.default.factory.createNumericLiteral(position.character + 1))
+  ], true);
+}
+__name(createSourceLocation, "createSourceLocation");
+function transformDynamicExpression(state, expression) {
+  if (ts__default.default.isBinaryExpression(expression) && expression.operatorToken.kind === ts__default.default.SyntaxKind.AmpersandAmpersandToken) {
+    const right = unwrapExpression(expression.right);
+    if (!isJsxExpression(right)) return null;
+    return createGetter(ts__default.default.factory.createConditionalExpression(
+      expression.left,
+      ts__default.default.factory.createToken(ts__default.default.SyntaxKind.QuestionToken),
+      transformJsxExpression(state, right),
+      ts__default.default.factory.createToken(ts__default.default.SyntaxKind.ColonToken),
+      ts__default.default.factory.createNull()
+    ));
+  }
+  if (ts__default.default.isConditionalExpression(expression)) {
+    const whenTrue = transformDynamicBranch(state, expression.whenTrue);
+    const whenFalse = transformDynamicBranch(state, expression.whenFalse);
+    if (!whenTrue && !whenFalse) return null;
+    return createGetter(ts__default.default.factory.createConditionalExpression(
+      expression.condition,
+      ts__default.default.factory.createToken(ts__default.default.SyntaxKind.QuestionToken),
+      whenTrue ?? ts__default.default.factory.createNull(),
+      ts__default.default.factory.createToken(ts__default.default.SyntaxKind.ColonToken),
+      whenFalse ?? ts__default.default.factory.createNull()
+    ));
+  }
+  return null;
+}
+__name(transformDynamicExpression, "transformDynamicExpression");
+function transformDynamicBranch(state, expression) {
+  const branch = unwrapExpression(expression);
+  if (isJsxExpression(branch)) return transformJsxExpression(state, branch);
+  if (branch.kind === ts__default.default.SyntaxKind.NullKeyword || branch.kind === ts__default.default.SyntaxKind.FalseKeyword) return branch;
+  return null;
+}
+__name(transformDynamicBranch, "transformDynamicBranch");
+function transformListExpression(state, parent, expression, anchor) {
+  if (!ts__default.default.isCallExpression(expression) || expression.arguments.length !== 1) return null;
+  if (!ts__default.default.isPropertyAccessExpression(expression.expression) || expression.expression.name.text !== "map") return null;
+  const callback = expression.arguments[0];
+  if (!ts__default.default.isArrowFunction(callback) && !ts__default.default.isFunctionExpression(callback)) return null;
+  const body = unwrapExpression(callback.body);
+  if (!isJsxExpression(body) || ts__default.default.isJsxFragment(body)) return null;
+  const key = findKeyExpression(body);
+  const renderItem = transformListCallback(callback, transformJsxExpression(state, body));
+  const args = [
+    parent,
+    anchor,
+    createGetter(expression.expression.expression),
+    renderItem
+  ];
+  if (key) args.push(createKeyCallback(callback, key));
+  return args;
+}
+__name(transformListExpression, "transformListExpression");
+function transformListCallback(callback, body) {
+  if (ts__default.default.isArrowFunction(callback)) {
+    return ts__default.default.factory.updateArrowFunction(
+      callback,
+      callback.modifiers,
+      callback.typeParameters,
+      callback.parameters,
+      callback.type,
+      callback.equalsGreaterThanToken,
+      body
+    );
+  }
+  return ts__default.default.factory.updateFunctionExpression(
+    callback,
+    callback.modifiers,
+    callback.asteriskToken,
+    callback.name,
+    callback.typeParameters,
+    callback.parameters,
+    callback.type,
+    ts__default.default.factory.createBlock([ts__default.default.factory.createReturnStatement(body)], true)
+  );
+}
+__name(transformListCallback, "transformListCallback");
+function createKeyCallback(callback, key) {
+  return ts__default.default.factory.createArrowFunction(
+    void 0,
+    void 0,
+    callback.parameters,
+    void 0,
+    ts__default.default.factory.createToken(ts__default.default.SyntaxKind.EqualsGreaterThanToken),
+    key
+  );
+}
+__name(createKeyCallback, "createKeyCallback");
+function findKeyExpression(node) {
+  const attributes = ts__default.default.isJsxElement(node) ? node.openingElement.attributes : node.attributes;
+  for (const attribute of attributes.properties) {
+    if (!ts__default.default.isJsxAttribute(attribute) || attribute.name.getText() !== "key") continue;
+    if (attribute.initializer && ts__default.default.isJsxExpression(attribute.initializer)) {
+      return attribute.initializer.expression ?? null;
+    }
+  }
+  return null;
+}
+__name(findKeyExpression, "findKeyExpression");
+function unwrapExpression(node) {
+  return ts__default.default.isParenthesizedExpression(node) ? node.expression : node;
+}
+__name(unwrapExpression, "unwrapExpression");
+function childToComponentExpression(state, child) {
+  if (ts__default.default.isJsxText(child)) {
+    const text = child.text.replace(/\s+/g, " ").trim();
+    return text ? [ts__default.default.factory.createStringLiteral(text)] : [];
+  }
+  if (ts__default.default.isJsxElement(child) || ts__default.default.isJsxSelfClosingElement(child) || ts__default.default.isJsxFragment(child)) {
+    return [transformJsxExpression(state, child)];
+  }
+  if (child.kind === ts__default.default.SyntaxKind.JsxExpression) {
+    const expression = child.expression;
+    return expression ? [transformEmbeddedExpression(state, expression)] : [];
+  }
+  return [];
+}
+__name(childToComponentExpression, "childToComponentExpression");
+function propertyName(name) {
+  return /^[$A-Z_a-z][$\w]*$/u.test(name) ? ts__default.default.factory.createIdentifier(name) : ts__default.default.factory.createStringLiteral(name);
+}
+__name(propertyName, "propertyName");
+function createGetter(expression) {
+  return ts__default.default.factory.createArrowFunction(
+    void 0,
+    void 0,
+    [],
+    void 0,
+    ts__default.default.factory.createToken(ts__default.default.SyntaxKind.EqualsGreaterThanToken),
+    expression
+  );
+}
+__name(createGetter, "createGetter");
+function createGetterProperty(name, expression) {
+  return ts__default.default.factory.createGetAccessorDeclaration(
+    void 0,
+    typeof name === "string" ? propertyName(name) : name,
+    [],
+    void 0,
+    ts__default.default.factory.createBlock([ts__default.default.factory.createReturnStatement(expression)], true)
+  );
+}
+__name(createGetterProperty, "createGetterProperty");
+function callStatement(state, name, args, source) {
+  const statement = ts__default.default.factory.createExpressionStatement(
+    ts__default.default.factory.createCallExpression(helperRef(state, name), void 0, args)
+  );
+  return source ? tagStatement(state, statement, source) : statement;
+}
+__name(callStatement, "callStatement");
+function createConstStatement(state, name, initializer, source) {
+  const statement = ts__default.default.factory.createVariableStatement(
+    void 0,
+    ts__default.default.factory.createVariableDeclarationList([
+      ts__default.default.factory.createVariableDeclaration(name, void 0, void 0, initializer)
+    ], ts__default.default.NodeFlags.Const)
+  );
+  return source ? tagStatement(state, statement, source) : statement;
+}
+__name(createConstStatement, "createConstStatement");
+function tagStatement(state, statement, source) {
+  const position = positionOfNode(state, source);
+  if (position) state.statementSources.set(statement, position);
+  return statement;
+}
+__name(tagStatement, "tagStatement");
+function positionOfNode(state, node) {
+  const sourceFile = node.getSourceFile() ?? state.sourceFile;
+  if (!sourceFile || node.pos < 0) return null;
+  const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+  return { line, column: character };
+}
+__name(positionOfNode, "positionOfNode");
+function nextIdentifier(state, prefix) {
+  let name;
+  do {
+    name = `${prefix}${state.generatedId++}`;
+  } while (state.takenNames.has(name));
+  return ts__default.default.factory.createIdentifier(name);
+}
+__name(nextIdentifier, "nextIdentifier");
+
+exports.compile = compile;
+exports.compileWithSourceMap = compileWithSourceMap;
+exports.createCompiler = createCompiler;
+//# sourceMappingURL=compile.cjs.map
+//# sourceMappingURL=compile.cjs.map