@vobs/compiler 1.2.1 → 1.3.0

package/dist/index.cjs

@@ -1,14 +1,47 @@
-'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 __VOBS_CJS_FILE_URL = require("url").pathToFileURL(__filename).href;
+"use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/compiler/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  compile: () => compile,
+  compileWithSourceMap: () => compileWithSourceMap,
+  createCompiler: () => createCompiler,
+  createI18nExtractor: () => createI18nExtractor
+});
+module.exports = __toCommonJS(src_exports);
+
+// packages/compiler/src/compile.ts
+var import_typescript = __toESM(require("typescript"), 1);
+var import_error = require("@vobs/runtime/error");
 function createCompiler(options = {}) {
   const basePlugins = options.plugins ?? [];
   return {
@@ -31,7 +64,7 @@ function compile(code, options = {}) {
   const result = compileWithSourceMap(code, options);
   const firstError = result.diagnostics.find((diagnostic) => diagnostic.severity === "error");
   if (firstError) {
-    throw new error.VobsError({
+    throw new import_error.VobsError({
       code: firstError.code,
       layer: "compiler",
       message: firstError.message,
@@ -45,12 +78,12 @@ function compile(code, options = {}) {
 __name(compile, "compile");
 function compileWithSourceMap(code, options = {}) {
   const filename = options.filename ?? "component.tsx";
-  let sourceFile = ts__default.default.createSourceFile(
+  let sourceFile = import_typescript.default.createSourceFile(
     filename,
     code,
-    ts__default.default.ScriptTarget.Latest,
+    import_typescript.default.ScriptTarget.Latest,
     true,
-    ts__default.default.ScriptKind.TSX
+    import_typescript.default.ScriptKind.TSX
   );
   const state = {
     generatedId: 0,
@@ -63,21 +96,22 @@ function compileWithSourceMap(code, options = {}) {
     sourceLocation: options.sourceLocation ?? true,
     stateAliases: collectStateAliases(sourceFile),
     localBindings: collectLocallyDeclaredNames(sourceFile),
-    diagnostics: []
+    diagnostics: [],
+    hmrModuleId: options.hmrModuleId ?? null
   };
   const cleanFilename = filename.split(/[?#]/u, 1)[0] || filename;
-  const diagnostics = ts__default.default.transpileModule(code, {
+  const diagnostics = import_typescript.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 }
+    compilerOptions: { jsx: import_typescript.default.JsxEmit.Preserve, target: import_typescript.default.ScriptTarget.Latest }
   }).diagnostics?.map((diagnostic) => toCompilerDiagnostic(diagnostic, sourceFile, cleanFilename)) ?? [];
   const plugins = options.plugins ?? [];
   validatePlugins(plugins);
   const context = {
     filename,
-    factory: ts__default.default.factory,
+    factory: import_typescript.default.factory,
     addRuntimeImport(name) {
       resolveHelperName(state, name);
     },
@@ -89,15 +123,16 @@ function compileWithSourceMap(code, options = {}) {
   }
   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)
+    (statement) => import_typescript.default.isImportDeclaration(statement) ? rebuildImport(state, statement) : transformStatement(state, statement, true)
   );
   const templateDeclarations = createTemplateDeclarations(state);
-  const resultFile = ts__default.default.factory.updateSourceFile(sourceFile, [
+  let resultFile = import_typescript.default.factory.updateSourceFile(sourceFile, [
     ...createRuntimeImports(state),
     ...templateDeclarations,
     ...statements
   ]);
-  const generated = ts__default.default.createPrinter().printFile(resultFile);
+  resultFile = transformResidualJsx(state, resultFile);
+  const generated = import_typescript.default.createPrinter().printFile(resultFile);
   return {
     code: generated,
     map: buildSourceMap(state, filename, code, generated, resultFile),
@@ -108,11 +143,11 @@ __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 message = import_typescript.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",
+    severity: diagnostic.category === import_typescript.default.DiagnosticCategory.Warning ? "warning" : "error",
     message,
     location: { file: filename, line, column },
     codeFrame
@@ -135,7 +170,7 @@ 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 kindNote = tagName.kind === import_typescript.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",
@@ -148,7 +183,7 @@ function reportUnsupportedTag(state, tagName) {
 }
 __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 reparsed = import_typescript.default.createSourceFile(filename, generated, import_typescript.default.ScriptTarget.Latest, true, import_typescript.default.ScriptKind.TSX);
   const segments = [];
   walkPairedTrees(state, resultFile, reparsed, reparsed, segments);
   segments.sort((a, b) => a.genLine - b.genLine || a.genCol - b.genCol);
@@ -163,8 +198,8 @@ function buildSourceMap(state, filename, source, generated, resultFile) {
 }
 __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;
+  if (import_typescript.default.isSourceFile(node) || import_typescript.default.isBlock(node) || import_typescript.default.isModuleBlock(node)) return node.statements;
+  if (import_typescript.default.isCaseClause(node) || import_typescript.default.isDefaultClause(node)) return node.statements;
   return null;
 }
 __name(statementLists, "statementLists");
@@ -183,10 +218,10 @@ function walkPairedTrees(state, original, generated, reparsed, segments) {
   }
   const originalChildren = [];
   const generatedChildren = [];
-  ts__default.default.forEachChild(original, (node) => {
+  import_typescript.default.forEachChild(original, (node) => {
     originalChildren.push(node);
   });
-  ts__default.default.forEachChild(generated, (node) => {
+  import_typescript.default.forEachChild(generated, (node) => {
     generatedChildren.push(node);
   });
   if (originalChildren.length !== generatedChildren.length) return;
@@ -256,8 +291,8 @@ __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" });
+    if (!plugin.name) throw new import_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 import_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);
   }
 }
@@ -269,11 +304,11 @@ function transformPluginNodes(sourceFile, plugin, context) {
     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);
+      return import_typescript.default.visitEachChild(replacement ?? node, visit, transformContext);
     }, "visit");
-    return ts__default.default.visitNode(root, visit);
+    return import_typescript.default.visitNode(root, visit);
   }, "transformer");
-  const result = ts__default.default.transform(sourceFile, [transformer]);
+  const result = import_typescript.default.transform(sourceFile, [transformer]);
   try {
     return result.transformed[0];
   } finally {
@@ -284,8 +319,8 @@ __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);
+    if (import_typescript.default.isIdentifier(node) && isBindingName(node)) names.add(node.text);
+    import_typescript.default.forEachChild(node, visit);
   }, "visit");
   visit(sourceFile);
   return names;
@@ -294,11 +329,11 @@ __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;
+    if (!import_typescript.default.isImportDeclaration(statement) || !import_typescript.default.isStringLiteral(statement.moduleSpecifier)) continue;
+    const module2 = statement.moduleSpecifier.text;
+    if (module2 !== "@vobs/reactivity" && module2 !== "@vobs/vobs") continue;
     const clause = statement.importClause;
-    if (!clause?.namedBindings || !ts__default.default.isNamedImports(clause.namedBindings)) continue;
+    if (!clause?.namedBindings || !import_typescript.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);
@@ -311,9 +346,9 @@ __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);
+    if (import_typescript.default.isImportDeclaration(node)) return;
+    if (import_typescript.default.isIdentifier(node) && isBindingName(node)) names.add(node.text);
+    import_typescript.default.forEachChild(node, visit);
   }, "visit");
   visit(sourceFile);
   return names;
@@ -322,9 +357,9 @@ __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;
+  if (import_typescript.default.isPropertyAccessExpression(parent) && parent.name === node) return false;
+  if (import_typescript.default.isQualifiedName(parent) && parent.right === node) return false;
+  if (import_typescript.default.isJsxAttribute(parent)) return false;
   return parent.name === node;
 }
 __name(isBindingName, "isBindingName");
@@ -342,45 +377,45 @@ function resolveHelperName(state, name) {
 }
 __name(resolveHelperName, "resolveHelperName");
 function helperRef(state, name) {
-  return ts__default.default.factory.createIdentifier(resolveHelperName(state, name));
+  return import_typescript.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(
+    const module2 = name === "insertResourceBoundary" ? "@vobs/resource" : "@vobs/vobs";
+    const imported = modules.get(module2) ?? [];
+    imported.push(import_typescript.default.factory.createImportSpecifier(
       false,
-      alias === name ? void 0 : ts__default.default.factory.createIdentifier(name),
-      ts__default.default.factory.createIdentifier(alias)
+      alias === name ? void 0 : import_typescript.default.factory.createIdentifier(name),
+      import_typescript.default.factory.createIdentifier(alias)
     ));
-    modules.set(module, imported);
+    modules.set(module2, imported);
   }
-  return [...modules.entries()].map(([module, imported]) => ts__default.default.factory.createImportDeclaration(
+  return [...modules.entries()].map(([module2, imported]) => import_typescript.default.factory.createImportDeclaration(
     void 0,
-    ts__default.default.factory.createImportClause(
+    import_typescript.default.factory.createImportClause(
       false,
       void 0,
-      ts__default.default.factory.createNamedImports(imported)
+      import_typescript.default.factory.createNamedImports(imported)
     ),
-    ts__default.default.factory.createStringLiteral(module)
+    import_typescript.default.factory.createStringLiteral(module2)
   ));
 }
 __name(createRuntimeImports, "createRuntimeImports");
 function rebuildImport(state, node) {
-  if (!ts__default.default.isStringLiteral(node.moduleSpecifier)) return node;
-  return tagStatement(state, ts__default.default.factory.createImportDeclaration(
+  if (!import_typescript.default.isStringLiteral(node.moduleSpecifier)) return node;
+  return tagStatement(state, import_typescript.default.factory.createImportDeclaration(
     node.modifiers,
     node.importClause,
-    ts__default.default.factory.createStringLiteral(node.moduleSpecifier.text),
+    import_typescript.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(
+function transformStatement(state, node, moduleScope = false) {
+  if (import_typescript.default.isFunctionDeclaration(node) && node.body) {
+    return tagStatement(state, import_typescript.default.factory.updateFunctionDeclaration(
       node,
       node.modifiers,
       node.asteriskToken,
@@ -391,20 +426,20 @@ function transformStatement(state, node) {
       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 (import_typescript.default.isVariableStatement(node)) return transformVariableStatement(state, node, moduleScope);
+  if (import_typescript.default.isExportAssignment(node) && containsJsx(node.expression)) {
+    return tagStatement(state, import_typescript.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 (import_typescript.default.isExpressionStatement(node) && containsJsx(node.expression)) {
+    return tagStatement(state, import_typescript.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);
+  if (import_typescript.default.isReturnStatement(node) && node.expression && containsJsx(node.expression)) {
+    return tagStatement(state, import_typescript.default.factory.updateReturnStatement(node, transformEmbeddedExpression(state, node.expression)), node);
   }
   return node;
 }
 __name(transformStatement, "transformStatement");
-function transformVariableStatement(state, node) {
+function transformVariableStatement(state, node, moduleScope = false) {
   let changed = false;
   const declarations = node.declarationList.declarations.map((declaration) => {
     const initializer = declaration.initializer;
@@ -412,10 +447,12 @@ function transformVariableStatement(state, node) {
     let nextInitializer = inferStateDebugName(state, declaration, initializer) ?? initializer;
     if (containsJsx(nextInitializer)) {
       nextInitializer = transformEmbeddedExpression(state, nextInitializer);
+    } else if (moduleScope && state.hmrModuleId !== null) {
+      nextInitializer = wrapStateWithHmrRef(state, declaration, nextInitializer) ?? nextInitializer;
     }
     if (nextInitializer === initializer) return declaration;
     changed = true;
-    return ts__default.default.factory.updateVariableDeclaration(
+    return import_typescript.default.factory.updateVariableDeclaration(
       declaration,
       declaration.name,
       declaration.exclamationToken,
@@ -424,31 +461,54 @@ function transformVariableStatement(state, node) {
     );
   });
   if (!changed) return node;
-  return tagStatement(state, ts__default.default.factory.updateVariableStatement(
+  return tagStatement(state, import_typescript.default.factory.updateVariableStatement(
     node,
     node.modifiers,
-    ts__default.default.factory.updateVariableDeclarationList(node.declarationList, declarations)
+    import_typescript.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;
+  if (!import_typescript.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)) {
+  while (import_typescript.default.isParenthesizedExpression(call) || import_typescript.default.isAsExpression(call) || import_typescript.default.isTypeAssertionExpression(call) || import_typescript.default.isSatisfiesExpression(call)) {
     call = call.expression;
   }
-  if (!ts__default.default.isCallExpression(call)) return void 0;
+  if (!import_typescript.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 (!import_typescript.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, [
+  return import_typescript.default.factory.createCallExpression(callee, call.typeArguments, [
     ...call.arguments,
-    ts__default.default.factory.createStringLiteral(declaration.name.text)
+    import_typescript.default.factory.createStringLiteral(declaration.name.text)
   ]);
 }
 __name(inferStateDebugName, "inferStateDebugName");
+function wrapStateWithHmrRef(state, declaration, initializer) {
+  let call = initializer;
+  while (import_typescript.default.isParenthesizedExpression(call) || import_typescript.default.isAsExpression(call) || import_typescript.default.isTypeAssertionExpression(call) || import_typescript.default.isSatisfiesExpression(call)) {
+    call = call.expression;
+  }
+  if (!import_typescript.default.isCallExpression(call)) return void 0;
+  const callee = call.expression;
+  if (!import_typescript.default.isIdentifier(callee) || !state.stateAliases.has(callee.text)) return void 0;
+  if (state.localBindings.has(callee.text)) return void 0;
+  if (!import_typescript.default.isIdentifier(declaration.name)) return void 0;
+  return import_typescript.default.factory.createCallExpression(helperRef(state, "hmrStateRef"), void 0, [
+    import_typescript.default.factory.createStringLiteral(`${state.hmrModuleId}#${declaration.name.text}`),
+    import_typescript.default.factory.createArrowFunction(
+      void 0,
+      void 0,
+      [],
+      void 0,
+      import_typescript.default.factory.createToken(import_typescript.default.SyntaxKind.EqualsGreaterThanToken),
+      initializer
+    )
+  ]);
+}
+__name(wrapStateWithHmrRef, "wrapStateWithHmrRef");
 function containsJsx(expression) {
   let found = false;
   const visit = /* @__PURE__ */ __name((node) => {
@@ -456,7 +516,7 @@ function containsJsx(expression) {
       found = true;
       return;
     }
-    ts__default.default.forEachChild(node, visit);
+    import_typescript.default.forEachChild(node, visit);
   }, "visit");
   visit(expression);
   return found;
@@ -464,20 +524,20 @@ function containsJsx(expression) {
 __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;
+    if (!import_typescript.default.isReturnStatement(statement) || !statement.expression) return transformStatement(state, statement);
+    const expression = import_typescript.default.isParenthesizedExpression(statement.expression) ? statement.expression.expression : statement.expression;
+    return isJsxExpression(expression) ? tagStatement(state, import_typescript.default.factory.updateReturnStatement(statement, transformJsxExpression(state, expression)), statement) : statement;
   });
-  return ts__default.default.factory.updateBlock(block, statements);
+  return import_typescript.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);
+  return import_typescript.default.isJsxElement(node) || import_typescript.default.isJsxSelfClosingElement(node) || import_typescript.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)) {
+  if (import_typescript.default.isJsxFragment(node)) return transformFragment(state, node.children);
+  if (import_typescript.default.isJsxElement(node)) {
     return transformElement(state, node, node.openingElement.tagName, node.openingElement.attributes, node.children);
   }
   return transformElement(state, node, node.tagName, node.attributes, []);
@@ -485,35 +545,35 @@ function transformJsxExpression(state, node) {
 __name(transformJsxExpression, "transformJsxExpression");
 function transformElement(state, node, tagName, attributes, children) {
   if (isFragmentTag(tagName)) return transformFragment(state, children);
-  if (!ts__default.default.isIdentifier(tagName)) {
+  if (!import_typescript.default.isIdentifier(tagName)) {
     reportUnsupportedTag(state, tagName);
   }
-  if (ts__default.default.isIdentifier(tagName) && tagName.text === "ResourceBoundary") {
+  if (import_typescript.default.isIdentifier(tagName) && tagName.text === "ResourceBoundary") {
     return transformResourceBoundary(state, node, attributes, children);
   }
-  if (ts__default.default.isIdentifier(tagName) && tagName.text === "AsyncBoundary") {
+  if (import_typescript.default.isIdentifier(tagName) && tagName.text === "AsyncBoundary") {
     return transformAsyncBoundary(state, node, attributes, children);
   }
-  if (ts__default.default.isIdentifier(tagName) && tagName.text === "ErrorBoundary") {
+  if (import_typescript.default.isIdentifier(tagName) && tagName.text === "ErrorBoundary") {
     return transformErrorBoundary(state, node, attributes, children);
   }
-  if (ts__default.default.isIdentifier(tagName) && tagName.text === "Profiler") {
+  if (import_typescript.default.isIdentifier(tagName) && tagName.text === "Profiler") {
     return transformProfiler(state, node, attributes, children);
   }
-  if (ts__default.default.isIdentifier(tagName) && /^[A-Z]/.test(tagName.text)) {
+  if (import_typescript.default.isIdentifier(tagName) && /^[A-Z]/.test(tagName.text)) {
     const args = [
-      ts__default.default.factory.createCallExpression(helperRef(state, "resolveComponent"), void 0, [
+      import_typescript.default.factory.createCallExpression(helperRef(state, "resolveComponent"), void 0, [
         tagName,
-        ts__default.default.factory.createStringLiteral(state.filename),
-        ts__default.default.factory.createStringLiteral(tagName.text)
+        import_typescript.default.factory.createStringLiteral(state.filename),
+        import_typescript.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);
+    return import_typescript.default.factory.createCallExpression(helperRef(state, "createComponent"), void 0, args);
   }
   if (isStaticElement(tagName, attributes, children)) {
-    return ts__default.default.factory.createCallExpression(
+    return import_typescript.default.factory.createCallExpression(
       helperRef(state, "cloneTemplate"),
       void 0,
       [registerTemplate(state, serializeStaticHtml(node))]
@@ -525,25 +585,25 @@ function transformElement(state, node, tagName, attributes, children) {
     createConstStatement(
       state,
       elementId,
-      ts__default.default.factory.createCallExpression(
+      import_typescript.default.factory.createCallExpression(
         helperRef(state, "createElement"),
         void 0,
-        [ts__default.default.factory.createStringLiteral(elementName)]
+        [import_typescript.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(
+  statements.push(tagStatement(state, import_typescript.default.factory.createReturnStatement(elementId), node));
+  return import_typescript.default.factory.createCallExpression(
+    import_typescript.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)
+      import_typescript.default.factory.createToken(import_typescript.default.SyntaxKind.EqualsGreaterThanToken),
+      import_typescript.default.factory.createBlock(statements, true)
     ),
     void 0,
     []
@@ -559,29 +619,29 @@ function transformFragment(state, children) {
   const anchor = nextIdentifier(state, "_fragmentAnchor");
   const statements = [];
   appendChildren(state, statements, parent, children, anchor);
-  return ts__default.default.factory.createCallExpression(
+  return import_typescript.default.factory.createCallExpression(
     helperRef(state, "createFragment"),
     void 0,
-    [ts__default.default.factory.createArrowFunction(
+    [import_typescript.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)
+        import_typescript.default.factory.createParameterDeclaration(void 0, void 0, parent),
+        import_typescript.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)
+      import_typescript.default.factory.createToken(import_typescript.default.SyntaxKind.EqualsGreaterThanToken),
+      import_typescript.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" });
+  if (!resource) throw new import_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))
+    import_typescript.default.factory.createPropertyAssignment("resource", transformEmbeddedExpression(state, resource)),
+    import_typescript.default.factory.createPropertyAssignment("children", createBoundaryFactory(state, children))
   ];
   appendBoundaryOptionalProperty(state, options, attributes, "loading");
   appendBoundaryOptionalProperty(state, options, attributes, "empty");
@@ -591,34 +651,34 @@ function transformResourceBoundary(state, node, attributes, children) {
 __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" });
+  if (!fallback) throw new import_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))
+    import_typescript.default.factory.createPropertyAssignment("children", createBoundaryFactory(state, children)),
+    import_typescript.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" });
+  if (!promise) throw new import_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))
+    import_typescript.default.factory.createPropertyAssignment("promise", transformEmbeddedExpression(state, promise)),
+    import_typescript.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)));
+  if (resetKey) options.push(import_typescript.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 idAttribute = attributes.properties.find((attribute) => import_typescript.default.isJsxAttribute(attribute) && attribute.name.getText() === "id");
+  const id = idAttribute && import_typescript.default.isJsxAttribute(idAttribute) && idAttribute.initializer && import_typescript.default.isStringLiteral(idAttribute.initializer) ? import_typescript.default.factory.createStringLiteral(idAttribute.initializer.text) : idAttribute && import_typescript.default.isJsxAttribute(idAttribute) && idAttribute.initializer && import_typescript.default.isJsxExpression(idAttribute.initializer) ? idAttribute.initializer.expression : null;
+  if (!id) throw new import_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))
+    import_typescript.default.factory.createPropertyAssignment("id", transformEmbeddedExpression(state, id)),
+    import_typescript.default.factory.createPropertyAssignment("children", createBoundaryFactory(state, children))
   ];
   appendBoundaryOptionalProperty(state, options, attributes, "onRender");
   return createBoundaryFragment(state, node, "insertProfiler", options);
@@ -627,22 +687,22 @@ __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(
+  return import_typescript.default.factory.createCallExpression(
     helperRef(state, "createFragment"),
     void 0,
-    [ts__default.default.factory.createArrowFunction(
+    [import_typescript.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)
+        import_typescript.default.factory.createParameterDeclaration(void 0, void 0, parent),
+        import_typescript.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, [
+      import_typescript.default.factory.createToken(import_typescript.default.SyntaxKind.EqualsGreaterThanToken),
+      import_typescript.default.factory.createBlock([callStatement(state, helper, [
         parent,
         anchor,
-        ts__default.default.factory.createObjectLiteralExpression(options, true)
+        import_typescript.default.factory.createObjectLiteralExpression(options, true)
       ], node)], true)
     )]
   );
@@ -650,27 +710,27 @@ function createBoundaryFragment(state, node, helper, options) {
 __name(createBoundaryFragment, "createBoundaryFragment");
 function createBoundaryFactory(state, children) {
   const content = transformFragment(state, children);
-  return ts__default.default.factory.createArrowFunction(
+  return import_typescript.default.factory.createArrowFunction(
     void 0,
     void 0,
     [],
     void 0,
-    ts__default.default.factory.createToken(ts__default.default.SyntaxKind.EqualsGreaterThanToken),
+    import_typescript.default.factory.createToken(import_typescript.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 value = import_typescript.default.factory.createIdentifier("value");
+  const expressionChild = children.length === 1 && children[0].kind === import_typescript.default.SyntaxKind.JsxExpression ? children[0].expression : void 0;
+  if (expressionChild && import_typescript.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);
+  return import_typescript.default.factory.createArrowFunction(void 0, void 0, [
+    import_typescript.default.factory.createParameterDeclaration(void 0, void 0, value)
+  ], void 0, import_typescript.default.factory.createToken(import_typescript.default.SyntaxKind.EqualsGreaterThanToken), content);
 }
 __name(createAsyncFactory, "createAsyncFactory");
 function appendBoundaryOptionalProperty(state, properties, attributes, name) {
@@ -678,14 +738,14 @@ function appendBoundaryOptionalProperty(state, properties, 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));
+    properties.push(import_typescript.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)) {
+    if (!import_typescript.default.isJsxAttribute(attribute) || attribute.name.getText() !== name) continue;
+    if (attribute.initializer && import_typescript.default.isJsxExpression(attribute.initializer)) {
       return attribute.initializer.expression ?? null;
     }
   }
@@ -693,14 +753,14 @@ function getAttributeExpression(attributes, name) {
 }
 __name(getAttributeExpression, "getAttributeExpression");
 function transformEmbeddedExpression(state, expression) {
-  const result = ts__default.default.transform(expression, [(context) => (root) => {
+  const result = import_typescript.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)) {
+      if (import_typescript.default.isJsxElement(node) || import_typescript.default.isJsxSelfClosingElement(node) || import_typescript.default.isJsxFragment(node)) {
         return transformJsxExpression(state, node);
       }
-      return ts__default.default.visitEachChild(node, visit, context);
+      return import_typescript.default.visitEachChild(node, visit, context);
     }, "visit");
-    return ts__default.default.visitNode(root, visit);
+    return import_typescript.default.visitNode(root, visit);
   }]);
   try {
     return result.transformed[0];
@@ -709,21 +769,42 @@ function transformEmbeddedExpression(state, expression) {
   }
 }
 __name(transformEmbeddedExpression, "transformEmbeddedExpression");
+function transformResidualJsx(state, sourceFile) {
+  if (!containsJsx(sourceFile)) return sourceFile;
+  const result = import_typescript.default.transform(sourceFile, [(context) => (root) => {
+    const visit = /* @__PURE__ */ __name((node) => {
+      if (import_typescript.default.isReturnStatement(node) && node.expression && containsJsx(node.expression)) {
+        return import_typescript.default.factory.updateReturnStatement(node, transformEmbeddedExpression(state, node.expression));
+      }
+      if (isJsxExpression(node)) {
+        return transformJsxExpression(state, node);
+      }
+      return import_typescript.default.visitEachChild(node, visit, context);
+    }, "visit");
+    return import_typescript.default.visitNode(root, visit);
+  }]);
+  try {
+    return result.transformed[0];
+  } finally {
+    result.dispose();
+  }
+}
+__name(transformResidualJsx, "transformResidualJsx");
 function isStaticElement(tagName, attributes, children) {
-  if (!ts__default.default.isIdentifier(tagName) || !/^[a-z]/.test(tagName.text)) return false;
+  if (!import_typescript.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;
+    if (import_typescript.default.isJsxSpreadAttribute(attribute)) return false;
+    if (!import_typescript.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;
+    if (initializer && !import_typescript.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 (import_typescript.default.isJsxText(child)) continue;
+    if (import_typescript.default.isJsxElement(child) || import_typescript.default.isJsxSelfClosingElement(child)) {
+      const nested = import_typescript.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;
     }
@@ -733,7 +814,7 @@ function isStaticElement(tagName, attributes, children) {
 }
 __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: [] };
+  const { tagName, attributes, children } = import_typescript.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");
@@ -741,25 +822,25 @@ 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;
+    if (!import_typescript.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)) {
+    if (import_typescript.default.isStringLiteral(initializer)) {
       html += ` ${attributeName}="${escapeHtmlAttribute(initializer.text)}"`;
     }
   }
   html += ">";
   for (const child of children) {
-    if (ts__default.default.isJsxText(child)) {
+    if (import_typescript.default.isJsxText(child)) {
       const text = child.text.replace(/\s+/g, " ").trimStart();
       if (text.trim()) html += escapeHtmlText(text);
       continue;
     }
-    if (ts__default.default.isJsxElement(child)) {
+    if (import_typescript.default.isJsxElement(child)) {
       html += serializeStaticElement(
         child.openingElement.tagName,
         child.openingElement.attributes,
@@ -767,7 +848,7 @@ function serializeStaticElement(tagName, attributes, children) {
       );
       continue;
     }
-    if (ts__default.default.isJsxSelfClosingElement(child)) {
+    if (import_typescript.default.isJsxSelfClosingElement(child)) {
       html += serializeStaticElement(child.tagName, child.attributes, []);
     }
   }
@@ -793,103 +874,103 @@ function registerTemplate(state, html) {
 __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(
+    ([html, identifier]) => import_typescript.default.factory.createVariableStatement(void 0, import_typescript.default.factory.createVariableDeclarationList([
+      import_typescript.default.factory.createVariableDeclaration(identifier, void 0, void 0, import_typescript.default.factory.createCallExpression(
         helperRef(state, "createTemplate"),
         void 0,
-        [ts__default.default.factory.createStringLiteral(html)]
+        [import_typescript.default.factory.createStringLiteral(html)]
       ))
-    ], ts__default.default.NodeFlags.Const))
+    ], import_typescript.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));
+  const hasSpread = attributes.properties.some((attribute) => import_typescript.default.isJsxSpreadAttribute(attribute));
   for (const attribute of attributes.properties) {
-    if (ts__default.default.isJsxSpreadAttribute(attribute)) {
+    if (import_typescript.default.isJsxSpreadAttribute(attribute)) {
       statements.push(callStatement(state, "spreadProps", [element, transformEmbeddedExpression(state, attribute.expression)], attribute));
       continue;
     }
-    if (!ts__default.default.isJsxAttribute(attribute)) continue;
+    if (!import_typescript.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) {
+      if (initializer2 && import_typescript.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) {
+    if (name.startsWith("on") && initializer && import_typescript.default.isJsxExpression(initializer) && initializer.expression) {
       statements.push(callStatement(state, "addEventListener", [
         element,
-        ts__default.default.factory.createStringLiteral(name.slice(2).toLowerCase()),
+        import_typescript.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));
+        statements.push(callStatement(state, isPropertyAttribute(name) ? "setProperty" : "setAttribute", [element, import_typescript.default.factory.createStringLiteral(isPropertyAttribute(name) ? name : name === "className" ? "class" : name), isPropertyAttribute(name) ? import_typescript.default.factory.createTrue() : import_typescript.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("")));
+      if (isPropertyAttribute(name)) staticProps.push(createStaticProperty(name, import_typescript.default.factory.createTrue()));
+      else staticProps.push(createStaticProperty(name === "className" ? "class" : name, import_typescript.default.factory.createStringLiteral("")));
       continue;
     }
-    if (ts__default.default.isStringLiteral(initializer)) {
+    if (import_typescript.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));
+        statements.push(callStatement(state, isPropertyAttribute(name) ? "setProperty" : "setAttribute", [element, import_typescript.default.factory.createStringLiteral(isPropertyAttribute(name) ? name : name === "className" ? "class" : name), import_typescript.default.factory.createStringLiteral(initializer.text)], attribute));
         continue;
       }
       staticProps.push(createStaticProperty(
         isPropertyAttribute(name) ? name : name === "className" ? "class" : name,
-        ts__default.default.factory.createStringLiteral(initializer.text)
+        import_typescript.default.factory.createStringLiteral(initializer.text)
       ));
       continue;
     }
     const attributeName = name === "className" ? "class" : name;
     const propertyAttribute = isPropertyAttribute(name);
-    if (ts__default.default.isJsxExpression(initializer) && initializer.expression) {
+    if (import_typescript.default.isJsxExpression(initializer) && initializer.expression) {
       statements.push(callStatement(state, propertyAttribute ? "bindProperty" : "bindAttribute", [
         element,
-        ts__default.default.factory.createStringLiteral(propertyAttribute ? name : attributeName),
+        import_typescript.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)
+    import_typescript.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);
+  return import_typescript.default.factory.createPropertyAssignment(import_typescript.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()) {
+function appendChildren(state, statements, element, children, anchor = import_typescript.default.factory.createNull()) {
   for (const child of children) {
-    if (ts__default.default.isJsxText(child)) {
+    if (import_typescript.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)
+          import_typescript.default.factory.createCallExpression(helperRef(state, "createText"), void 0, [
+            import_typescript.default.factory.createStringLiteral(text)
           ]),
           anchor
         ], child));
       }
       continue;
     }
-    if (ts__default.default.isJsxElement(child) || ts__default.default.isJsxSelfClosingElement(child) || ts__default.default.isJsxFragment(child)) {
+    if (import_typescript.default.isJsxElement(child) || import_typescript.default.isJsxSelfClosingElement(child) || import_typescript.default.isJsxFragment(child)) {
       statements.push(callStatement(state, "insertBefore", [
         element,
         transformJsxExpression(state, child),
@@ -897,7 +978,7 @@ function appendChildren(state, statements, element, children, anchor = ts__defau
       ], child));
       continue;
     }
-    if (child.kind === ts__default.default.SyntaxKind.JsxExpression) {
+    if (child.kind === import_typescript.default.SyntaxKind.JsxExpression) {
       const expression = child.expression;
       if (!expression) continue;
       const list = transformListExpression(state, element, expression, anchor);
@@ -910,9 +991,9 @@ function appendChildren(state, statements, element, children, anchor = ts__defau
         statements.push(callStatement(state, "insertDynamic", [element, anchor, dynamic], child));
         continue;
       }
-      if (!containsJsx(expression) && !ts__default.default.isIdentifier(expression)) {
+      if (!containsJsx(expression) && !import_typescript.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(createConstStatement(state, textId, import_typescript.default.factory.createCallExpression(helperRef(state, "createText"), void 0, [import_typescript.default.factory.createStringLiteral("")]), child));
         statements.push(callStatement(state, "insertBefore", [element, textId, anchor], child));
         statements.push(callStatement(state, "bindText", [textId, createGetter(expression)], child));
         continue;
@@ -926,18 +1007,18 @@ __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));
+    if (import_typescript.default.isJsxSpreadAttribute(attribute)) {
+      properties.push(import_typescript.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(import_typescript.default.factory.createPropertyAssignment(name, import_typescript.default.factory.createTrue()));
+    } else if (import_typescript.default.isStringLiteral(initializer)) {
+      properties.push(import_typescript.default.factory.createPropertyAssignment(name, import_typescript.default.factory.createStringLiteral(initializer.text)));
+    } else if (import_typescript.default.isJsxExpression(initializer) && initializer.expression) {
       properties.push(createGetterProperty(name, transformEmbeddedExpression(state, initializer.expression)));
     }
   }
@@ -945,62 +1026,78 @@ function createComponentProps(state, attributes, children) {
   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)));
+    properties.push(createGetterProperty("children", import_typescript.default.factory.createArrayLiteralExpression(childExpressions)));
   }
-  return ts__default.default.factory.createObjectLiteralExpression(properties, true);
+  return import_typescript.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))
+  return import_typescript.default.factory.createObjectLiteralExpression([
+    import_typescript.default.factory.createPropertyAssignment("file", import_typescript.default.factory.createStringLiteral(sourceFile.fileName)),
+    import_typescript.default.factory.createPropertyAssignment("line", import_typescript.default.factory.createNumericLiteral(position.line + 1)),
+    import_typescript.default.factory.createPropertyAssignment("column", import_typescript.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 converted = convertDynamicNodeExpression(state, expression);
+  return converted ? createGetter(converted) : null;
+}
+__name(transformDynamicExpression, "transformDynamicExpression");
+function convertDynamicNodeExpression(state, expression) {
+  if (import_typescript.default.isBinaryExpression(expression) && expression.operatorToken.kind === import_typescript.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 (isJsxExpression(right)) {
+      return createNodeConditional(expression.left, transformJsxExpression(state, right), null);
+    }
+    const convertedRight = convertDynamicNodeExpression(state, right);
+    if (convertedRight) return createNodeConditional(expression.left, convertedRight, null);
+    return null;
   }
-  if (ts__default.default.isConditionalExpression(expression)) {
+  if (import_typescript.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(
+    return import_typescript.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()
-    ));
+      import_typescript.default.factory.createToken(import_typescript.default.SyntaxKind.QuestionToken),
+      whenTrue ?? import_typescript.default.factory.createNull(),
+      import_typescript.default.factory.createToken(import_typescript.default.SyntaxKind.ColonToken),
+      whenFalse ?? import_typescript.default.factory.createNull()
+    );
   }
   return null;
 }
-__name(transformDynamicExpression, "transformDynamicExpression");
+__name(convertDynamicNodeExpression, "convertDynamicNodeExpression");
+function createNodeConditional(condition, whenTrue, whenFalse) {
+  return import_typescript.default.factory.createConditionalExpression(
+    condition,
+    import_typescript.default.factory.createToken(import_typescript.default.SyntaxKind.QuestionToken),
+    whenTrue,
+    import_typescript.default.factory.createToken(import_typescript.default.SyntaxKind.ColonToken),
+    whenFalse ?? import_typescript.default.factory.createNull()
+  );
+}
+__name(createNodeConditional, "createNodeConditional");
 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;
+  if (branch.kind === import_typescript.default.SyntaxKind.NullKeyword || branch.kind === import_typescript.default.SyntaxKind.FalseKeyword) return branch;
+  if (import_typescript.default.isConditionalExpression(branch) || import_typescript.default.isBinaryExpression(branch) && branch.operatorToken.kind === import_typescript.default.SyntaxKind.AmpersandAmpersandToken) {
+    return convertDynamicNodeExpression(state, 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;
+  if (!import_typescript.default.isCallExpression(expression) || expression.arguments.length !== 1) return null;
+  if (!import_typescript.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;
+  if (!import_typescript.default.isArrowFunction(callback) && !import_typescript.default.isFunctionExpression(callback)) return null;
   const body = unwrapExpression(callback.body);
-  if (!isJsxExpression(body) || ts__default.default.isJsxFragment(body)) return null;
+  if (!isJsxExpression(body) || import_typescript.default.isJsxFragment(body)) return null;
   const key = findKeyExpression(body);
   const renderItem = transformListCallback(callback, transformJsxExpression(state, body));
   const args = [
@@ -1014,8 +1111,8 @@ function transformListExpression(state, parent, expression, anchor) {
 }
 __name(transformListExpression, "transformListExpression");
 function transformListCallback(callback, body) {
-  if (ts__default.default.isArrowFunction(callback)) {
-    return ts__default.default.factory.updateArrowFunction(
+  if (import_typescript.default.isArrowFunction(callback)) {
+    return import_typescript.default.factory.updateArrowFunction(
       callback,
       callback.modifiers,
       callback.typeParameters,
@@ -1025,7 +1122,7 @@ function transformListCallback(callback, body) {
       body
     );
   }
-  return ts__default.default.factory.updateFunctionExpression(
+  return import_typescript.default.factory.updateFunctionExpression(
     callback,
     callback.modifiers,
     callback.asteriskToken,
@@ -1033,26 +1130,26 @@ function transformListCallback(callback, body) {
     callback.typeParameters,
     callback.parameters,
     callback.type,
-    ts__default.default.factory.createBlock([ts__default.default.factory.createReturnStatement(body)], true)
+    import_typescript.default.factory.createBlock([import_typescript.default.factory.createReturnStatement(body)], true)
   );
 }
 __name(transformListCallback, "transformListCallback");
 function createKeyCallback(callback, key) {
-  return ts__default.default.factory.createArrowFunction(
+  return import_typescript.default.factory.createArrowFunction(
     void 0,
     void 0,
     callback.parameters,
     void 0,
-    ts__default.default.factory.createToken(ts__default.default.SyntaxKind.EqualsGreaterThanToken),
+    import_typescript.default.factory.createToken(import_typescript.default.SyntaxKind.EqualsGreaterThanToken),
     key
   );
 }
 __name(createKeyCallback, "createKeyCallback");
 function findKeyExpression(node) {
-  const attributes = ts__default.default.isJsxElement(node) ? node.openingElement.attributes : node.attributes;
+  const attributes = import_typescript.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)) {
+    if (!import_typescript.default.isJsxAttribute(attribute) || attribute.name.getText() !== "key") continue;
+    if (attribute.initializer && import_typescript.default.isJsxExpression(attribute.initializer)) {
       return attribute.initializer.expression ?? null;
     }
   }
@@ -1060,18 +1157,18 @@ function findKeyExpression(node) {
 }
 __name(findKeyExpression, "findKeyExpression");
 function unwrapExpression(node) {
-  return ts__default.default.isParenthesizedExpression(node) ? node.expression : node;
+  return import_typescript.default.isParenthesizedExpression(node) ? node.expression : node;
 }
 __name(unwrapExpression, "unwrapExpression");
 function childToComponentExpression(state, child) {
-  if (ts__default.default.isJsxText(child)) {
+  if (import_typescript.default.isJsxText(child)) {
     const text = child.text.replace(/\s+/g, " ").trim();
-    return text ? [ts__default.default.factory.createStringLiteral(text)] : [];
+    return text ? [import_typescript.default.factory.createStringLiteral(text)] : [];
   }
-  if (ts__default.default.isJsxElement(child) || ts__default.default.isJsxSelfClosingElement(child) || ts__default.default.isJsxFragment(child)) {
+  if (import_typescript.default.isJsxElement(child) || import_typescript.default.isJsxSelfClosingElement(child) || import_typescript.default.isJsxFragment(child)) {
     return [transformJsxExpression(state, child)];
   }
-  if (child.kind === ts__default.default.SyntaxKind.JsxExpression) {
+  if (child.kind === import_typescript.default.SyntaxKind.JsxExpression) {
     const expression = child.expression;
     return expression ? [transformEmbeddedExpression(state, expression)] : [];
   }
@@ -1079,43 +1176,43 @@ function childToComponentExpression(state, child) {
 }
 __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);
+  return /^[$A-Z_a-z][$\w]*$/u.test(name) ? import_typescript.default.factory.createIdentifier(name) : import_typescript.default.factory.createStringLiteral(name);
 }
 __name(propertyName, "propertyName");
 function createGetter(expression) {
-  return ts__default.default.factory.createArrowFunction(
+  return import_typescript.default.factory.createArrowFunction(
     void 0,
     void 0,
     [],
     void 0,
-    ts__default.default.factory.createToken(ts__default.default.SyntaxKind.EqualsGreaterThanToken),
+    import_typescript.default.factory.createToken(import_typescript.default.SyntaxKind.EqualsGreaterThanToken),
     expression
   );
 }
 __name(createGetter, "createGetter");
 function createGetterProperty(name, expression) {
-  return ts__default.default.factory.createGetAccessorDeclaration(
+  return import_typescript.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)
+    import_typescript.default.factory.createBlock([import_typescript.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)
+  const statement = import_typescript.default.factory.createExpressionStatement(
+    import_typescript.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(
+  const statement = import_typescript.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)
+    import_typescript.default.factory.createVariableDeclarationList([
+      import_typescript.default.factory.createVariableDeclaration(name, void 0, void 0, initializer)
+    ], import_typescript.default.NodeFlags.Const)
   );
   return source ? tagStatement(state, statement, source) : statement;
 }
@@ -1138,9 +1235,12 @@ function nextIdentifier(state, prefix) {
   do {
     name = `${prefix}${state.generatedId++}`;
   } while (state.takenNames.has(name));
-  return ts__default.default.factory.createIdentifier(name);
+  return import_typescript.default.factory.createIdentifier(name);
 }
 __name(nextIdentifier, "nextIdentifier");
+
+// packages/compiler/src/i18n-extractor.ts
+var import_typescript2 = __toESM(require("typescript"), 1);
 function createI18nExtractor(options = {}) {
   const names = new Set(options.functions ?? ["t"]);
   const keys = /* @__PURE__ */ new Set();
@@ -1148,14 +1248,14 @@ function createI18nExtractor(options = {}) {
     name: "i18n-extractor",
     analyze(program, context) {
       const visit = /* @__PURE__ */ __name((node) => {
-        if (ts__default.default.isCallExpression(node) && isTranslationCall(node.expression, names)) {
+        if (import_typescript2.default.isCallExpression(node) && isTranslationCall(node.expression, names)) {
           const key = readStaticKey(node.arguments[0]);
           if (key) {
             keys.add(key);
             options.onKey?.(key, context.filename);
           }
         }
-        ts__default.default.forEachChild(node, visit);
+        import_typescript2.default.forEachChild(node, visit);
       }, "visit");
       visit(program);
     }
@@ -1168,20 +1268,21 @@ function createI18nExtractor(options = {}) {
 }
 __name(createI18nExtractor, "createI18nExtractor");
 function isTranslationCall(expression, names) {
-  if (ts__default.default.isIdentifier(expression)) return names.has(expression.text);
-  return ts__default.default.isPropertyAccessExpression(expression) && names.has(expression.name.text);
+  if (import_typescript2.default.isIdentifier(expression)) return names.has(expression.text);
+  return import_typescript2.default.isPropertyAccessExpression(expression) && names.has(expression.name.text);
 }
 __name(isTranslationCall, "isTranslationCall");
 function readStaticKey(argument) {
   if (!argument) return void 0;
-  if (ts__default.default.isStringLiteral(argument) || ts__default.default.isNoSubstitutionTemplateLiteral(argument)) return argument.text;
+  if (import_typescript2.default.isStringLiteral(argument) || import_typescript2.default.isNoSubstitutionTemplateLiteral(argument)) return argument.text;
   return void 0;
 }
 __name(readStaticKey, "readStaticKey");
-
-exports.compile = compile;
-exports.compileWithSourceMap = compileWithSourceMap;
-exports.createCompiler = createCompiler;
-exports.createI18nExtractor = createI18nExtractor;
-//# sourceMappingURL=index.cjs.map
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  compile,
+  compileWithSourceMap,
+  createCompiler,
+  createI18nExtractor
+});
 //# sourceMappingURL=index.cjs.map