@vobs/vite-plugin 1.2.1 → 1.2.2

package/dist/index.js

@@ -1,1146 +1,14 @@
-import { readFile } from 'fs/promises';
-import path from 'path';
-import ts from 'typescript';
-import { VobsError } from '@vobs/runtime/error';
-import { parseFragment } from 'parse5';
-
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-function compileWithSourceMap(code, options = {}) {
-  const filename = options.filename ?? "component.tsx";
-  let sourceFile = ts.createSourceFile(
-    filename,
-    code,
-    ts.ScriptTarget.Latest,
-    true,
-    ts.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.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.JsxEmit.Preserve, target: ts.ScriptTarget.Latest }
-  }).diagnostics?.map((diagnostic) => toCompilerDiagnostic(diagnostic, sourceFile, cleanFilename)) ?? [];
-  const plugins = options.plugins ?? [];
-  validatePlugins(plugins);
-  const context = {
-    filename,
-    factory: ts.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.isImportDeclaration(statement) ? rebuildImport(state, statement) : transformStatement(state, statement)
-  );
-  const templateDeclarations = createTemplateDeclarations(state);
-  const resultFile = ts.factory.updateSourceFile(sourceFile, [
-    ...createRuntimeImports(state),
-    ...templateDeclarations,
-    ...statements
-  ]);
-  const generated = ts.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.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.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.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.createSourceFile(filename, generated, ts.ScriptTarget.Latest, true, ts.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.isSourceFile(node) || ts.isBlock(node) || ts.isModuleBlock(node)) return node.statements;
-  if (ts.isCaseClause(node) || ts.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.forEachChild(original, (node) => {
-    originalChildren.push(node);
-  });
-  ts.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 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 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.visitEachChild(replacement ?? node, visit, transformContext);
-    }, "visit");
-    return ts.visitNode(root, visit);
-  }, "transformer");
-  const result = ts.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.isIdentifier(node) && isBindingName(node)) names.add(node.text);
-    ts.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.isImportDeclaration(statement) || !ts.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.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.isImportDeclaration(node)) return;
-    if (ts.isIdentifier(node) && isBindingName(node)) names.add(node.text);
-    ts.forEachChild(node, visit);
-  }, "visit");
-  visit(sourceFile);
-  return names;
-}
-__name(collectLocallyDeclaredNames, "collectLocallyDeclaredNames");
-function isBindingName(node) {
-  const parent = node.parent;
-  if (!parent) return false;
-  if (ts.isPropertyAccessExpression(parent) && parent.name === node) return false;
-  if (ts.isQualifiedName(parent) && parent.right === node) return false;
-  if (ts.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.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.factory.createImportSpecifier(
-      false,
-      alias === name ? void 0 : ts.factory.createIdentifier(name),
-      ts.factory.createIdentifier(alias)
-    ));
-    modules.set(module, imported);
-  }
-  return [...modules.entries()].map(([module, imported]) => ts.factory.createImportDeclaration(
-    void 0,
-    ts.factory.createImportClause(
-      false,
-      void 0,
-      ts.factory.createNamedImports(imported)
-    ),
-    ts.factory.createStringLiteral(module)
-  ));
-}
-__name(createRuntimeImports, "createRuntimeImports");
-function rebuildImport(state, node) {
-  if (!ts.isStringLiteral(node.moduleSpecifier)) return node;
-  return tagStatement(state, ts.factory.createImportDeclaration(
-    node.modifiers,
-    node.importClause,
-    ts.factory.createStringLiteral(node.moduleSpecifier.text),
-    node.attributes
-  ), node);
-}
-__name(rebuildImport, "rebuildImport");
-function transformStatement(state, node) {
-  if (ts.isFunctionDeclaration(node) && node.body) {
-    return tagStatement(state, ts.factory.updateFunctionDeclaration(
-      node,
-      node.modifiers,
-      node.asteriskToken,
-      node.name,
-      node.typeParameters,
-      node.parameters,
-      node.type,
-      transformBlock(state, node.body)
-    ), node);
-  }
-  if (ts.isVariableStatement(node)) return transformVariableStatement(state, node);
-  if (ts.isExportAssignment(node) && containsJsx(node.expression)) {
-    return tagStatement(state, ts.factory.updateExportAssignment(node, node.modifiers, transformEmbeddedExpression(state, node.expression)), node);
-  }
-  if (ts.isExpressionStatement(node) && containsJsx(node.expression)) {
-    return tagStatement(state, ts.factory.updateExpressionStatement(node, transformEmbeddedExpression(state, node.expression)), node);
-  }
-  if (ts.isReturnStatement(node) && node.expression && containsJsx(node.expression)) {
-    return tagStatement(state, ts.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.factory.updateVariableDeclaration(
-      declaration,
-      declaration.name,
-      declaration.exclamationToken,
-      declaration.type,
-      nextInitializer
-    );
-  });
-  if (!changed) return node;
-  return tagStatement(state, ts.factory.updateVariableStatement(
-    node,
-    node.modifiers,
-    ts.factory.updateVariableDeclarationList(node.declarationList, declarations)
-  ), node);
-}
-__name(transformVariableStatement, "transformVariableStatement");
-function inferStateDebugName(state, declaration, initializer) {
-  if (state.stateAliases.size === 0) return void 0;
-  if (!ts.isIdentifier(declaration.name)) return void 0;
-  let call = initializer;
-  while (ts.isParenthesizedExpression(call) || ts.isAsExpression(call) || ts.isTypeAssertionExpression(call) || ts.isSatisfiesExpression(call)) {
-    call = call.expression;
-  }
-  if (!ts.isCallExpression(call)) return void 0;
-  const callee = call.expression;
-  if (!ts.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.factory.createCallExpression(callee, call.typeArguments, [
-    ...call.arguments,
-    ts.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.forEachChild(node, visit);
-  }, "visit");
-  visit(expression);
-  return found;
-}
-__name(containsJsx, "containsJsx");
-function transformBlock(state, block) {
-  const statements = block.statements.map((statement) => {
-    if (!ts.isReturnStatement(statement) || !statement.expression) return transformStatement(state, statement);
-    const expression = ts.isParenthesizedExpression(statement.expression) ? statement.expression.expression : statement.expression;
-    return isJsxExpression(expression) ? tagStatement(state, ts.factory.updateReturnStatement(statement, transformJsxExpression(state, expression)), statement) : statement;
-  });
-  return ts.factory.updateBlock(block, statements);
-}
-__name(transformBlock, "transformBlock");
-function isJsxExpression(node) {
-  return ts.isJsxElement(node) || ts.isJsxSelfClosingElement(node) || ts.isJsxFragment(node);
-}
-__name(isJsxExpression, "isJsxExpression");
-function transformJsxExpression(state, node) {
-  if (ts.isJsxFragment(node)) return transformFragment(state, node.children);
-  if (ts.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.isIdentifier(tagName)) {
-    reportUnsupportedTag(state, tagName);
-  }
-  if (ts.isIdentifier(tagName) && tagName.text === "ResourceBoundary") {
-    return transformResourceBoundary(state, node, attributes, children);
-  }
-  if (ts.isIdentifier(tagName) && tagName.text === "AsyncBoundary") {
-    return transformAsyncBoundary(state, node, attributes, children);
-  }
-  if (ts.isIdentifier(tagName) && tagName.text === "ErrorBoundary") {
-    return transformErrorBoundary(state, node, attributes, children);
-  }
-  if (ts.isIdentifier(tagName) && tagName.text === "Profiler") {
-    return transformProfiler(state, node, attributes, children);
-  }
-  if (ts.isIdentifier(tagName) && /^[A-Z]/.test(tagName.text)) {
-    const args = [
-      ts.factory.createCallExpression(helperRef(state, "resolveComponent"), void 0, [
-        tagName,
-        ts.factory.createStringLiteral(state.filename),
-        ts.factory.createStringLiteral(tagName.text)
-      ]),
-      createComponentProps(state, attributes, children)
-    ];
-    if (state.sourceLocation) args.push(createSourceLocation(tagName));
-    return ts.factory.createCallExpression(helperRef(state, "createComponent"), void 0, args);
-  }
-  if (isStaticElement(tagName, attributes, children)) {
-    return ts.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.factory.createCallExpression(
-        helperRef(state, "createElement"),
-        void 0,
-        [ts.factory.createStringLiteral(elementName)]
-      ),
-      node
-    )
-  ];
-  appendAttributes(state, statements, elementId, attributes);
-  appendChildren(state, statements, elementId, children);
-  statements.push(tagStatement(state, ts.factory.createReturnStatement(elementId), node));
-  return ts.factory.createCallExpression(
-    ts.factory.createArrowFunction(
-      void 0,
-      void 0,
-      [],
-      void 0,
-      ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
-      ts.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.factory.createCallExpression(
-    helperRef(state, "createFragment"),
-    void 0,
-    [ts.factory.createArrowFunction(
-      void 0,
-      void 0,
-      [
-        ts.factory.createParameterDeclaration(void 0, void 0, parent),
-        ts.factory.createParameterDeclaration(void 0, void 0, anchor)
-      ],
-      void 0,
-      ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
-      ts.factory.createBlock(statements, true)
-    )]
-  );
-}
-__name(transformFragment, "transformFragment");
-function transformResourceBoundary(state, node, attributes, children) {
-  const resource = getAttributeExpression(attributes, "resource");
-  if (!resource) throw new 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.factory.createPropertyAssignment("resource", transformEmbeddedExpression(state, resource)),
-    ts.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 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.factory.createPropertyAssignment("children", createBoundaryFactory(state, children)),
-    ts.factory.createPropertyAssignment("fallback", transformEmbeddedExpression(state, fallback))
-  ]);
-}
-__name(transformErrorBoundary, "transformErrorBoundary");
-function transformAsyncBoundary(state, node, attributes, children) {
-  const promise = getAttributeExpression(attributes, "promise");
-  if (!promise) throw new 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.factory.createPropertyAssignment("promise", transformEmbeddedExpression(state, promise)),
-    ts.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.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.isJsxAttribute(attribute) && attribute.name.getText() === "id");
-  const id = idAttribute && ts.isJsxAttribute(idAttribute) && idAttribute.initializer && ts.isStringLiteral(idAttribute.initializer) ? ts.factory.createStringLiteral(idAttribute.initializer.text) : idAttribute && ts.isJsxAttribute(idAttribute) && idAttribute.initializer && ts.isJsxExpression(idAttribute.initializer) ? idAttribute.initializer.expression : null;
-  if (!id) throw new 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.factory.createPropertyAssignment("id", transformEmbeddedExpression(state, id)),
-    ts.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.factory.createCallExpression(
-    helperRef(state, "createFragment"),
-    void 0,
-    [ts.factory.createArrowFunction(
-      void 0,
-      void 0,
-      [
-        ts.factory.createParameterDeclaration(void 0, void 0, parent),
-        ts.factory.createParameterDeclaration(void 0, void 0, anchor)
-      ],
-      void 0,
-      ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
-      ts.factory.createBlock([callStatement(state, helper, [
-        parent,
-        anchor,
-        ts.factory.createObjectLiteralExpression(options, true)
-      ], node)], true)
-    )]
-  );
-}
-__name(createBoundaryFragment, "createBoundaryFragment");
-function createBoundaryFactory(state, children) {
-  const content = transformFragment(state, children);
-  return ts.factory.createArrowFunction(
-    void 0,
-    void 0,
-    [],
-    void 0,
-    ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
-    content
-  );
-}
-__name(createBoundaryFactory, "createBoundaryFactory");
-function createAsyncFactory(state, children) {
-  const value = ts.factory.createIdentifier("value");
-  const expressionChild = children.length === 1 && children[0].kind === ts.SyntaxKind.JsxExpression ? children[0].expression : void 0;
-  if (expressionChild && ts.isArrowFunction(expressionChild)) {
-    const transformed = transformEmbeddedExpression(state, expressionChild);
-    return transformed;
-  }
-  const content = transformFragment(state, children);
-  return ts.factory.createArrowFunction(void 0, void 0, [
-    ts.factory.createParameterDeclaration(void 0, void 0, value)
-  ], void 0, ts.factory.createToken(ts.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.factory.createPropertyAssignment(name, value));
-  }
-}
-__name(appendBoundaryOptionalProperty, "appendBoundaryOptionalProperty");
-function getAttributeExpression(attributes, name) {
-  for (const attribute of attributes.properties) {
-    if (!ts.isJsxAttribute(attribute) || attribute.name.getText() !== name) continue;
-    if (attribute.initializer && ts.isJsxExpression(attribute.initializer)) {
-      return attribute.initializer.expression ?? null;
-    }
-  }
-  return null;
-}
-__name(getAttributeExpression, "getAttributeExpression");
-function transformEmbeddedExpression(state, expression) {
-  const result = ts.transform(expression, [(context) => (root) => {
-    const visit = /* @__PURE__ */ __name((node) => {
-      if (ts.isJsxElement(node) || ts.isJsxSelfClosingElement(node) || ts.isJsxFragment(node)) {
-        return transformJsxExpression(state, node);
-      }
-      return ts.visitEachChild(node, visit, context);
-    }, "visit");
-    return ts.visitNode(root, visit);
-  }]);
-  try {
-    return result.transformed[0];
-  } finally {
-    result.dispose();
-  }
-}
-__name(transformEmbeddedExpression, "transformEmbeddedExpression");
-function isStaticElement(tagName, attributes, children) {
-  if (!ts.isIdentifier(tagName) || !/^[a-z]/.test(tagName.text)) return false;
-  for (const attribute of attributes.properties) {
-    if (ts.isJsxSpreadAttribute(attribute)) return false;
-    if (!ts.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.isStringLiteral(initializer)) return false;
-  }
-  for (const child of children) {
-    if (ts.isJsxText(child)) continue;
-    if (ts.isJsxElement(child) || ts.isJsxSelfClosingElement(child)) {
-      const nested = ts.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.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.isJsxAttribute(attribute)) continue;
-    const attributeName = attribute.name.getText() === "className" ? "class" : attribute.name.getText();
-    const initializer = attribute.initializer;
-    if (!initializer) {
-      html += ` ${attributeName}=""`;
-      continue;
-    }
-    if (ts.isStringLiteral(initializer)) {
-      html += ` ${attributeName}="${escapeHtmlAttribute(initializer.text)}"`;
-    }
-  }
-  html += ">";
-  for (const child of children) {
-    if (ts.isJsxText(child)) {
-      const text = child.text.replace(/\s+/g, " ").trimStart();
-      if (text.trim()) html += escapeHtmlText(text);
-      continue;
-    }
-    if (ts.isJsxElement(child)) {
-      html += serializeStaticElement(
-        child.openingElement.tagName,
-        child.openingElement.attributes,
-        child.children
-      );
-      continue;
-    }
-    if (ts.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.factory.createVariableStatement(void 0, ts.factory.createVariableDeclarationList([
-      ts.factory.createVariableDeclaration(identifier, void 0, void 0, ts.factory.createCallExpression(
-        helperRef(state, "createTemplate"),
-        void 0,
-        [ts.factory.createStringLiteral(html)]
-      ))
-    ], ts.NodeFlags.Const))
-  );
-}
-__name(createTemplateDeclarations, "createTemplateDeclarations");
-function appendAttributes(state, statements, element, attributes) {
-  const staticProps = [];
-  const hasSpread = attributes.properties.some((attribute) => ts.isJsxSpreadAttribute(attribute));
-  for (const attribute of attributes.properties) {
-    if (ts.isJsxSpreadAttribute(attribute)) {
-      statements.push(callStatement(state, "spreadProps", [element, transformEmbeddedExpression(state, attribute.expression)], attribute));
-      continue;
-    }
-    if (!ts.isJsxAttribute(attribute)) continue;
-    const name = attribute.name.getText();
-    if (name === "key") continue;
-    if (name === "ref") {
-      const initializer2 = attribute.initializer;
-      if (initializer2 && ts.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.isJsxExpression(initializer) && initializer.expression) {
-      statements.push(callStatement(state, "addEventListener", [
-        element,
-        ts.factory.createStringLiteral(name.slice(2).toLowerCase()),
-        initializer.expression
-      ], attribute));
-      continue;
-    }
-    if (!initializer) {
-      if (hasSpread) {
-        statements.push(callStatement(state, isPropertyAttribute(name) ? "setProperty" : "setAttribute", [element, ts.factory.createStringLiteral(isPropertyAttribute(name) ? name : name === "className" ? "class" : name), isPropertyAttribute(name) ? ts.factory.createTrue() : ts.factory.createStringLiteral("")], attribute));
-        continue;
-      }
-      if (isPropertyAttribute(name)) staticProps.push(createStaticProperty(name, ts.factory.createTrue()));
-      else staticProps.push(createStaticProperty(name === "className" ? "class" : name, ts.factory.createStringLiteral("")));
-      continue;
-    }
-    if (ts.isStringLiteral(initializer)) {
-      if (hasSpread) {
-        statements.push(callStatement(state, isPropertyAttribute(name) ? "setProperty" : "setAttribute", [element, ts.factory.createStringLiteral(isPropertyAttribute(name) ? name : name === "className" ? "class" : name), ts.factory.createStringLiteral(initializer.text)], attribute));
-        continue;
-      }
-      staticProps.push(createStaticProperty(
-        isPropertyAttribute(name) ? name : name === "className" ? "class" : name,
-        ts.factory.createStringLiteral(initializer.text)
-      ));
-      continue;
-    }
-    const attributeName = name === "className" ? "class" : name;
-    const propertyAttribute = isPropertyAttribute(name);
-    if (ts.isJsxExpression(initializer) && initializer.expression) {
-      statements.push(callStatement(state, propertyAttribute ? "bindProperty" : "bindAttribute", [
-        element,
-        ts.factory.createStringLiteral(propertyAttribute ? name : attributeName),
-        createGetter(initializer.expression)
-      ], attribute));
-    }
-  }
-  if (staticProps.length) statements.splice(1, 0, callStatement(state, "setStaticProps", [
-    element,
-    ts.factory.createObjectLiteralExpression(staticProps, true)
-  ], attributes));
-}
-__name(appendAttributes, "appendAttributes");
-function createStaticProperty(name, value) {
-  return ts.factory.createPropertyAssignment(ts.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.factory.createNull()) {
-  for (const child of children) {
-    if (ts.isJsxText(child)) {
-      const text = child.text.replace(/\s+/g, " ").trimStart();
-      if (text.trim()) {
-        statements.push(callStatement(state, "insertBefore", [
-          element,
-          ts.factory.createCallExpression(helperRef(state, "createText"), void 0, [
-            ts.factory.createStringLiteral(text)
-          ]),
-          anchor
-        ], child));
-      }
-      continue;
-    }
-    if (ts.isJsxElement(child) || ts.isJsxSelfClosingElement(child) || ts.isJsxFragment(child)) {
-      statements.push(callStatement(state, "insertBefore", [
-        element,
-        transformJsxExpression(state, child),
-        anchor
-      ], child));
-      continue;
-    }
-    if (child.kind === ts.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.isIdentifier(expression)) {
-        const textId = nextIdentifier(state, "_text");
-        statements.push(createConstStatement(state, textId, ts.factory.createCallExpression(helperRef(state, "createText"), void 0, [ts.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.isJsxSpreadAttribute(attribute)) {
-      properties.push(ts.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.factory.createPropertyAssignment(name, ts.factory.createTrue()));
-    } else if (ts.isStringLiteral(initializer)) {
-      properties.push(ts.factory.createPropertyAssignment(name, ts.factory.createStringLiteral(initializer.text)));
-    } else if (ts.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.factory.createArrayLiteralExpression(childExpressions)));
-  }
-  return ts.factory.createObjectLiteralExpression(properties, true);
-}
-__name(createComponentProps, "createComponentProps");
-function createSourceLocation(node) {
-  const sourceFile = node.getSourceFile();
-  const position = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
-  return ts.factory.createObjectLiteralExpression([
-    ts.factory.createPropertyAssignment("file", ts.factory.createStringLiteral(sourceFile.fileName)),
-    ts.factory.createPropertyAssignment("line", ts.factory.createNumericLiteral(position.line + 1)),
-    ts.factory.createPropertyAssignment("column", ts.factory.createNumericLiteral(position.character + 1))
-  ], true);
-}
-__name(createSourceLocation, "createSourceLocation");
-function transformDynamicExpression(state, expression) {
-  if (ts.isBinaryExpression(expression) && expression.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) {
-    const right = unwrapExpression(expression.right);
-    if (!isJsxExpression(right)) return null;
-    return createGetter(ts.factory.createConditionalExpression(
-      expression.left,
-      ts.factory.createToken(ts.SyntaxKind.QuestionToken),
-      transformJsxExpression(state, right),
-      ts.factory.createToken(ts.SyntaxKind.ColonToken),
-      ts.factory.createNull()
-    ));
-  }
-  if (ts.isConditionalExpression(expression)) {
-    const whenTrue = transformDynamicBranch(state, expression.whenTrue);
-    const whenFalse = transformDynamicBranch(state, expression.whenFalse);
-    if (!whenTrue && !whenFalse) return null;
-    return createGetter(ts.factory.createConditionalExpression(
-      expression.condition,
-      ts.factory.createToken(ts.SyntaxKind.QuestionToken),
-      whenTrue ?? ts.factory.createNull(),
-      ts.factory.createToken(ts.SyntaxKind.ColonToken),
-      whenFalse ?? ts.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.SyntaxKind.NullKeyword || branch.kind === ts.SyntaxKind.FalseKeyword) return branch;
-  return null;
-}
-__name(transformDynamicBranch, "transformDynamicBranch");
-function transformListExpression(state, parent, expression, anchor) {
-  if (!ts.isCallExpression(expression) || expression.arguments.length !== 1) return null;
-  if (!ts.isPropertyAccessExpression(expression.expression) || expression.expression.name.text !== "map") return null;
-  const callback = expression.arguments[0];
-  if (!ts.isArrowFunction(callback) && !ts.isFunctionExpression(callback)) return null;
-  const body = unwrapExpression(callback.body);
-  if (!isJsxExpression(body) || ts.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.isArrowFunction(callback)) {
-    return ts.factory.updateArrowFunction(
-      callback,
-      callback.modifiers,
-      callback.typeParameters,
-      callback.parameters,
-      callback.type,
-      callback.equalsGreaterThanToken,
-      body
-    );
-  }
-  return ts.factory.updateFunctionExpression(
-    callback,
-    callback.modifiers,
-    callback.asteriskToken,
-    callback.name,
-    callback.typeParameters,
-    callback.parameters,
-    callback.type,
-    ts.factory.createBlock([ts.factory.createReturnStatement(body)], true)
-  );
-}
-__name(transformListCallback, "transformListCallback");
-function createKeyCallback(callback, key) {
-  return ts.factory.createArrowFunction(
-    void 0,
-    void 0,
-    callback.parameters,
-    void 0,
-    ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
-    key
-  );
-}
-__name(createKeyCallback, "createKeyCallback");
-function findKeyExpression(node) {
-  const attributes = ts.isJsxElement(node) ? node.openingElement.attributes : node.attributes;
-  for (const attribute of attributes.properties) {
-    if (!ts.isJsxAttribute(attribute) || attribute.name.getText() !== "key") continue;
-    if (attribute.initializer && ts.isJsxExpression(attribute.initializer)) {
-      return attribute.initializer.expression ?? null;
-    }
-  }
-  return null;
-}
-__name(findKeyExpression, "findKeyExpression");
-function unwrapExpression(node) {
-  return ts.isParenthesizedExpression(node) ? node.expression : node;
-}
-__name(unwrapExpression, "unwrapExpression");
-function childToComponentExpression(state, child) {
-  if (ts.isJsxText(child)) {
-    const text = child.text.replace(/\s+/g, " ").trim();
-    return text ? [ts.factory.createStringLiteral(text)] : [];
-  }
-  if (ts.isJsxElement(child) || ts.isJsxSelfClosingElement(child) || ts.isJsxFragment(child)) {
-    return [transformJsxExpression(state, child)];
-  }
-  if (child.kind === ts.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.factory.createIdentifier(name) : ts.factory.createStringLiteral(name);
-}
-__name(propertyName, "propertyName");
-function createGetter(expression) {
-  return ts.factory.createArrowFunction(
-    void 0,
-    void 0,
-    [],
-    void 0,
-    ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
-    expression
-  );
-}
-__name(createGetter, "createGetter");
-function createGetterProperty(name, expression) {
-  return ts.factory.createGetAccessorDeclaration(
-    void 0,
-    typeof name === "string" ? propertyName(name) : name,
-    [],
-    void 0,
-    ts.factory.createBlock([ts.factory.createReturnStatement(expression)], true)
-  );
-}
-__name(createGetterProperty, "createGetterProperty");
-function callStatement(state, name, args, source) {
-  const statement = ts.factory.createExpressionStatement(
-    ts.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.factory.createVariableStatement(
-    void 0,
-    ts.factory.createVariableDeclarationList([
-      ts.factory.createVariableDeclaration(name, void 0, void 0, initializer)
-    ], ts.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.factory.createIdentifier(name);
-}
-__name(nextIdentifier, "nextIdentifier");
-function createI18nExtractor(options = {}) {
-  const names = new Set(options.functions ?? ["t"]);
-  const keys = /* @__PURE__ */ new Set();
-  const plugin = {
-    name: "i18n-extractor",
-    analyze(program, context) {
-      const visit = /* @__PURE__ */ __name((node) => {
-        if (ts.isCallExpression(node) && isTranslationCall(node.expression, names)) {
-          const key = readStaticKey(node.arguments[0]);
-          if (key) {
-            keys.add(key);
-            options.onKey?.(key, context.filename);
-          }
-        }
-        ts.forEachChild(node, visit);
-      }, "visit");
-      visit(program);
-    }
-  };
-  return {
-    plugin,
-    getKeys: /* @__PURE__ */ __name(() => [...keys].sort(), "getKeys"),
-    reset: /* @__PURE__ */ __name(() => keys.clear(), "reset")
-  };
-}
-__name(createI18nExtractor, "createI18nExtractor");
-function isTranslationCall(expression, names) {
-  if (ts.isIdentifier(expression)) return names.has(expression.text);
-  return ts.isPropertyAccessExpression(expression) && names.has(expression.name.text);
-}
-__name(isTranslationCall, "isTranslationCall");
-function readStaticKey(argument) {
-  if (!argument) return void 0;
-  if (ts.isStringLiteral(argument) || ts.isNoSubstitutionTemplateLiteral(argument)) return argument.text;
-  return void 0;
-}
-__name(readStaticKey, "readStaticKey");
+
+// packages/vite-plugin/src/index.ts
+import { readFile } from "fs/promises";
+import path from "path";
+import { compileWithSourceMap, createI18nExtractor } from "@vobs/compiler";
+import { VobsError } from "@vobs/runtime/error";
+
+// packages/vite-plugin/src/html-component.ts
+import { parseFragment } from "parse5";
 var blockedTags = /* @__PURE__ */ new Set(["script", "iframe", "object", "embed", "base", "meta", "link", "style"]);
 var blockedAttributes = /^(?:on[a-z]+|srcdoc|style)$/iu;
 var urlAttributes = /* @__PURE__ */ new Set(["href", "src", "action", "formaction", "poster", "xlink:href"]);
@@ -1353,7 +221,7 @@ if (import.meta.hot) {
 `;
 }
 __name(createHmrCode, "createHmrCode");
-
-export { vobsPlugin };
-//# sourceMappingURL=index.js.map
+export {
+  vobsPlugin
+};
 //# sourceMappingURL=index.js.map