transone-cli 0.1.0 → 0.2.0

package/dist/build-mp-kcnx989m.js

@@ -0,0 +1,2795 @@
+// @bun
+import {
+  __require
+} from "./index-yb2wsc7f.js";
+
+// src/mp/build-mp.ts
+import { cp, mkdir, readdir, rm, writeFile } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { basename, dirname as dirname3, join as join3, relative, resolve as resolve2 } from "path";
+
+// src/mp/ts-loader.ts
+var tsModule = null;
+async function loadTypescript() {
+  if (tsModule) {
+    return tsModule;
+  }
+  tsModule = await import("typescript");
+  return tsModule;
+}
+
+// src/mp/analyze.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname, join, resolve } from "path";
+
+// src/mp/errors.ts
+class MpCompileError extends Error {
+  file;
+  constructor(file, message) {
+    super(`${message} (${file})`);
+    this.name = "MpCompileError";
+    this.file = file;
+  }
+}
+function mpError(file, message) {
+  return new MpCompileError(file, message);
+}
+
+// src/mp/fold.ts
+function foldExpression(ts, node, consts, seen = new Set) {
+  node = unwrapParentheses(ts, node);
+  if (ts.isStringLiteral(node)) {
+    return node.text;
+  }
+  if (ts.isNoSubstitutionTemplateLiteral(node)) {
+    if (node.text.includes("{{")) {
+      return;
+    }
+    return node.text;
+  }
+  if (ts.isNumericLiteral(node)) {
+    return Number(node.text);
+  }
+  if (node.kind === ts.SyntaxKind.TrueKeyword) {
+    return true;
+  }
+  if (node.kind === ts.SyntaxKind.FalseKeyword) {
+    return false;
+  }
+  if (node.kind === ts.SyntaxKind.NullKeyword) {
+    return null;
+  }
+  if (ts.isPrefixUnaryExpression(node)) {
+    const operand = foldExpression(ts, node.operand, consts, seen);
+    if (operand === undefined) {
+      return;
+    }
+    if (node.operator === ts.SyntaxKind.MinusToken) {
+      return typeof operand === "number" ? -operand : undefined;
+    }
+    if (node.operator === ts.SyntaxKind.PlusToken) {
+      return typeof operand === "number" ? operand : undefined;
+    }
+    if (node.operator === ts.SyntaxKind.ExclamationToken) {
+      return !operand;
+    }
+    return;
+  }
+  if (ts.isBinaryExpression(node)) {
+    const left = foldExpression(ts, node.left, consts, seen);
+    const right = foldExpression(ts, node.right, consts, seen);
+    if (left === undefined || right === undefined) {
+      return;
+    }
+    return foldBinary(ts, node.operatorToken.kind, left, right);
+  }
+  if (ts.isConditionalExpression(node)) {
+    const condition = foldExpression(ts, node.condition, consts, seen);
+    if (typeof condition !== "boolean") {
+      return;
+    }
+    return condition ? foldExpression(ts, node.whenTrue, consts, seen) : foldExpression(ts, node.whenFalse, consts, seen);
+  }
+  if (ts.isArrayLiteralExpression(node)) {
+    const items = [];
+    for (const element of node.elements) {
+      if (ts.isSpreadElement(element)) {
+        const spread = foldExpression(ts, element.expression, consts, seen);
+        if (!Array.isArray(spread)) {
+          return;
+        }
+        items.push(...spread);
+        continue;
+      }
+      const value = foldExpression(ts, element, consts, seen);
+      if (value === undefined) {
+        return;
+      }
+      items.push(value);
+    }
+    return items;
+  }
+  if (ts.isObjectLiteralExpression(node)) {
+    const result = {};
+    for (const property of node.properties) {
+      if (ts.isPropertyAssignment(property)) {
+        const key = propertyNameText(ts, property.name);
+        const value = foldExpression(ts, property.initializer, consts, seen);
+        if (key === undefined || value === undefined) {
+          return;
+        }
+        result[key] = value;
+        continue;
+      }
+      if (ts.isShorthandPropertyAssignment(property) && ts.isIdentifier(property.name)) {
+        const initializer = consts.get(property.name.text);
+        if (!initializer) {
+          return;
+        }
+        const value = foldExpression(ts, initializer, consts, seen);
+        if (value === undefined) {
+          return;
+        }
+        result[property.name.text] = value;
+        continue;
+      }
+      return;
+    }
+    return result;
+  }
+  if (ts.isIdentifier(node)) {
+    if (seen.has(node.text)) {
+      return;
+    }
+    const initializer = consts.get(node.text);
+    if (!initializer) {
+      return;
+    }
+    seen.add(node.text);
+    const value = foldExpression(ts, initializer, consts, seen);
+    seen.delete(node.text);
+    return value;
+  }
+  if (ts.isPropertyAccessExpression(node)) {
+    const base = foldExpression(ts, node.expression, consts, seen);
+    if (base === undefined) {
+      return;
+    }
+    if (Array.isArray(base)) {
+      if (node.name.text === "length") {
+        return base.length;
+      }
+      return;
+    }
+    if (typeof base === "object" && base !== null) {
+      return base[node.name.text];
+    }
+    return;
+  }
+  if (ts.isElementAccessExpression(node)) {
+    const base = foldExpression(ts, node.expression, consts, seen);
+    const index = foldExpression(ts, node.argumentExpression, consts, seen);
+    if (!Array.isArray(base) || typeof index !== "number") {
+      return;
+    }
+    return base[index];
+  }
+  if (ts.isTemplateExpression(node)) {
+    let result = "";
+    if (node.head.text !== "") {
+      result += node.head.text;
+    }
+    for (const span of node.templateSpans) {
+      const value = foldExpression(ts, span.expression, consts, seen);
+      if (value === undefined) {
+        return;
+      }
+      result += String(value);
+      result += span.literal.text;
+    }
+    return result;
+  }
+  return;
+}
+function foldBinary(ts, operator, left, right) {
+  switch (operator) {
+    case ts.SyntaxKind.PlusToken:
+      return `${left}${right}`;
+    case ts.SyntaxKind.MinusToken:
+      return left - right;
+    case ts.SyntaxKind.AsteriskToken:
+      return left * right;
+    case ts.SyntaxKind.SlashToken:
+      return left / right;
+    case ts.SyntaxKind.PercentToken:
+      return left % right;
+    case ts.SyntaxKind.EqualsEqualsEqualsToken:
+      return left === right;
+    case ts.SyntaxKind.ExclamationEqualsEqualsToken:
+      return left !== right;
+    case ts.SyntaxKind.LessThanToken:
+      return left < right;
+    case ts.SyntaxKind.LessThanEqualsToken:
+      return left <= right;
+    case ts.SyntaxKind.GreaterThanToken:
+      return left > right;
+    case ts.SyntaxKind.GreaterThanEqualsToken:
+      return left >= right;
+    case ts.SyntaxKind.AmpersandAmpersandToken:
+      return Boolean(left) && Boolean(right);
+    case ts.SyntaxKind.BarBarToken:
+      return Boolean(left) || Boolean(right);
+    default:
+      return;
+  }
+}
+function propertyNameText(ts, name) {
+  if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) {
+    return name.text;
+  }
+  return;
+}
+function unwrapParentheses(ts, node) {
+  let current = node;
+  while (ts.isParenthesizedExpression(current)) {
+    current = current.expression;
+  }
+  return current;
+}
+function isThisExpression(ts, node) {
+  return node.kind === ts.SyntaxKind.ThisKeyword;
+}
+
+// src/mp/analyze.ts
+function readSource(context, filePath) {
+  const cached = context.files.get(filePath);
+  if (cached) {
+    return cached;
+  }
+  if (!existsSync(filePath)) {
+    throw mpError(filePath, "\u6E90\u6587\u4EF6\u4E0D\u5B58\u5728");
+  }
+  const text = readFileSync(filePath, "utf8");
+  const source = context.ts.createSourceFile(filePath, text, context.ts.ScriptTarget.Latest, true, context.ts.ScriptKind.TS);
+  context.files.set(filePath, source);
+  return source;
+}
+function findRootClass(context, filePath) {
+  const { ts } = context;
+  const source = readSource(context, filePath);
+  const imports = collectImports(context.ts, source);
+  const localClasses = collectLocalClasses(context.ts, source);
+  for (const expression of topLevelExpressions(ts, source)) {
+    if (!context.ts.isCallExpression(expression)) {
+      continue;
+    }
+    const calleeName = callName(context.ts, expression.expression);
+    const isCreateApp = calleeName === "createApp" || calleeName !== undefined && imports.get(calleeName)?.importedName === "createApp";
+    if (!isCreateApp) {
+      continue;
+    }
+    const rootExpr = createAppRoot(context.ts, expression);
+    if (!rootExpr) {
+      continue;
+    }
+    return resolveClassReference(context, { filePath, source }, rootExpr);
+  }
+  for (const statement of source.statements) {
+    if (!context.ts.isClassDeclaration(statement)) {
+      continue;
+    }
+    const name = statement.name?.text;
+    if (!name || !isExported(context.ts, statement)) {
+      continue;
+    }
+    if (isComponentSubclass(context, {
+      filePath,
+      source,
+      declaration: statement,
+      className: name
+    })) {
+      return {
+        filePath,
+        source,
+        declaration: statement,
+        className: name
+      };
+    }
+  }
+  for (const [name, declaration] of localClasses) {
+    if (isComponentSubclass(context, {
+      filePath,
+      source,
+      declaration,
+      className: name
+    })) {
+      return { filePath, source, declaration, className: name };
+    }
+  }
+  throw mpError(filePath, "\u672A\u627E\u5230\u53EF\u7F16\u8BD1\u7684\u9875\u9762\u7EC4\u4EF6\uFF1A\u9700\u8981 createApp({ root }) \u6216\u5BFC\u51FA\u7684 Component \u5B50\u7C7B");
+}
+function resolveClassReference(context, from, expr) {
+  const { ts } = context;
+  expr = unwrapParentheses(ts, expr);
+  if (ts.isClassExpression(expr) || ts.isClassDeclaration(expr)) {
+    const name2 = expr.name?.text;
+    if (!name2) {
+      throw mpError(from.filePath, "\u533F\u540D\u7EC4\u4EF6\u7C7B\u4E0D\u652F\u6301\u7F16\u8BD1\u5230\u5C0F\u7A0B\u5E8F");
+    }
+    return {
+      filePath: from.filePath,
+      source: from.source,
+      declaration: expr,
+      className: name2
+    };
+  }
+  if (!ts.isIdentifier(expr)) {
+    throw mpError(from.filePath, `\u7EC4\u4EF6\u5F15\u7528\u5FC5\u987B\u662F\u7C7B\u540D\u6216\u7C7B\u8868\u8FBE\u5F0F: ${expr.getText().slice(0, 60)}`);
+  }
+  const name = expr.text;
+  const local = collectLocalClasses(ts, from.source).get(name);
+  if (local) {
+    return {
+      filePath: from.filePath,
+      source: from.source,
+      declaration: local,
+      className: name
+    };
+  }
+  const imports = collectImports(ts, from.source);
+  const binding = imports.get(name);
+  if (binding) {
+    return resolveImportedClass(context, from, name, binding);
+  }
+  throw mpError(from.filePath, `\u65E0\u6CD5\u89E3\u6790\u7EC4\u4EF6\u6807\u8BC6\u7B26 "${name}"`);
+}
+function isComponentSubclass(context, classSource) {
+  const { ts } = context;
+  const heritage = classSource.declaration.heritageClauses ?? [];
+  const imports = collectImports(ts, classSource.source);
+  for (const clause of heritage) {
+    if (clause.token !== ts.SyntaxKind.ExtendsKeyword) {
+      continue;
+    }
+    for (const type of clause.types) {
+      if (!ts.isExpressionWithTypeArguments(type)) {
+        continue;
+      }
+      const expression = unwrapParentheses(ts, type.expression);
+      if (!ts.isIdentifier(expression)) {
+        continue;
+      }
+      const binding = imports.get(expression.text);
+      if (binding && binding.specifier.includes("transone")) {
+        return true;
+      }
+      if (expression.text === "Component") {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function resolveImportedClass(context, from, localName, binding) {
+  if (binding.specifier.startsWith(".")) {
+    const targetPath = resolveImportPath(from.filePath, binding.specifier);
+    if (!targetPath) {
+      throw mpError(from.filePath, `\u627E\u4E0D\u5230\u5BFC\u5165\u6587\u4EF6 "${binding.specifier}"\uFF08\u76F8\u5BF9 ${from.filePath}\uFF09`);
+    }
+    const source = readSource(context, targetPath);
+    const importedName = binding.importedName;
+    const found = findExportedClass(context, source, importedName, new Set);
+    if (!found) {
+      throw mpError(targetPath, `\u627E\u4E0D\u5230\u5BFC\u51FA\u7684\u7EC4\u4EF6\u7C7B "${importedName}"\uFF08\u4ECE ${localName} \u5BFC\u5165\uFF09`);
+    }
+    return {
+      filePath: found.filePath,
+      source: readSource(context, found.filePath),
+      declaration: found.declaration,
+      className: importedName
+    };
+  }
+  return resolvePackageClass(context, from, localName, binding);
+}
+function resolvePackageClass(context, from, localName, binding) {
+  const packageInfo = findPackageInfo(from.filePath, binding.specifier);
+  if (!packageInfo) {
+    throw mpError(from.filePath, `\u65E0\u6CD5\u89E3\u6790\u7EC4\u4EF6\u6765\u6E90 "${binding.specifier}"\uFF1A\u627E\u4E0D\u5230 node_modules \u5305\uFF08\u4EC5\u652F\u6301\u76F8\u5BF9\u8DEF\u5F84\u6216\u5DF2\u5B89\u88C5\u7684\u5305\uFF09`);
+  }
+  const sourceField = packageInfo.source;
+  if (typeof sourceField !== "string" || sourceField.length === 0) {
+    throw mpError(from.filePath, `\u5305 "${binding.specifier}" \u7F3A\u5C11 "source" \u5B57\u6BB5\uFF1A\u5C0F\u7A0B\u5E8F\u7F16\u8BD1\u9700\u8981\u53EF\u5206\u6790\u7684 TS \u6E90\u7801\u5165\u53E3\uFF08\u5728 package.json \u58F0\u660E "source": "./lib/index.ts"\uFF09`);
+  }
+  const targetPath = resolvePackageSource(packageInfo.dir, sourceField);
+  if (!targetPath) {
+    throw mpError(from.filePath, `\u5305 "${binding.specifier}" \u7684 "source" \u6307\u5411\u7684\u6587\u4EF6\u4E0D\u5B58\u5728: ${sourceField}`);
+  }
+  const source = readSource(context, targetPath);
+  const importedName = binding.importedName;
+  const found = findExportedClass(context, source, importedName, new Set);
+  if (!found) {
+    throw mpError(targetPath, `\u627E\u4E0D\u5230\u5BFC\u51FA\u7684\u7EC4\u4EF6\u7C7B "${importedName}"\uFF08\u4ECE ${localName} \u5BFC\u5165\uFF0C\u5305 "${binding.specifier}"\uFF09`);
+  }
+  return {
+    filePath: found.filePath,
+    source: readSource(context, found.filePath),
+    declaration: found.declaration,
+    className: importedName
+  };
+}
+function findPackageInfo(fromFile, specifier) {
+  const segments = specifier.split("/");
+  const packageJsonRelative = join("node_modules", ...segments, "package.json");
+  let current = dirname(fromFile);
+  for (;; ) {
+    const candidate = join(current, packageJsonRelative);
+    if (existsSync(candidate)) {
+      try {
+        const json = JSON.parse(readFileSync(candidate, "utf8"));
+        return { dir: join(current, "node_modules", ...segments), source: json.source };
+      } catch {
+        return;
+      }
+    }
+    const parent = dirname(current);
+    if (parent === current) {
+      return;
+    }
+    current = parent;
+  }
+}
+function resolvePackageSource(packageDir, sourceField) {
+  const base = resolve(packageDir, sourceField);
+  const candidates = [base, `${base}.ts`, `${base}.tsx`];
+  return candidates.find((candidate) => existsSync(candidate));
+}
+function findExportedClass(context, source, name, seen) {
+  const { ts } = context;
+  if (seen.has(source.fileName)) {
+    return;
+  }
+  seen.add(source.fileName);
+  for (const statement of source.statements) {
+    if (ts.isClassDeclaration(statement) && statement.name?.text === name) {
+      if (isExported(ts, statement)) {
+        return { filePath: source.fileName, declaration: statement };
+      }
+    }
+  }
+  for (const statement of source.statements) {
+    if (ts.isExportDeclaration(statement) && statement.exportClause && ts.isNamedExports(statement.exportClause)) {
+      for (const element of statement.exportClause.elements) {
+        if (element.name.text !== name) {
+          continue;
+        }
+        const local = collectLocalClasses(ts, source).get(name);
+        if (local) {
+          return { filePath: source.fileName, declaration: local };
+        }
+        if (!statement.moduleSpecifier) {
+          continue;
+        }
+        const specifier = statement.moduleSpecifier.getText().replace(/['"]/g, "");
+        if (!specifier.startsWith(".")) {
+          continue;
+        }
+        const targetPath = resolveImportPath(source.fileName, specifier);
+        if (!targetPath) {
+          continue;
+        }
+        const targetSource = readSource(context, targetPath);
+        const reExported = findExportedClass(context, targetSource, element.propertyName?.text ?? element.name.text, seen);
+        if (reExported) {
+          return reExported;
+        }
+      }
+    }
+  }
+  return;
+}
+function topLevelExpressions(ts, source) {
+  const expressions = [];
+  for (const statement of source.statements) {
+    if (ts.isExpressionStatement(statement)) {
+      expressions.push(statement.expression);
+      continue;
+    }
+    if (ts.isVariableStatement(statement)) {
+      for (const declaration of statement.declarationList.declarations) {
+        if (declaration.initializer) {
+          expressions.push(declaration.initializer);
+        }
+      }
+    }
+  }
+  return expressions;
+}
+function createAppRoot(ts, call) {
+  for (const argument of call.arguments) {
+    const object = unwrapParentheses(ts, argument);
+    if (!ts.isObjectLiteralExpression(object)) {
+      continue;
+    }
+    for (const property of object.properties) {
+      if (ts.isPropertyAssignment(property) && ts.isIdentifier(property.name) && property.name.text === "root") {
+        return property.initializer;
+      }
+    }
+  }
+  return;
+}
+function collectLocalClasses(ts, source) {
+  const classes = new Map;
+  for (const statement of source.statements) {
+    if (ts.isClassDeclaration(statement) && statement.name) {
+      classes.set(statement.name.text, statement);
+    }
+  }
+  return classes;
+}
+function collectImports(ts, source) {
+  const imports = new Map;
+  for (const statement of source.statements) {
+    if (!ts.isImportDeclaration(statement)) {
+      continue;
+    }
+    const specifier = statement.moduleSpecifier.getText().replace(/['"]/g, "");
+    const bindings = statement.importClause?.namedBindings;
+    if (!bindings) {
+      continue;
+    }
+    if (ts.isNamedImports(bindings)) {
+      for (const element of bindings.elements) {
+        imports.set(element.name.text, {
+          specifier,
+          importedName: element.propertyName?.text ?? element.name.text
+        });
+      }
+    } else if (ts.isNamespaceImport(bindings)) {
+      imports.set(bindings.name.text, { specifier, importedName: "*" });
+    }
+  }
+  return imports;
+}
+function resolveImportPath(fromFile, specifier) {
+  const base = resolve(dirname(fromFile), specifier);
+  const candidates = [
+    base,
+    `${base}.ts`,
+    `${base}.tsx`,
+    join(base, "index.ts"),
+    join(base, "index.tsx")
+  ];
+  return candidates.find((candidate) => existsSync(candidate));
+}
+function isExported(ts, declaration) {
+  return (declaration.modifiers ?? []).some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword);
+}
+function callName(ts, expression) {
+  expression = unwrapParentheses(ts, expression);
+  if (ts.isIdentifier(expression)) {
+    return expression.text;
+  }
+  if (ts.isPropertyAccessExpression(expression)) {
+    return expression.name.text;
+  }
+  return;
+}
+
+// src/mp/binding.ts
+function toBinding(context, node) {
+  const { ts } = context;
+  node = unwrapParentheses(ts, node);
+  if (ts.isPropertyAccessExpression(node)) {
+    const statePath = thisStatePath(ts, node);
+    if (statePath) {
+      return statePath;
+    }
+    const propsPath = thisPropsPath(ts, node);
+    if (propsPath) {
+      context.onProp?.(propsPath.split(".")[0]);
+      return propsPath;
+    }
+    const folded = foldExpression(ts, node, context.scope.consts);
+    if (folded !== undefined) {
+      return literalToBinding(folded);
+    }
+    const base = toBinding(context, node.expression);
+    if (!isPathLike(base)) {
+      throw mpError(context.filePath, `\u6A21\u677F\u8868\u8FBE\u5F0F\u4E0D\u652F\u6301\u8BE5\u5C5E\u6027\u8BBF\u95EE: ${node.getText()}`);
+    }
+    return `${base}.${node.name.text}`;
+  }
+  if (ts.isElementAccessExpression(node)) {
+    const folded = foldExpression(ts, node, context.scope.consts);
+    if (folded !== undefined) {
+      return literalToBinding(folded);
+    }
+    const base = toBinding(context, node.expression);
+    const index = toBinding(context, node.argumentExpression);
+    if (!isPathLike(base)) {
+      throw mpError(context.filePath, `\u6A21\u677F\u8868\u8FBE\u5F0F\u4E0D\u652F\u6301\u8BE5\u4E0B\u6807\u8BBF\u95EE: ${node.getText()}`);
+    }
+    return `${base}[${index}]`;
+  }
+  if (ts.isIdentifier(node)) {
+    const { params, locals, consts } = context.scope;
+    if (params.has(node.text)) {
+      return node.text;
+    }
+    if (locals.has(node.text)) {
+      return toBinding(context, locals.get(node.text));
+    }
+    if (consts.has(node.text)) {
+      const folded = foldExpression(ts, node, consts);
+      if (folded !== undefined) {
+        return literalToBinding(folded);
+      }
+      return toBinding(context, consts.get(node.text));
+    }
+    throw mpError(context.filePath, `\u65E0\u6CD5\u89E3\u6790\u6A21\u677F\u6807\u8BC6\u7B26 "${node.text}"`);
+  }
+  if (ts.isStringLiteral(node)) {
+    return singleQuoted(node.text);
+  }
+  if (ts.isNumericLiteral(node)) {
+    return node.text;
+  }
+  if (node.kind === ts.SyntaxKind.TrueKeyword) {
+    return "true";
+  }
+  if (node.kind === ts.SyntaxKind.FalseKeyword) {
+    return "false";
+  }
+  if (node.kind === ts.SyntaxKind.NullKeyword) {
+    return "null";
+  }
+  if (ts.isNoSubstitutionTemplateLiteral(node)) {
+    if (node.text.includes("{{")) {
+      return node.text;
+    }
+    return singleQuoted(node.text);
+  }
+  if (ts.isTemplateExpression(node)) {
+    const parts = [];
+    if (node.head.text !== "") {
+      parts.push(singleQuoted(node.head.text));
+    }
+    for (const span of node.templateSpans) {
+      parts.push(toBinding(context, span.expression));
+      if (span.literal.text !== "") {
+        parts.push(singleQuoted(span.literal.text));
+      }
+    }
+    return parts.join(" + ");
+  }
+  if (ts.isBinaryExpression(node)) {
+    return `(${toBinding(context, node.left)} ${node.operatorToken.getText()} ${toBinding(context, node.right)})`;
+  }
+  if (ts.isConditionalExpression(node)) {
+    return `(${toBinding(context, node.condition)} ? ${toBinding(context, node.whenTrue)} : ${toBinding(context, node.whenFalse)})`;
+  }
+  if (ts.isPrefixUnaryExpression(node)) {
+    const operator = ts.tokenToString(node.operator) ?? String(node.operator);
+    return `(${operator}${toBinding(context, node.operand)})`;
+  }
+  if (ts.isArrayLiteralExpression(node)) {
+    const folded = foldExpression(ts, node, context.scope.consts);
+    if (folded !== undefined) {
+      return literalToBinding(folded);
+    }
+    const items = node.elements.map((element) => toBinding(context, element));
+    return `[${items.join(", ")}]`;
+  }
+  if (ts.isObjectLiteralExpression(node)) {
+    const folded = foldExpression(ts, node, context.scope.consts);
+    if (folded !== undefined) {
+      return literalToBinding(folded);
+    }
+    throw mpError(context.filePath, `\u6A21\u677F\u8868\u8FBE\u5F0F\u4E2D\u7684\u5BF9\u8C61\u5B57\u9762\u91CF\u65E0\u6CD5\u9759\u6001\u6C42\u503C: ${node.getText()}`);
+  }
+  if (ts.isCallExpression(node)) {
+    throw mpError(context.filePath, `\u6A21\u677F\u8868\u8FBE\u5F0F\u4E0D\u652F\u6301\u51FD\u6570\u8C03\u7528\uFF08\u5982 ${node.getText()}\uFF09\uFF1AWXML \u65E0\u6CD5\u6267\u884C\u65B9\u6CD5\uFF0C\u8BF7\u5728\u65B9\u6CD5/state \u4E2D\u9884\u5148\u8BA1\u7B97\u683C\u5F0F\u5316\u7ED3\u679C`);
+  }
+  throw mpError(context.filePath, `\u4E0D\u652F\u6301\u7684\u6A21\u677F\u8868\u8FBE\u5F0F: ${node.getText() ?? node.kind}`);
+}
+function thisStatePath(ts, node) {
+  return thisMemberPath(ts, node, "state");
+}
+function thisPropsPath(ts, node) {
+  return thisMemberPath(ts, node, "props");
+}
+function thisMemberPath(ts, node, member) {
+  let current = node;
+  const parts = [];
+  while (ts.isPropertyAccessExpression(current)) {
+    parts.unshift(current.name.text);
+    current = current.expression;
+    if (ts.isPropertyAccessExpression(current) && isThisExpression(ts, current.expression)) {
+      if (current.name.text === member) {
+        return parts.join(".");
+      }
+      return;
+    }
+    if (ts.isElementAccessExpression(current)) {
+      if (!ts.isStringLiteral(current.argumentExpression) || !thisMemberBase(ts, current.expression)) {
+        return;
+      }
+      parts.unshift(current.argumentExpression.text);
+      current = current.expression;
+      if (ts.isPropertyAccessExpression(current) && current.name.text === member) {
+        return parts.join(".");
+      }
+      return;
+    }
+  }
+  return;
+}
+function thisMemberBase(ts, node) {
+  return ts.isPropertyAccessExpression(node) && isThisExpression(ts, node.expression);
+}
+function isPathLike(value) {
+  return /^[A-Za-z_$][\w$]*(\.[A-Za-z_$][\w$]*)*$/.test(value);
+}
+function literalToBinding(value) {
+  if (typeof value === "string") {
+    return singleQuoted(value);
+  }
+  if (typeof value === "number") {
+    return String(value);
+  }
+  if (typeof value === "boolean") {
+    return value ? "true" : "false";
+  }
+  if (value === null) {
+    return "null";
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map(literalToBinding).join(", ")}]`;
+  }
+  const entries = Object.entries(value).map(([key, item]) => `${key}: ${literalToBinding(item)}`);
+  return `{${entries.join(", ")}}`;
+}
+function singleQuoted(value) {
+  return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+}
+
+// src/mp/types.ts
+function warn(context, message) {
+  context.warnings.push(message);
+}
+
+// src/mp/wxml.ts
+var ELEMENT_FACTORIES = new Set([
+  "h",
+  "Tag",
+  "Div",
+  "Span",
+  "P",
+  "Button",
+  "Input",
+  "Section",
+  "Main",
+  "Header",
+  "Footer",
+  "Nav",
+  "Article",
+  "Aside",
+  "H1",
+  "H2",
+  "H3",
+  "H4",
+  "H5",
+  "H6",
+  "Strong",
+  "Em",
+  "Small",
+  "Pre",
+  "Code",
+  "Blockquote",
+  "Ul",
+  "Ol",
+  "Li",
+  "A",
+  "Img",
+  "Form",
+  "Label",
+  "Textarea",
+  "Select",
+  "Option",
+  "Table",
+  "Thead",
+  "Tbody",
+  "Tr",
+  "Th",
+  "Td"
+]);
+var SPECIAL_CALLS = new Set(["createComponent", "each", "slot"]);
+var TAG_MAP = {
+  div: "view",
+  section: "view",
+  main: "view",
+  header: "view",
+  footer: "view",
+  article: "view",
+  aside: "view",
+  nav: "view",
+  ul: "view",
+  ol: "view",
+  li: "view",
+  blockquote: "view",
+  pre: "view",
+  code: "view",
+  table: "view",
+  thead: "view",
+  tbody: "view",
+  tr: "view",
+  th: "view",
+  td: "view",
+  p: "view",
+  form: "form",
+  label: "label",
+  h1: "view",
+  h2: "view",
+  h3: "view",
+  h4: "view",
+  h5: "view",
+  h6: "view",
+  span: "text",
+  strong: "text",
+  em: "text",
+  small: "text",
+  button: "button",
+  input: "input",
+  textarea: "textarea",
+  img: "image",
+  a: "navigator",
+  view: "view",
+  text: "text",
+  image: "image",
+  navigator: "navigator",
+  "scroll-view": "scroll-view",
+  swiper: "swiper",
+  "swiper-item": "swiper-item",
+  picker: "picker",
+  "picker-view": "picker-view",
+  "picker-view-column": "picker-view-column",
+  switch: "switch",
+  checkbox: "checkbox",
+  "checkbox-group": "checkbox-group",
+  radio: "radio",
+  "radio-group": "radio-group",
+  slider: "slider",
+  progress: "progress",
+  icon: "icon",
+  "rich-text": "rich-text",
+  video: "video",
+  camera: "camera",
+  "live-player": "live-player",
+  "live-pusher": "live-pusher",
+  map: "map",
+  canvas: "canvas",
+  "cover-view": "cover-view",
+  "cover-image": "cover-image",
+  "movable-view": "movable-view",
+  "movable-area": "movable-area",
+  "web-view": "web-view",
+  ad: "ad",
+  "official-account": "official-account",
+  "open-data": "open-data",
+  scrollView: "scroll-view",
+  swiperItem: "swiper-item",
+  pickerView: "picker-view",
+  pickerViewColumn: "picker-view-column",
+  checkboxGroup: "checkbox-group",
+  radioGroup: "radio-group",
+  richText: "rich-text",
+  coverView: "cover-view",
+  coverImage: "cover-image",
+  movableView: "movable-view",
+  movableArea: "movable-area",
+  webView: "web-view",
+  livePlayer: "live-player",
+  officialAccount: "official-account",
+  openData: "open-data"
+};
+var EVENT_MAP = {
+  click: "tap",
+  tap: "tap",
+  longpress: "longpress",
+  longtap: "longtap",
+  input: "input",
+  change: "change",
+  cancel: "cancel",
+  submit: "submit",
+  focus: "focus",
+  blur: "blur",
+  confirm: "confirm",
+  load: "load",
+  error: "error",
+  scroll: "scroll",
+  scrolltoupper: "scrolltoupper",
+  scrolltolower: "scrolltolower",
+  scrollToUpper: "scrolltoupper",
+  scrollToLower: "scrolltolower",
+  refresherrefresh: "refresherrefresh",
+  refresherpulldown: "refresherpulldown",
+  refresherrestore: "refresherrestore",
+  refresherabort: "refresherabort",
+  touchstart: "touchstart",
+  touchmove: "touchmove",
+  touchend: "touchend",
+  touchcancel: "touchcancel",
+  touchforcechange: "touchforcechange",
+  transitionend: "transitionend",
+  animationfinish: "animationfinish",
+  animationfail: "animationfail",
+  getphonenumber: "getphonenumber",
+  getuserinfo: "getuserinfo",
+  getcontact: "getcontact",
+  openshare: "openshare",
+  launchapp: "launchapp",
+  message: "message"
+};
+var TAG_KEYS = new Set([
+  "props",
+  "children",
+  "listeners",
+  "key",
+  "directions"
+]);
+function notUndefined(ts, expression) {
+  return expression !== undefined && !(ts.isIdentifier(expression) && expression.text === "undefined");
+}
+function isEventProp(key) {
+  return /^on[A-Z]/.test(key) || /^on[a-z]/.test(key);
+}
+function eventNameFromProp(key) {
+  return key.slice(2).toLowerCase();
+}
+function compileTemplate(context, classSource, _kind, hoverSelectors = new Set) {
+  const { ts } = context;
+  const renderMethod = findMethod(context, classSource, "render");
+  if (!renderMethod) {
+    throw mpError(classSource.filePath, `\u7EC4\u4EF6 ${classSource.className} \u7F3A\u5C11 render() \u65B9\u6CD5`);
+  }
+  const body = renderMethod.body;
+  if (!body) {
+    throw mpError(classSource.filePath, "render() \u7F3A\u5C11\u65B9\u6CD5\u4F53");
+  }
+  const locals = new Map;
+  let returnStatement;
+  for (const statement of body.statements) {
+    if (ts.isVariableStatement(statement)) {
+      const isConst = statement.declarationList.flags & ts.NodeFlags.Const;
+      if (!isConst) {
+        throw mpError(classSource.filePath, "render() \u5185\u53EA\u652F\u6301 const \u5C40\u90E8\u53D8\u91CF\uFF08\u5C0F\u7A0B\u5E8F\u6A21\u677F\u662F\u9759\u6001\u7F16\u8BD1\u7684\uFF09");
+      }
+      for (const declaration of statement.declarationList.declarations) {
+        if (ts.isIdentifier(declaration.name) && declaration.initializer) {
+          locals.set(declaration.name.text, declaration.initializer);
+        }
+      }
+      continue;
+    }
+    if (ts.isReturnStatement(statement)) {
+      returnStatement = statement;
+      continue;
+    }
+    throw mpError(classSource.filePath, `render() \u5185\u4E0D\u652F\u6301\u7684\u8BED\u53E5\uFF08\u53EA\u652F\u6301 const \u58F0\u660E\u4E0E return\uFF09: ${statement.getText().slice(0, 60)}`);
+  }
+  if (!returnStatement?.expression) {
+    throw mpError(classSource.filePath, "render() \u5FC5\u987B\u4EE5 return \u8868\u8FBE\u5F0F\u7ED3\u675F");
+  }
+  const consts = collectModuleConsts(context, classSource);
+  const builder = {
+    handlers: new Set,
+    usedComponents: new Map,
+    propsReferenced: new Set,
+    customEvents: new Set,
+    emitters: []
+  };
+  const env = {
+    builder,
+    scope: { params: new Set, locals, consts },
+    indent: 0,
+    extraAttrs: [],
+    origins: collectFactoryOrigins(ts, classSource.source),
+    hoverSelectors
+  };
+  const lines = buildNodeLines(context, classSource, returnStatement.expression, env);
+  const header = `<!-- \u7531 transone build --target ${context.dialect.id} \u751F\u6210\uFF0C\u8BF7\u52FF\u624B\u52A8\u7F16\u8F91 -->`;
+  return {
+    template: [header, ...lines].join(`
+`) + `
+`,
+    builder
+  };
+}
+function buildNodeLines(context, classSource, node, env, depth = 0) {
+  if (depth > 64) {
+    throw mpError(classSource.filePath, "\u6A21\u677F\u5D4C\u5957\u8FC7\u6DF1\uFF08\u53EF\u80FD\u662F\u6807\u8BC6\u7B26\u5FAA\u73AF\u5F15\u7528\uFF09");
+  }
+  const { ts } = context;
+  node = unwrapParentheses(ts, node);
+  node = unwrapTypeAssertions(ts, node);
+  if (node.kind === ts.SyntaxKind.NullKeyword) {
+    return [];
+  }
+  if (ts.isCallExpression(node)) {
+    const localName = callName2(ts, node.expression);
+    const name = (localName && env.origins.get(localName)) ?? localName;
+    if (name === "createComponent") {
+      return compileComponentCall(context, classSource, node, env, depth);
+    }
+    if (name === "each") {
+      return compileEach(context, classSource, node, env, depth);
+    }
+    if (name === "slot") {
+      return compileSlot(context, classSource, node, env);
+    }
+    if (name && ELEMENT_FACTORIES.has(name)) {
+      return compileElementCall(context, classSource, node, env, depth);
+    }
+    throw mpError(classSource.filePath, `\u4E0D\u652F\u6301\u7684\u6E32\u67D3\u8C03\u7528 "${name ?? "?"}"\uFF08\u4EC5\u652F\u6301 h/Tag/\u5143\u7D20\u5FEB\u6377\u65B9\u5F0F/createComponent/each/slot\uFF09`);
+  }
+  if (ts.isIdentifier(node)) {
+    if (env.scope.params.has(node.text)) {
+      return [indent(env.indent) + `{{${node.text}}}`];
+    }
+    const replacement = resolveIdentifierExpression(context, classSource, node, env);
+    if (replacement) {
+      return buildNodeLines(context, classSource, replacement, env, depth + 1);
+    }
+    throw mpError(classSource.filePath, `\u65E0\u6CD5\u89E3\u6790\u6A21\u677F\u6807\u8BC6\u7B26 "${node.text}"`);
+  }
+  if (ts.isObjectLiteralExpression(node)) {
+    const componentProp = objectProperty(ts, node, "component");
+    if (componentProp) {
+      return compileComponentObject(context, classSource, node, env, depth);
+    }
+    throw mpError(classSource.filePath, `render() \u4E2D\u4E0D\u652F\u6301\u7684\u5BF9\u8C61\u5B57\u9762\u91CF: ${node.getText().slice(0, 60)}`);
+  }
+  if (ts.isConditionalExpression(node)) {
+    return compileConditional(context, classSource, node, env, depth);
+  }
+  if (ts.isBinaryExpression(node)) {
+    if (node.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) {
+      return compileLogicalAnd(context, classSource, node, env, depth);
+    }
+    throw mpError(classSource.filePath, `render() \u4E2D\u4E0D\u652F\u6301\u7684\u8868\u8FBE\u5F0F\uFF08\u6761\u4EF6\u6E32\u67D3\u8BF7\u7528\u4E09\u5143\u6216 &&\uFF09: ${node.getText().slice(0, 60)}`);
+  }
+  if (ts.isArrayLiteralExpression(node)) {
+    const lines = [];
+    for (const element of node.elements) {
+      if (ts.isSpreadElement(element)) {
+        throw mpError(classSource.filePath, "children \u4E2D\u4E0D\u652F\u6301\u5C55\u5F00\u8FD0\u7B97\u7B26");
+      }
+      lines.push(...buildNodeLines(context, classSource, element, env, depth));
+    }
+    return lines;
+  }
+  if (isTextNode(ts, node)) {
+    return [indent(env.indent) + textContent(context, classSource, node, env)];
+  }
+  if (ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node)) {
+    return [
+      indent(env.indent) + `{{${toBinding(bindingContext(context, classSource, env), node)}}}`
+    ];
+  }
+  throw mpError(classSource.filePath, `render() \u4E2D\u4E0D\u652F\u6301\u7684\u8282\u70B9: ${node.getText().slice(0, 60)}`);
+}
+function compileElementCall(context, classSource, node, env, depth) {
+  const { ts } = context;
+  const localName = callName2(ts, node.expression);
+  const name = env.origins.get(localName) ?? localName;
+  const args = node.arguments;
+  let tagExpr;
+  let propsExpr;
+  let childrenExpr;
+  let listenersExpr;
+  let directionsExpr;
+  if (name === "h" || name === "Tag") {
+    if (args.length === 0) {
+      throw mpError(classSource.filePath, `${name}() \u7F3A\u5C11\u6807\u7B7E\u53C2\u6570`);
+    }
+    tagExpr = args[0];
+    if (name === "Tag" && args.length >= 2 && ts.isObjectLiteralExpression(args[1])) {
+      const options = args[1];
+      propsExpr = objectProperty(ts, options, "props");
+      childrenExpr = objectProperty(ts, options, "children");
+      listenersExpr = objectProperty(ts, options, "listeners");
+      directionsExpr = objectProperty(ts, options, "directions");
+    } else {
+      propsExpr = args[1];
+      childrenExpr = args[2];
+      listenersExpr = notUndefined(ts, args[3]) ? args[3] : undefined;
+      directionsExpr = notUndefined(ts, args[5]) ? args[5] : undefined;
+    }
+  } else {
+    tagExpr = ts.factory.createStringLiteral(kebabCase(name));
+    const options = args[0];
+    if (options && ts.isObjectLiteralExpression(options)) {
+      propsExpr = objectProperty(ts, options, "props");
+      childrenExpr = objectProperty(ts, options, "children");
+      listenersExpr = objectProperty(ts, options, "listeners");
+      directionsExpr = objectProperty(ts, options, "directions");
+      const directProps = options.properties.filter((property) => ts.isPropertyAssignment(property) && ts.isIdentifier(property.name) && !TAG_KEYS.has(property.name.text));
+      if (directProps.length > 0) {
+        propsExpr = ts.factory.createObjectLiteralExpression([
+          ...propsExpr && ts.isObjectLiteralExpression(propsExpr) ? propsExpr.properties : [],
+          ...directProps
+        ]);
+      }
+    }
+  }
+  if (!ts.isStringLiteral(tagExpr)) {
+    throw mpError(classSource.filePath, "\u5143\u7D20\u6807\u7B7E\u5FC5\u987B\u662F\u5B57\u7B26\u4E32\u5B57\u9762\u91CF");
+  }
+  return compileElement(context, classSource, tagExpr.text, propsExpr, childrenExpr, listenersExpr, directionsExpr, env, depth);
+}
+function compileElement(context, classSource, tagName, propsExpr, childrenExpr, listenersExpr, directionsExpr, env, depth) {
+  const { ts } = context;
+  const wxmlTag = TAG_MAP[tagName];
+  if (!wxmlTag) {
+    throw mpError(classSource.filePath, `\u4E0D\u652F\u6301\u7684 HTML \u6807\u7B7E "${tagName}"\uFF08WXML \u4EC5\u652F\u6301\u57FA\u7840\u7EC4\u4EF6\uFF09`);
+  }
+  const attrs = [...env.extraAttrs];
+  if (propsExpr !== undefined) {
+    if (!ts.isObjectLiteralExpression(propsExpr)) {
+      throw mpError(classSource.filePath, `\u5143\u7D20 props \u5FC5\u987B\u662F\u5BF9\u8C61\u5B57\u9762\u91CF`);
+    }
+    for (const property of propsExpr.properties) {
+      if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.name)) {
+        throw mpError(classSource.filePath, `\u5143\u7D20 props \u53EA\u652F\u6301\u9759\u6001\u5C5E\u6027\u540D`);
+      }
+      const key = property.name.text;
+      const value = property.initializer;
+      if (key === "key") {
+        continue;
+      }
+      if (key === "class" || key === "className") {
+        attrs.push(compileClassAttr(context, classSource, value, env));
+        continue;
+      }
+      if (key === "style") {
+        attrs.push(compileStyleAttr(context, classSource, value, env));
+        continue;
+      }
+      if (key === "slot") {
+        attrs.push(`slot="${compileLiteralString(context, classSource, value, "slot \u540D\u79F0")}"`);
+        continue;
+      }
+      if (isEventProp(key)) {
+        const event = eventNameFromProp(key);
+        attrs.push(compileListener(context, classSource, event, value, env));
+        continue;
+      }
+      attrs.push(compileGenericAttr(context, classSource, key, value, env));
+    }
+  }
+  if (listenersExpr !== undefined) {
+    if (!ts.isObjectLiteralExpression(listenersExpr)) {
+      throw mpError(classSource.filePath, "listeners \u5FC5\u987B\u662F\u5BF9\u8C61\u5B57\u9762\u91CF");
+    }
+    for (const property of listenersExpr.properties) {
+      if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.name)) {
+        throw mpError(classSource.filePath, "listeners \u53EA\u652F\u6301\u9759\u6001\u4E8B\u4EF6\u540D");
+      }
+      const event = property.name.text.split(".")[0];
+      const hasModifiers = property.name.text !== event;
+      if (hasModifiers) {
+        warn(context, `${classSource.filePath}: \u4E8B\u4EF6\u4FEE\u9970\u7B26 "${property.name.text}" \u5728\u5C0F\u7A0B\u5E8F\u4E2D\u4E0D\u751F\u6548`);
+      }
+      attrs.push(compileListener(context, classSource, event, property.initializer, env));
+    }
+  }
+  if (directionsExpr !== undefined) {
+    if (!ts.isObjectLiteralExpression(directionsExpr)) {
+      throw mpError(classSource.filePath, "directions \u5FC5\u987B\u662F\u5BF9\u8C61\u5B57\u9762\u91CF");
+    }
+    const ifExpr = objectProperty(ts, directionsExpr, "if");
+    if (ifExpr) {
+      const folded = foldExpression(ts, ifExpr, env.scope.consts);
+      if (folded === false) {
+        return [];
+      }
+      if (folded !== true) {
+        attrs.push(`${context.dialect.directivePrefix}if="{{${toBinding(bindingContext(context, classSource, env), ifExpr)}}}"`);
+      }
+    }
+    const showExpr = objectProperty(ts, directionsExpr, "show");
+    if (showExpr) {
+      const folded = foldExpression(ts, showExpr, env.scope.consts);
+      if (folded === false) {
+        attrs.push("hidden");
+      } else if (folded !== true) {
+        const binding = toBinding(bindingContext(context, classSource, env), showExpr);
+        attrs.push(`hidden="{{!(${binding})}}"`);
+      }
+    }
+    if (objectProperty(ts, directionsExpr, "model")) {
+      throw mpError(classSource.filePath, "directions.model \u53CC\u5411\u7ED1\u5B9A\u6682\u4E0D\u652F\u6301\u7F16\u8BD1\u5230\u5C0F\u7A0B\u5E8F\uFF0C\u8BF7\u6539\u7528 value + bindinput");
+    }
+  }
+  const openTag = attrs.length > 0 ? `<${wxmlTag} ${attrs.join(" ")}>` : `<${wxmlTag}>`;
+  const lines = [indent(env.indent) + openTag];
+  const childLines = buildNodeLines(context, classSource, childrenExpr ?? ts.factory.createArrayLiteralExpression([]), {
+    ...env,
+    indent: env.indent + 1
+  }, depth + 1);
+  lines.push(...childLines);
+  lines.push(indent(env.indent) + `</${wxmlTag}>`);
+  return lines;
+}
+function compileConditional(context, classSource, node, env, depth) {
+  const condition = toBinding(bindingContext(context, classSource, env), node.condition);
+  const whenTrue = buildNodeLines(context, classSource, node.whenTrue, env, depth + 1);
+  const whenFalse = buildNodeLines(context, classSource, node.whenFalse, env, depth + 1);
+  const lines = [indent(env.indent) + `<block ${context.dialect.directivePrefix}if="{{${condition}}}">`];
+  lines.push(...whenTrue.map((line) => indent(env.indent + 1) + line));
+  lines.push(indent(env.indent) + "</block>");
+  if (whenFalse.length > 0) {
+    lines.push(indent(env.indent) + `<block ${context.dialect.directivePrefix}else>`);
+    lines.push(...whenFalse.map((line) => indent(env.indent + 1) + line));
+    lines.push(indent(env.indent) + "</block>");
+  }
+  return lines;
+}
+function compileLogicalAnd(context, classSource, node, env, depth) {
+  const condition = toBinding(bindingContext(context, classSource, env), node.left);
+  const inner = buildNodeLines(context, classSource, node.right, env, depth + 1);
+  return [
+    indent(env.indent) + `<block ${context.dialect.directivePrefix}if="{{${condition}}}">`,
+    ...inner.map((line) => indent(env.indent + 1) + line),
+    indent(env.indent) + "</block>"
+  ];
+}
+function compileEach(context, classSource, node, env, depth) {
+  const { ts } = context;
+  const [itemsExpr, renderExpr, keyExpr] = node.arguments;
+  if (!itemsExpr || !renderExpr) {
+    throw mpError(classSource.filePath, "each(items, render, key) \u7F3A\u5C11\u53C2\u6570");
+  }
+  if (!ts.isArrowFunction(renderExpr)) {
+    throw mpError(classSource.filePath, "each \u7684 render \u53C2\u6570\u5FC5\u987B\u662F\u7BAD\u5934\u51FD\u6570");
+  }
+  const paramNames = [];
+  for (const parameter of renderExpr.parameters) {
+    if (!ts.isIdentifier(parameter.name)) {
+      throw mpError(classSource.filePath, "each \u7684\u53C2\u6570\u5FC5\u987B\u662F (item, index) \u6807\u8BC6\u7B26");
+    }
+    paramNames.push(parameter.name.text);
+  }
+  if (paramNames.length > 2) {
+    throw mpError(classSource.filePath, "each \u6700\u591A\u63A5\u53D7 (item, index) \u4E24\u4E2A\u53C2\u6570");
+  }
+  const itemsBinding = toBinding(bindingContext(context, classSource, env), itemsExpr);
+  const itemName = paramNames[0] ?? "item";
+  const indexName = paramNames[1] ?? "index";
+  const childScope = {
+    ...env.scope,
+    params: new Set([...env.scope.params, itemName, indexName])
+  };
+  let keyAttr = "";
+  if (keyExpr) {
+    const keyBinding = eachKeyBinding(context, classSource, keyExpr, itemName, indexName);
+    if (keyBinding) {
+      keyAttr = ` ${context.dialect.directivePrefix}key="${keyBinding}"`;
+    }
+  }
+  const inner = buildNodeLines(context, classSource, renderExpr.body, {
+    ...env,
+    scope: childScope,
+    indent: env.indent + 1
+  }, depth + 1);
+  return [
+    indent(env.indent) + `<block ${context.dialect.directivePrefix}for="{{${itemsBinding}}}" ${context.dialect.directivePrefix}for-item="${itemName}" ${context.dialect.directivePrefix}for-index="${indexName}"${keyAttr}>`,
+    ...inner,
+    indent(env.indent) + "</block>"
+  ];
+}
+function eachKeyBinding(context, classSource, keyExpr, itemName, indexName) {
+  const { ts } = context;
+  keyExpr = unwrapParentheses(ts, keyExpr);
+  if (ts.isArrowFunction(keyExpr)) {
+    const body = arrowBodyExpression(ts, keyExpr);
+    if (body === undefined) {
+      throw mpError(classSource.filePath, "each \u7684 key \u5FC5\u987B\u662F (item) => item.xxx \u6216 (item, index) => index");
+    }
+    keyExpr = body;
+  }
+  if (ts.isIdentifier(keyExpr)) {
+    if (keyExpr.text === indexName) {
+      return;
+    }
+    if (keyExpr.text === itemName) {
+      throw mpError(classSource.filePath, "\u5217\u8868 key \u4E0D\u80FD\u76F4\u63A5\u4F7F\u7528 item\uFF0C\u8BF7\u53D6 item \u7684\u6210\u5458");
+    }
+  }
+  if (ts.isPropertyAccessExpression(keyExpr) && ts.isIdentifier(keyExpr.expression)) {
+    const base = keyExpr.expression.text;
+    if (base === itemName) {
+      return keyExpr.name.text;
+    }
+  }
+  const nested = eachKeyPath(ts, keyExpr, itemName);
+  if (nested) {
+    return nested;
+  }
+  throw mpError(classSource.filePath, "each \u7684 key \u5FC5\u987B\u662F (item) => item.xxx \u6216 (item, index) => index");
+}
+function arrowBodyExpression(ts, arrow) {
+  const body = arrow.body;
+  if (ts.isBlock(body)) {
+    const statements = body.statements.filter((statement) => !ts.isEmptyStatement(statement));
+    if (statements.length === 1 && ts.isReturnStatement(statements[0]) && statements[0].expression) {
+      return statements[0].expression;
+    }
+    return;
+  }
+  return body;
+}
+function eachKeyPath(ts, node, itemName) {
+  node = unwrapParentheses(ts, node);
+  if (!ts.isPropertyAccessExpression(node)) {
+    return;
+  }
+  let current = node;
+  const parts = [];
+  while (ts.isPropertyAccessExpression(current)) {
+    parts.unshift(current.name.text);
+    current = current.expression;
+  }
+  if (ts.isIdentifier(current) && current.text === itemName) {
+    return parts.join(".");
+  }
+  return;
+}
+function compileComponentCall(context, classSource, node, env, depth) {
+  const { ts } = context;
+  const first = unwrapParentheses(ts, node.arguments[0]);
+  if (ts.isObjectLiteralExpression(first) && objectProperty(ts, first, "component")) {
+    return compileComponentObject(context, classSource, first, env, depth);
+  }
+  const [classExpr, propsExpr, childrenExpr] = node.arguments;
+  if (!classExpr) {
+    throw mpError(classSource.filePath, "createComponent \u7F3A\u5C11\u7EC4\u4EF6\u7C7B\u53C2\u6570");
+  }
+  const directionsExpr = node.arguments[4];
+  return compileComponent(context, classSource, classExpr, propsExpr, childrenExpr, undefined, directionsExpr, env, depth);
+}
+function compileComponentObject(context, classSource, node, env, depth) {
+  return compileComponent(context, classSource, objectProperty(context.ts, node, "component"), objectProperty(context.ts, node, "props"), objectProperty(context.ts, node, "children"), objectProperty(context.ts, node, "emitters"), objectProperty(context.ts, node, "directions"), env, depth);
+}
+function compileComponent(context, classSource, classExpr, propsExpr, childrenExpr, emittersExpr, directionsExpr, env, depth) {
+  const { ts } = context;
+  const target = resolveClassReference(context, classSource, classExpr);
+  if (!isComponentSubclass(context, target)) {
+    throw mpError(classSource.filePath, `createComponent \u53EA\u63A5\u53D7 Component \u5B50\u7C7B: ${target.className}`);
+  }
+  const tag = kebabCase(target.className);
+  env.builder.usedComponents.set(tag, target);
+  const attrs = [...env.extraAttrs];
+  const callSiteProps = {};
+  if (propsExpr !== undefined) {
+    if (!ts.isObjectLiteralExpression(propsExpr)) {
+      throw mpError(classSource.filePath, "createComponent \u7684 props \u5FC5\u987B\u662F\u5BF9\u8C61\u5B57\u9762\u91CF");
+    }
+    for (const property of propsExpr.properties) {
+      if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.name)) {
+        throw mpError(classSource.filePath, "\u7EC4\u4EF6 props \u53EA\u652F\u6301\u9759\u6001\u5C5E\u6027\u540D");
+      }
+      const key = property.name.text;
+      const value = property.initializer;
+      if (ts.isArrowFunction(value) || ts.isFunctionExpression(value)) {
+        throw mpError(classSource.filePath, `\u7EC4\u4EF6 props \u4F20\u51FD\u6570\uFF08${key}\uFF09\u6682\u4E0D\u652F\u6301\u7F16\u8BD1\u5230\u5C0F\u7A0B\u5E8F\uFF0C\u8BF7\u6539\u7528 emitters + this.emit \u6A21\u5F0F`);
+      }
+      callSiteProps[key] = inferPropType(context, classSource, value, env);
+      const folded = foldExpression(ts, value, env.scope.consts);
+      if (folded !== undefined && folded !== null) {
+        attrs.push(`${key}="${escapeAttr(literalToString(folded))}"`);
+      } else {
+        const binding = toBinding(bindingContext(context, classSource, env), value);
+        attrs.push(`${key}="{{${binding}}}"`);
+      }
+    }
+    const existing = context.callSites.get(tag) ?? [];
+    existing.push(callSiteProps);
+    context.callSites.set(tag, existing);
+  }
+  if (emittersExpr !== undefined) {
+    if (!ts.isObjectLiteralExpression(emittersExpr)) {
+      throw mpError(classSource.filePath, "emitters \u5FC5\u987B\u662F\u5BF9\u8C61\u5B57\u9762\u91CF");
+    }
+    for (const property of emittersExpr.properties) {
+      if (!ts.isPropertyAssignment(property)) {
+        throw mpError(classSource.filePath, "emitters \u53EA\u652F\u6301\u9759\u6001\u4E8B\u4EF6\u540D");
+      }
+      const eventName = ts.isIdentifier(property.name) || ts.isStringLiteral(property.name) ? property.name.text : undefined;
+      if (eventName === undefined) {
+        throw mpError(classSource.filePath, "emitters \u53EA\u652F\u6301\u9759\u6001\u4E8B\u4EF6\u540D");
+      }
+      const usage = compileEmitterHandler(context, classSource, property.initializer);
+      if (!usage) {
+        throw mpError(classSource.filePath, "emitters \u5904\u7406\u5668\u53EA\u652F\u6301 () => this.method() \u6216 (value) => this.method(value)");
+      }
+      usage.event = eventName;
+      const key = `__transone_emitter_${eventName}_${env.builder.emitters.length}`;
+      usage.key = key;
+      env.builder.emitters.push(usage);
+      attrs.push(`bind:${eventName}="${key}"`);
+    }
+  }
+  if (directionsExpr !== undefined) {
+    if (!ts.isObjectLiteralExpression(directionsExpr)) {
+      throw mpError(classSource.filePath, "directions \u5FC5\u987B\u662F\u5BF9\u8C61\u5B57\u9762\u91CF");
+    }
+    const ifExpr = objectProperty(ts, directionsExpr, "if");
+    if (ifExpr) {
+      const folded = foldExpression(ts, ifExpr, env.scope.consts);
+      if (folded === false) {
+        return [];
+      }
+      if (folded !== true) {
+        attrs.push(`${context.dialect.directivePrefix}if="{{${toBinding(bindingContext(context, classSource, env), ifExpr)}}}"`);
+      }
+    }
+  }
+  const openTag = attrs.length > 0 ? `<${tag} ${attrs.join(" ")}>` : `<${tag}>`;
+  const lines = [indent(env.indent) + openTag];
+  const childLines = buildNodeLines(context, classSource, childrenExpr ?? ts.factory.createArrayLiteralExpression([]), {
+    ...env,
+    indent: env.indent + 1
+  }, depth + 1);
+  lines.push(...childLines);
+  lines.push(indent(env.indent) + `</${tag}>`);
+  return lines;
+}
+function compileSlot(context, classSource, node, env) {
+  const nameExpr = node.arguments[0];
+  if (!nameExpr) {
+    return [indent(env.indent) + "<slot/>"];
+  }
+  const name = compileLiteralString(context, classSource, nameExpr, "slot \u540D\u79F0");
+  return [indent(env.indent) + `<slot name="${name}"/>`];
+}
+function compileListener(context, classSource, eventName, handlerExpr, env) {
+  const wxmlEvent = EVENT_MAP[eventName];
+  if (!wxmlEvent) {
+    throw mpError(classSource.filePath, `\u4E0D\u652F\u6301\u7684\u5C0F\u7A0B\u5E8F\u4E8B\u4EF6 "${eventName}"\uFF08\u652F\u6301: ${Object.keys(EVENT_MAP).join("/")}\uFF09`);
+  }
+  const method = compileHandlerMethod(context, classSource, handlerExpr);
+  env.builder.handlers.add(method);
+  return `${context.dialect.bindEvent(wxmlEvent)}="${method}"`;
+}
+function compileHandlerMethod(context, classSource, handlerExpr) {
+  const { ts } = context;
+  handlerExpr = unwrapParentheses(ts, handlerExpr);
+  if (ts.isPropertyAccessExpression(handlerExpr) && isThisExpression(ts, handlerExpr.expression)) {
+    return handlerExpr.name.text;
+  }
+  if (ts.isArrowFunction(handlerExpr)) {
+    const call = singleMethodCall(ts, handlerExpr.body);
+    if (call && call.args.length === 0) {
+      return call.method;
+    }
+    const arg = call && call.args.length === 1 ? unwrapTypeAssertions(ts, call.args[0]) : undefined;
+    if (call && call.args.length === 1 && handlerExpr.parameters.length === 1 && ts.isIdentifier(handlerExpr.parameters[0].name) && arg !== undefined && ts.isIdentifier(arg) && handlerExpr.parameters[0].name.text === arg.text) {
+      return call.method;
+    }
+  }
+  throw mpError(classSource.filePath, "\u4E8B\u4EF6\u5904\u7406\u5668\u5FC5\u987B\u662F () => this.method()\u3001this.method \u6216 (e) => this.method(e) \u5F62\u5F0F");
+}
+function compileEmitterHandler(context, _classSource, handlerExpr) {
+  const { ts } = context;
+  handlerExpr = unwrapParentheses(ts, handlerExpr);
+  if (ts.isPropertyAccessExpression(handlerExpr) && isThisExpression(ts, handlerExpr.expression)) {
+    return { event: "pending", method: handlerExpr.name.text, passArgs: true, key: "" };
+  }
+  if (!ts.isArrowFunction(handlerExpr)) {
+    return;
+  }
+  const call = singleMethodCall(ts, handlerExpr.body);
+  if (!call) {
+    return;
+  }
+  if (call.args.length === 0) {
+    return { event: "pending", method: call.method, passArgs: false, key: "" };
+  }
+  const arg = call.args.length === 1 ? unwrapTypeAssertions(ts, call.args[0]) : undefined;
+  if (call.args.length === 1 && handlerExpr.parameters.length === 1 && ts.isIdentifier(handlerExpr.parameters[0].name) && arg !== undefined && ts.isIdentifier(arg) && handlerExpr.parameters[0].name.text === arg.text) {
+    return { event: "pending", method: call.method, passArgs: true, key: "" };
+  }
+  return;
+}
+function singleMethodCall(ts, body) {
+  let callExpr;
+  if (ts.isCallExpression(body)) {
+    callExpr = body;
+  } else if (ts.isBlock(body)) {
+    const statements = body.statements.filter((statement) => !ts.isEmptyStatement(statement));
+    if (statements.length !== 1 || !ts.isExpressionStatement(statements[0])) {
+      return;
+    }
+    const expression = statements[0].expression;
+    if (!ts.isCallExpression(expression)) {
+      return;
+    }
+    callExpr = expression;
+  } else {
+    return;
+  }
+  const callee = callExpr.expression;
+  if (!ts.isPropertyAccessExpression(callee) || !isThisExpression(ts, callee.expression)) {
+    return;
+  }
+  return { method: callee.name.text, args: callExpr.arguments };
+}
+function unwrapTypeAssertions(ts, expression) {
+  let node = expression;
+  for (;; ) {
+    if (ts.isAsExpression(node)) {
+      node = node.expression;
+      continue;
+    }
+    if (ts.isTypeAssertionExpression(node)) {
+      node = node.expression;
+      continue;
+    }
+    if (ts.isNonNullExpression(node)) {
+      node = node.expression;
+      continue;
+    }
+    return node;
+  }
+}
+function compileClassAttr(context, classSource, value, env) {
+  const { ts } = context;
+  const folded = foldExpression(ts, value, env.scope.consts);
+  if (typeof folded === "string") {
+    const hoverClass = hoverClassName(folded, env.hoverSelectors);
+    return hoverClass ? `class="${escapeAttr(folded)}" hover-class="${hoverClass}"` : `class="${escapeAttr(folded)}"`;
+  }
+  if (folded === null) {
+    return "";
+  }
+  const text = rawTemplateText(ts, value);
+  if (text !== undefined) {
+    const hoverClass = hoverClassName(text, env.hoverSelectors);
+    return hoverClass ? `class="${escapeAttr(text)}" hover-class="${hoverClass}"` : `class="${escapeAttr(text)}"`;
+  }
+  return `class="{{${toBinding(bindingContext(context, classSource, env), value)}}}"`;
+}
+function hoverClassName(className, hoverSelectors) {
+  for (const single of className.split(/\s+/)) {
+    if (single === "") {
+      continue;
+    }
+    if (hoverSelectors.has(single) || hoverSelectors.has(`.${single}`)) {
+      return `${single.replace(/^\./, "")}-hover`;
+    }
+  }
+  return;
+}
+function compileStyleAttr(context, classSource, value, env) {
+  const { ts } = context;
+  const options = unwrapParentheses(ts, value);
+  if (!ts.isObjectLiteralExpression(options)) {
+    throw mpError(classSource.filePath, "style \u5C5E\u6027\u5FC5\u987B\u662F\u5BF9\u8C61\u5B57\u9762\u91CF");
+  }
+  const declarations = [];
+  for (const property of options.properties) {
+    if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.name)) {
+      throw mpError(classSource.filePath, "style \u5C5E\u6027\u53EA\u652F\u6301\u9759\u6001\u952E");
+    }
+    const cssKey = property.name.text.replace(/([A-Z])/g, "-$1").toLowerCase();
+    const folded = foldExpression(ts, property.initializer, env.scope.consts);
+    if (typeof folded === "string" || typeof folded === "number") {
+      declarations.push(`${cssKey}: ${String(folded)};`);
+    } else {
+      const unitSplit = splitUnitExpression(ts, property.initializer);
+      if (unitSplit) {
+        declarations.push(`${cssKey}: {{${toBinding(bindingContext(context, classSource, env), unitSplit.expr)}}}${unitSplit.unit};`);
+      } else {
+        declarations.push(`${cssKey}: {{${toBinding(bindingContext(context, classSource, env), property.initializer)}}};`);
+      }
+    }
+  }
+  return `style="${escapeAttr(declarations.join(" "))}"`;
+}
+function splitUnitExpression(ts, expr) {
+  expr = unwrapParentheses(ts, expr);
+  if (!ts.isBinaryExpression(expr)) {
+    return;
+  }
+  if (expr.operatorToken.kind !== ts.SyntaxKind.PlusToken) {
+    return;
+  }
+  const right = unwrapParentheses(ts, expr.right);
+  if (!ts.isStringLiteral(right)) {
+    return;
+  }
+  const unit = right.text;
+  if (!/^[a-z%]+$/i.test(unit)) {
+    return;
+  }
+  return { expr: expr.left, unit };
+}
+function compileGenericAttr(context, classSource, key, value, env) {
+  const { ts } = context;
+  const attrName = wxmlAttrName(key);
+  const folded = foldExpression(ts, value, env.scope.consts);
+  if (folded !== undefined) {
+    if (folded === false || folded === null) {
+      return "";
+    }
+    if (folded === true) {
+      return attrName;
+    }
+    return `${attrName}="${escapeAttr(literalToString(folded))}"`;
+  }
+  const text = rawTemplateText(ts, value);
+  if (text !== undefined) {
+    return `${attrName}="${escapeAttr(text)}"`;
+  }
+  return `${attrName}="{{${toBinding(bindingContext(context, classSource, env), value)}}}"`;
+}
+var KEBAB_ATTRS = {
+  scrollX: "scroll-x",
+  scrollY: "scroll-y",
+  scrollIntoView: "scroll-into-view",
+  scrollWithAnimation: "scroll-with-animation",
+  scrollAnchoring: "scroll-anchoring",
+  enableFlex: "enable-flex",
+  enableScroll: "enable-scroll",
+  enableZoom: "enable-zoom",
+  enablePassive: "enable-passive",
+  autoFocus: "auto-focus",
+  confirmType: "confirm-type",
+  confirmHold: "confirm-hold",
+  cursorSpacing: "cursor-spacing",
+  selectionStart: "selection-start",
+  selectionEnd: "selection-end",
+  showConfirmBar: "show-confirm-bar",
+  adjustPosition: "adjust-position",
+  holdKeyboard: "hold-keyboard",
+  disableDefaultPadding: "disable-default-padding",
+  disableAutoPush: "disable-auto-push",
+  disableBeforeInput: "disable-before-input",
+  showMarker: "show-marker",
+  enablePublish: "enable-publish",
+  markerCluster: "marker-cluster",
+  showLocation: "show-location",
+  showCompass: "show-compass",
+  enableSatellite: "enable-satellite",
+  enableTraffic: "enable-traffic",
+  enableBuilding: "enable-building",
+  enableRotate: "enable-rotate",
+  enableOverlooking: "enable-overlooking",
+  subKey: "sub-key",
+  enableLazy: "enable-lazy",
+  showMenuByLongpress: "show-menu-by-longpress",
+  openType: "open-type",
+  formType: "form-type",
+  unitId: "unit-id",
+  hoverClass: "hover-class",
+  hoverStartTime: "hover-start-time",
+  hoverStayTime: "hover-stay-time",
+  hoverStopPropagation: "hover-stop-propagation",
+  plain: "plain",
+  loading: "loading",
+  disabled: "disabled",
+  size: "size"
+};
+function wxmlAttrName(key) {
+  if (key === "href") {
+    return "url";
+  }
+  if (key.startsWith("data") && key.length > 4) {
+    return `data${key.slice(4).replace(/([A-Z])/g, "-$1").toLowerCase()}`;
+  }
+  return KEBAB_ATTRS[key] ?? key;
+}
+function compileLiteralString(context, classSource, value, what) {
+  const { ts } = context;
+  const folded = foldExpression(ts, value, new Map);
+  if (typeof folded !== "string") {
+    throw mpError(classSource.filePath, `${what}\u5FC5\u987B\u662F\u5B57\u7B26\u4E32\u5B57\u9762\u91CF`);
+  }
+  return folded;
+}
+function textContent(context, classSource, node, env) {
+  const { ts } = context;
+  node = unwrapParentheses(ts, node);
+  if (ts.isStringLiteral(node)) {
+    return escapeXml(node.text);
+  }
+  if (ts.isNoSubstitutionTemplateLiteral(node)) {
+    return node.text.includes("{{") ? node.text : escapeXml(node.text);
+  }
+  if (ts.isTemplateExpression(node)) {
+    return `{{${toBinding(bindingContext(context, classSource, env), node)}}}`;
+  }
+  if (ts.isIdentifier(node)) {
+    if (env.scope.params.has(node.text)) {
+      return `{{${node.text}}}`;
+    }
+    const replacement = resolveIdentifierExpression(context, classSource, node, env);
+    if (replacement) {
+      return textContent(context, classSource, replacement, env);
+    }
+    throw mpError(classSource.filePath, `\u65E0\u6CD5\u89E3\u6790\u6A21\u677F\u6807\u8BC6\u7B26 "${node.text}"`);
+  }
+  if (ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node)) {
+    return `{{${toBinding(bindingContext(context, classSource, env), node)}}}`;
+  }
+  throw mpError(classSource.filePath, `\u4E0D\u652F\u6301\u7684\u6587\u672C\u8282\u70B9: ${node.getText().slice(0, 60)}`);
+}
+function isTextNode(ts, node) {
+  return ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node) || ts.isTemplateExpression(node);
+}
+function resolveIdentifierExpression(_context, _classSource, node, env) {
+  if (env.scope.locals.has(node.text)) {
+    return env.scope.locals.get(node.text);
+  }
+  if (env.scope.consts.has(node.text)) {
+    return env.scope.consts.get(node.text);
+  }
+  return;
+}
+function bindingContext(context, classSource, env) {
+  return {
+    ts: context.ts,
+    scope: env.scope,
+    filePath: classSource.filePath,
+    onProp: (name) => env.builder.propsReferenced.add(name)
+  };
+}
+function callName2(ts, expression) {
+  expression = unwrapParentheses(ts, expression);
+  if (ts.isIdentifier(expression)) {
+    return expression.text;
+  }
+  if (ts.isPropertyAccessExpression(expression)) {
+    return expression.name.text;
+  }
+  return;
+}
+function objectProperty(ts, object, key) {
+  for (const property of object.properties) {
+    if (ts.isPropertyAssignment(property) && ts.isIdentifier(property.name) && property.name.text === key) {
+      return property.initializer;
+    }
+  }
+  return;
+}
+function collectModuleConsts(context, classSource) {
+  const consts = new Map;
+  for (const statement of classSource.source.statements) {
+    if (!context.ts.isVariableStatement(statement)) {
+      continue;
+    }
+    const isConst = statement.declarationList.flags & context.ts.NodeFlags.Const;
+    if (!isConst) {
+      continue;
+    }
+    for (const declaration of statement.declarationList.declarations) {
+      if (context.ts.isIdentifier(declaration.name) && declaration.initializer) {
+        consts.set(declaration.name.text, declaration.initializer);
+      }
+    }
+  }
+  return consts;
+}
+function collectFactoryOrigins(ts, source) {
+  const origins = new Map;
+  for (const statement of source.statements) {
+    if (!ts.isImportDeclaration(statement)) {
+      continue;
+    }
+    const specifier = statement.moduleSpecifier.getText().replace(/['"]/g, "");
+    if (!specifier.includes("transone")) {
+      continue;
+    }
+    const bindings = statement.importClause?.namedBindings;
+    if (!bindings || !ts.isNamedImports(bindings)) {
+      continue;
+    }
+    for (const element of bindings.elements) {
+      const local = element.name.text;
+      const original = element.propertyName?.text ?? local;
+      if (ELEMENT_FACTORIES.has(original) || SPECIAL_CALLS.has(original)) {
+        origins.set(local, original);
+      }
+    }
+  }
+  return origins;
+}
+function inferPropType(context, _classSource, value, env) {
+  const { ts } = context;
+  const folded = foldExpression(ts, value, env.scope.consts);
+  if (typeof folded === "string") {
+    return "String";
+  }
+  if (typeof folded === "number") {
+    return "Number";
+  }
+  if (typeof folded === "boolean") {
+    return "Boolean";
+  }
+  if (Array.isArray(folded)) {
+    return "Array";
+  }
+  if (folded !== undefined && typeof folded === "object") {
+    return "Object";
+  }
+  return "null";
+}
+function rawTemplateText(ts, node) {
+  node = unwrapParentheses(ts, node);
+  if (ts.isNoSubstitutionTemplateLiteral(node) && node.text.includes("{{")) {
+    return node.text;
+  }
+  return;
+}
+function literalToString(value) {
+  return typeof value === "string" ? value : String(value);
+}
+function kebabCase(name) {
+  const kebab = name.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[^A-Za-z0-9-]/g, "").toLowerCase();
+  if (!kebab) {
+    throw new Error(`\u65E0\u6CD5\u4ECE\u7C7B\u540D "${name}" \u751F\u6210\u7EC4\u4EF6\u6807\u7B7E\u540D`);
+  }
+  return kebab;
+}
+function escapeXml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeAttr(value) {
+  return escapeXml(value).replace(/"/g, "&quot;");
+}
+function indent(level) {
+  return "  ".repeat(level);
+}
+function findMethod(context, classSource, name) {
+  const { ts } = context;
+  return classSource.declaration.members.find((member) => ts.isMethodDeclaration(member) && member.name.getText() === name);
+}
+
+// src/mp/styles.ts
+var UNITLESS_PROPERTIES = new Set([
+  "opacity",
+  "zIndex",
+  "fontWeight",
+  "lineHeight",
+  "flex",
+  "flexGrow",
+  "flexShrink",
+  "order",
+  "zoom",
+  "scale",
+  "transform",
+  "animationIterationCount",
+  "columnCount",
+  "fontSizeAdjust"
+]);
+function compileStyles(context, classSource) {
+  const { ts } = context;
+  const method = findMethod(context, classSource, "initStyles");
+  if (!method?.body) {
+    return { style: "", global: "", hoverSelectors: new Set };
+  }
+  const consts = collectModuleConsts2(context, classSource);
+  const entries = [];
+  for (const statement of method.body.statements) {
+    if (ts.isEmptyStatement(statement)) {
+      continue;
+    }
+    if (!ts.isExpressionStatement(statement)) {
+      throw mpError(classSource.filePath, "initStyles() \u53EA\u652F\u6301 this.styleManager.addStyle(...) \u8C03\u7528");
+    }
+    const expression = statement.expression;
+    const entry = addStyleEntry(context, classSource, expression, consts);
+    if (entry) {
+      entries.push(entry);
+    }
+  }
+  const local = [];
+  const global = [];
+  const hoverSelectors = new Set;
+  for (const entry of entries) {
+    const target = entry.selector === "body" ? global : local;
+    target.push(renderStyle(entry, context.lengthUnit));
+    if (entry.hover && entry.selector !== "body") {
+      hoverSelectors.add(entry.selector);
+    }
+  }
+  return { style: local.join(`
+`), global: global.join(`
+`), hoverSelectors };
+}
+function addStyleEntry(context, classSource, expression, consts) {
+  const { ts } = context;
+  if (!ts.isCallExpression(expression)) {
+    throw mpError(classSource.filePath, "initStyles() \u53EA\u652F\u6301 this.styleManager.addStyle(...) \u8C03\u7528");
+  }
+  const callee = expression.expression;
+  const manager = ts.isPropertyAccessExpression(callee) ? callee.expression : undefined;
+  if (!ts.isPropertyAccessExpression(callee) || callee.name.text !== "addStyle" || !manager || !ts.isPropertyAccessExpression(manager) || !isThisExpression(ts, manager.expression) || manager.name.text !== "styleManager") {
+    throw mpError(classSource.filePath, "initStyles() \u53EA\u652F\u6301 this.styleManager.addStyle(...) \u8C03\u7528");
+  }
+  const optionsExpr = expression.arguments[1];
+  if (!optionsExpr || !ts.isObjectLiteralExpression(optionsExpr)) {
+    throw mpError(classSource.filePath, "addStyle \u7684\u7B2C\u4E8C\u4E2A\u53C2\u6570\u5FC5\u987B\u662F\u5BF9\u8C61\u5B57\u9762\u91CF");
+  }
+  const selector = foldObjectString(ts, optionsExpr, "selector", consts);
+  const properties = foldObjectRecord(ts, optionsExpr, "properties", consts);
+  const hover = foldObjectRecord(ts, optionsExpr, "hover", consts);
+  const media = foldMedia(ts, optionsExpr, consts);
+  if (selector === undefined || properties === undefined) {
+    throw mpError(classSource.filePath, "addStyle \u9700\u8981 selector \u4E0E properties \u5B57\u9762\u91CF");
+  }
+  return {
+    selector,
+    properties,
+    ...hover ? { hover } : {},
+    ...media ? { media } : {}
+  };
+}
+function foldObjectString(ts, object, key, consts) {
+  const value = objectProperty2(ts, object, key);
+  if (!value) {
+    return;
+  }
+  const folded = foldExpression(ts, value, consts);
+  return typeof folded === "string" ? folded : undefined;
+}
+function foldObjectRecord(ts, object, key, consts) {
+  const value = objectProperty2(ts, object, key);
+  if (!value) {
+    return;
+  }
+  if (!ts.isObjectLiteralExpression(value)) {
+    return;
+  }
+  const result = {};
+  for (const property of value.properties) {
+    if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.name)) {
+      return;
+    }
+    const folded = foldExpression(ts, property.initializer, consts);
+    if (typeof folded !== "string" && typeof folded !== "number") {
+      return;
+    }
+    result[property.name.text] = folded;
+  }
+  return result;
+}
+function foldMedia(ts, object, consts) {
+  const value = objectProperty2(ts, object, "media");
+  if (!value) {
+    return;
+  }
+  if (!ts.isObjectLiteralExpression(value)) {
+    return;
+  }
+  const result = {};
+  for (const property of value.properties) {
+    if (!ts.isPropertyAssignment(property) || !ts.isStringLiteral(property.name) || !ts.isObjectLiteralExpression(property.initializer)) {
+      return;
+    }
+    const props = {};
+    for (const item of property.initializer.properties) {
+      if (!ts.isPropertyAssignment(item) || !ts.isIdentifier(item.name)) {
+        return;
+      }
+      const folded = foldExpression(ts, item.initializer, consts);
+      if (typeof folded !== "string" && typeof folded !== "number") {
+        return;
+      }
+      props[item.name.text] = folded;
+    }
+    result[property.name.text] = props;
+  }
+  return result;
+}
+function renderStyle(entry, lengthUnit) {
+  const selector = entry.selector === "body" ? "page" : entry.selector;
+  const parts = [];
+  parts.push(`${selector} {
+${convertToCss(entry.properties, lengthUnit)}
+}`);
+  if (entry.hover) {
+    parts.push(`${selector}-hover {
+${convertToCss(entry.hover, lengthUnit)}
+}`);
+  }
+  for (const [query, properties] of Object.entries(entry.media ?? {})) {
+    parts.push(`@media ${query} {
+${selector} {
+${convertToCss(properties, lengthUnit)}
+}
+}`);
+  }
+  return parts.join(`
+`);
+}
+function convertToCss(properties, lengthUnit) {
+  return Object.entries(properties).map(([key, value]) => {
+    const cssKey = key.replace(/([A-Z])/g, "-$1").toLowerCase();
+    return `  ${cssKey}: ${formatValue(key, value, lengthUnit)};`;
+  }).join(`
+`);
+}
+function formatValue(key, value, lengthUnit) {
+  if (typeof value !== "number") {
+    return value;
+  }
+  if (value === 0 || UNITLESS_PROPERTIES.has(key)) {
+    return String(value);
+  }
+  return lengthUnit === "rpx" ? `${value * 2}rpx` : `${value}px`;
+}
+function objectProperty2(ts, object, key) {
+  for (const property of object.properties) {
+    if (ts.isPropertyAssignment(property) && ts.isIdentifier(property.name) && property.name.text === key) {
+      return property.initializer;
+    }
+  }
+  return;
+}
+function collectModuleConsts2(context, classSource) {
+  const consts = new Map;
+  for (const statement of classSource.source.statements) {
+    if (!context.ts.isVariableStatement(statement)) {
+      continue;
+    }
+    const isConst = statement.declarationList.flags & context.ts.NodeFlags.Const;
+    if (!isConst) {
+      continue;
+    }
+    for (const declaration of statement.declarationList.declarations) {
+      if (context.ts.isIdentifier(declaration.name) && declaration.initializer) {
+        consts.set(declaration.name.text, declaration.initializer);
+      }
+    }
+  }
+  return consts;
+}
+
+// src/mp/state.ts
+function compileState(context, classSource) {
+  const { ts } = context;
+  const method = findMethod(context, classSource, "initState");
+  if (!method?.body) {
+    return "{}";
+  }
+  const consts = collectModuleConsts3(context, classSource);
+  const locals = new Map;
+  let returnStatement;
+  for (const statement of method.body.statements) {
+    if (ts.isVariableStatement(statement)) {
+      const isConst = statement.declarationList.flags & ts.NodeFlags.Const;
+      if (!isConst) {
+        throw mpError(classSource.filePath, "initState() \u5185\u53EA\u652F\u6301 const \u58F0\u660E\uFF08data \u9700\u9759\u6001\u6C42\u503C\uFF09");
+      }
+      for (const declaration of statement.declarationList.declarations) {
+        if (ts.isIdentifier(declaration.name) && declaration.initializer) {
+          locals.set(declaration.name.text, declaration.initializer);
+        }
+      }
+      continue;
+    }
+    if (ts.isReturnStatement(statement)) {
+      returnStatement = statement;
+      continue;
+    }
+    throw mpError(classSource.filePath, `initState() \u5185\u4E0D\u652F\u6301\u7684\u8BED\u53E5\uFF08\u53EA\u652F\u6301 const \u58F0\u660E\u4E0E return\uFF09: ${statement.getText().slice(0, 60)}`);
+  }
+  if (!returnStatement?.expression) {
+    throw mpError(classSource.filePath, "initState() \u5FC5\u987B\u4EE5 return \u8868\u8FBE\u5F0F\u7ED3\u675F");
+  }
+  const allConsts = new Map([...consts, ...locals]);
+  const value = foldExpression(ts, returnStatement.expression, allConsts);
+  if (value === undefined) {
+    throw mpError(classSource.filePath, "initState() \u7684\u7ED3\u679C\u5FC5\u987B\u80FD\u9759\u6001\u6C42\u503C\uFF08\u53EA\u652F\u6301\u5B57\u9762\u91CF\u3001\u6A21\u5757/\u5C40\u90E8\u5E38\u91CF\u4E0E\u7B80\u5355\u8868\u8FBE\u5F0F\uFF09");
+  }
+  return JSON.stringify(value, null, 2);
+}
+function collectModuleConsts3(context, classSource) {
+  const consts = new Map;
+  for (const statement of classSource.source.statements) {
+    if (!context.ts.isVariableStatement(statement)) {
+      continue;
+    }
+    const isConst = statement.declarationList.flags & context.ts.NodeFlags.Const;
+    if (!isConst) {
+      continue;
+    }
+    for (const declaration of statement.declarationList.declarations) {
+      if (context.ts.isIdentifier(declaration.name) && declaration.initializer) {
+        consts.set(declaration.name.text, declaration.initializer);
+      }
+    }
+  }
+  return consts;
+}
+
+// src/mp/methods.ts
+var PAGE_LIFECYCLE = {
+  beforeMount: "onLoad",
+  onMounted: "onReady",
+  onUnmounted: "onUnload",
+  onShow: "onShow",
+  onHide: "onHide",
+  onPullDownRefresh: "onPullDownRefresh",
+  onReachBottom: "onReachBottom",
+  onShareAppMessage: "onShareAppMessage",
+  onPageScroll: "onPageScroll",
+  onResize: "onResize"
+};
+var COMPONENT_LIFECYCLE = {
+  beforeMount: "created",
+  onMounted: "attached",
+  onUnmounted: "detached"
+};
+function compileMethods(context, classSource, usedNames, kind, customEvents) {
+  const { ts } = context;
+  const methods = new Map;
+  for (const member of classSource.declaration.members) {
+    if (ts.isMethodDeclaration(member) && ts.isIdentifier(member.name) && !isStatic(ts, member)) {
+      methods.set(member.name.text, member);
+    }
+  }
+  const lifecycleMap = kind === "page" ? PAGE_LIFECYCLE : COMPONENT_LIFECYCLE;
+  const seed = new Set(usedNames);
+  for (const hook of Object.keys(lifecycleMap)) {
+    if (methods.has(hook)) {
+      seed.add(hook);
+    }
+  }
+  const queue = [...seed];
+  const visited = new Set;
+  const entries = [];
+  const lifecycleEntries = [];
+  const emittedKeys = new Set;
+  while (queue.length > 0) {
+    const name = queue.shift();
+    if (visited.has(name)) {
+      continue;
+    }
+    visited.add(name);
+    const declaration = methods.get(name);
+    if (!declaration) {
+      throw mpError(classSource.filePath, `\u672A\u627E\u5230\u4E8B\u4EF6\u5904\u7406\u65B9\u6CD5 "${name}"`);
+    }
+    const lifecycleKey = lifecycleMap[name];
+    const key = lifecycleKey ?? name;
+    if (emittedKeys.has(key)) {
+      throw mpError(classSource.filePath, `\u65B9\u6CD5\u540D "${key}" \u4E0E\u5C0F\u7A0B\u5E8F\u751F\u547D\u5468\u671F\u94A9\u5B50\u51B2\u7A81`);
+    }
+    emittedKeys.add(key);
+    const fn = compileMethod(context, classSource, declaration, kind, customEvents, queue);
+    if (lifecycleKey) {
+      lifecycleEntries.push({ key, fn });
+    } else {
+      entries.push({ key, fn });
+    }
+  }
+  return { methods: entries, lifecycle: lifecycleEntries };
+}
+function compileMethod(context, classSource, declaration, kind, customEvents, referencedMethods) {
+  const { ts } = context;
+  if (!declaration.body) {
+    throw mpError(classSource.filePath, `\u65B9\u6CD5 ${declaration.name.getText()} \u7F3A\u5C11\u65B9\u6CD5\u4F53`);
+  }
+  const params = declaration.parameters.map((parameter) => ts.factory.createParameterDeclaration(undefined, parameter.dotDotDotToken, parameter.name, undefined, undefined, parameter.initializer));
+  const modifiers = isAsync(ts, declaration) ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)] : undefined;
+  const functionExpression = ts.factory.createFunctionExpression(modifiers, undefined, undefined, undefined, params, undefined, declaration.body);
+  const consts = collectModuleConsts4(context, classSource);
+  const locals = new Set;
+  const transformerFactory = (transformContext) => {
+    return (root) => visit(context, classSource, root, {
+      transformContext,
+      kind,
+      customEvents,
+      consts,
+      locals,
+      referencedMethods
+    });
+  };
+  const result = ts.transform(functionExpression, [transformerFactory]);
+  const transformed = result.transformed[0];
+  result.dispose();
+  const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
+  const printed = printer.printNode(ts.EmitHint.Expression, transformed, classSource.source);
+  const transpiled = ts.transpileModule(printed, {
+    compilerOptions: { target: ts.ScriptTarget.ESNext, module: ts.ModuleKind.None },
+    reportDiagnostics: false
+  });
+  return transpiled.outputText.trim();
+}
+function visit(context, classSource, node, state) {
+  const { ts } = context;
+  if (ts.isFunctionLike(node)) {
+    for (const parameter of node.parameters) {
+      if (ts.isIdentifier(parameter.name)) {
+        state.locals.add(parameter.name.text);
+      }
+    }
+  }
+  if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name)) {
+    state.locals.add(node.name.text);
+  }
+  if (ts.isBinaryExpression(node) && isAssignmentOperator(ts, node.operatorToken.kind)) {
+    if (isWholeStateAssignment(ts, node.left)) {
+      throw mpError(classSource.filePath, "\u4E0D\u652F\u6301\u66FF\u6362\u6574\u4E2A this.state\uFF0C\u8BF7\u6539\u7528 this.setState({ ... })");
+    }
+    const path = statePath(ts, node.left);
+    if (path !== undefined) {
+      const assignment = buildStateAssignment(ts, node, classSource.filePath);
+      return ts.visitEachChild(assignment, (child) => visit(context, classSource, child, state), state.transformContext);
+    }
+  }
+  if (ts.isCallExpression(node) && isThisMemberCall(ts, node, "setState")) {
+    const call = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createThis(), "setData"), undefined, node.arguments);
+    return ts.visitEachChild(call, (child) => visit(context, classSource, child, state), state.transformContext);
+  }
+  if (ts.isCallExpression(node) && isThisMemberCall(ts, node, "emit")) {
+    if (state.kind !== "component") {
+      throw mpError(classSource.filePath, "\u9875\u9762\u7EC4\u4EF6\u4E0D\u80FD\u4F7F\u7528 this.emit\uFF08\u7EC4\u4EF6\u95F4\u4E8B\u4EF6\u4EC5\u81EA\u5B9A\u4E49\u7EC4\u4EF6\u652F\u6301\uFF09");
+    }
+    const eventName = node.arguments[0];
+    if (!ts.isStringLiteral(eventName)) {
+      throw mpError(classSource.filePath, "this.emit \u7684\u4E8B\u4EF6\u540D\u5FC5\u987B\u662F\u5B57\u7B26\u4E32\u5B57\u9762\u91CF");
+    }
+    state.customEvents.add(eventName.text);
+    const args = ts.factory.createArrayLiteralExpression(node.arguments.slice(1));
+    const payload = ts.factory.createObjectLiteralExpression([
+      ts.factory.createPropertyAssignment("args", args)
+    ]);
+    const call = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createThis(), "triggerEvent"), undefined, [eventName, payload]);
+    return ts.visitEachChild(call, (child) => visit(context, classSource, child, state), state.transformContext);
+  }
+  if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && isThisExpression(ts, node.expression.expression)) {
+    const methodName = node.expression.name.text;
+    if (!BRIDGE_METHODS.has(methodName)) {
+      state.referencedMethods.push(methodName);
+    }
+  }
+  if (ts.isPropertyAccessExpression(node) && isThisExpression(ts, node.expression)) {
+    if (node.name.text === "state") {
+      return ts.factory.createPropertyAccessExpression(ts.factory.createThis(), "data");
+    }
+    if (node.name.text === "props") {
+      if (state.kind !== "component") {
+        throw mpError(classSource.filePath, "\u9875\u9762\u7EC4\u4EF6\u4E0D\u80FD\u8BBF\u95EE this.props");
+      }
+      return ts.factory.createPropertyAccessExpression(ts.factory.createThis(), "properties");
+    }
+  }
+  if (ts.isIdentifier(node) && !state.locals.has(node.text) && state.consts.has(node.text)) {
+    const folded = foldExpression(ts, state.consts.get(node.text), state.consts);
+    if (folded === undefined) {
+      throw mpError(classSource.filePath, `\u65B9\u6CD5\u4E2D\u5F15\u7528\u4E86\u65E0\u6CD5\u9759\u6001\u6C42\u503C\u7684\u6A21\u5757\u5E38\u91CF "${node.text}"`);
+    }
+    return valueToNode(ts, folded);
+  }
+  return ts.visitEachChild(node, (child) => visit(context, classSource, child, state), state.transformContext);
+}
+var BRIDGE_METHODS = new Set(["emit", "setState", "setData", "triggerEvent"]);
+function buildStateAssignment(ts, node, filePath) {
+  const path = statePath(ts, node.left);
+  if (path === undefined) {
+    throw new Error("internal: state assignment without state path");
+  }
+  const operator = node.operatorToken.kind;
+  const isCompound = operator !== ts.SyntaxKind.EqualsToken;
+  let value;
+  if (isCompound) {
+    const operatorText = compoundOperatorText(ts, operator);
+    if (!operatorText) {
+      throw new Error(`\u4E0D\u652F\u6301\u7684\u590D\u5408\u8D4B\u503C: ${node.operatorToken.getText()} (${filePath})`);
+    }
+    value = ts.factory.createBinaryExpression(node.left, operatorText, node.right);
+  } else {
+    value = node.right;
+  }
+  const key = ts.factory.createStringLiteral(path);
+  const object = ts.factory.createObjectLiteralExpression([
+    ts.factory.createPropertyAssignment(key, value)
+  ]);
+  return ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createThis(), "setData"), undefined, [object]);
+}
+function statePath(ts, left) {
+  const tokens = [];
+  let current = left;
+  for (;; ) {
+    if (ts.isPropertyAccessExpression(current)) {
+      if (isThisExpression(ts, current.expression) && current.name.text === "state") {
+        if (tokens.length === 0) {
+          return;
+        }
+        return tokens.reverse().map((token) => token.startsWith("[") ? token : `.${token}`).join("").slice(1);
+      }
+      tokens.push(current.name.text);
+      current = current.expression;
+      continue;
+    }
+    if (ts.isElementAccessExpression(current)) {
+      const argument = current.argumentExpression;
+      if (!ts.isStringLiteral(argument) && !ts.isNumericLiteral(argument)) {
+        return;
+      }
+      tokens.push(`[${argument.text}]`);
+      current = current.expression;
+      continue;
+    }
+    return;
+  }
+}
+function isAssignmentOperator(ts, kind) {
+  return kind === ts.SyntaxKind.EqualsToken || kind === ts.SyntaxKind.PlusEqualsToken || kind === ts.SyntaxKind.MinusEqualsToken || kind === ts.SyntaxKind.AsteriskEqualsToken || kind === ts.SyntaxKind.SlashEqualsToken || kind === ts.SyntaxKind.PercentEqualsToken || kind === ts.SyntaxKind.LessThanLessThanEqualsToken || kind === ts.SyntaxKind.GreaterThanGreaterThanEqualsToken || kind === ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken || kind === ts.SyntaxKind.AmpersandEqualsToken || kind === ts.SyntaxKind.BarEqualsToken || kind === ts.SyntaxKind.CaretEqualsToken || kind === ts.SyntaxKind.AsteriskAsteriskEqualsToken || kind === ts.SyntaxKind.AmpersandAmpersandEqualsToken || kind === ts.SyntaxKind.BarBarEqualsToken || kind === ts.SyntaxKind.QuestionQuestionEqualsToken;
+}
+function isWholeStateAssignment(ts, left) {
+  return ts.isPropertyAccessExpression(left) && isThisExpression(ts, left.expression) && left.name.text === "state";
+}
+function compoundOperatorText(ts, kind) {
+  switch (kind) {
+    case ts.SyntaxKind.PlusEqualsToken:
+      return ts.SyntaxKind.PlusToken;
+    case ts.SyntaxKind.MinusEqualsToken:
+      return ts.SyntaxKind.MinusToken;
+    case ts.SyntaxKind.AsteriskEqualsToken:
+      return ts.SyntaxKind.AsteriskToken;
+    case ts.SyntaxKind.SlashEqualsToken:
+      return ts.SyntaxKind.SlashToken;
+    case ts.SyntaxKind.PercentEqualsToken:
+      return ts.SyntaxKind.PercentToken;
+    default:
+      return;
+  }
+}
+function isThisMemberCall(ts, node, name) {
+  return ts.isPropertyAccessExpression(node.expression) && isThisExpression(ts, node.expression.expression) && node.expression.name.text === name;
+}
+function isStatic(ts, declaration) {
+  return (declaration.modifiers ?? []).some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword);
+}
+function isAsync(ts, declaration) {
+  return (declaration.modifiers ?? []).some((modifier) => modifier.kind === ts.SyntaxKind.AsyncKeyword);
+}
+function valueToNode(ts, value) {
+  if (typeof value === "string") {
+    return ts.factory.createStringLiteral(value);
+  }
+  if (typeof value === "number") {
+    return ts.factory.createNumericLiteral(String(value));
+  }
+  if (typeof value === "boolean") {
+    return value ? ts.factory.createTrue() : ts.factory.createFalse();
+  }
+  if (value === null) {
+    return ts.factory.createNull();
+  }
+  if (Array.isArray(value)) {
+    return ts.factory.createArrayLiteralExpression(value.map((item) => valueToNode(ts, item)));
+  }
+  return ts.factory.createObjectLiteralExpression(Object.entries(value).map(([key, item]) => ts.factory.createPropertyAssignment(ts.factory.createStringLiteral(key), valueToNode(ts, item))));
+}
+function collectModuleConsts4(context, classSource) {
+  const consts = new Map;
+  for (const statement of classSource.source.statements) {
+    if (!context.ts.isVariableStatement(statement)) {
+      continue;
+    }
+    const isConst = statement.declarationList.flags & context.ts.NodeFlags.Const;
+    if (!isConst) {
+      continue;
+    }
+    for (const declaration of statement.declarationList.declarations) {
+      if (context.ts.isIdentifier(declaration.name) && declaration.initializer) {
+        consts.set(declaration.name.text, declaration.initializer);
+      }
+    }
+  }
+  return consts;
+}
+
+// src/mp/inline.ts
+import { dirname as dirname2, join as join2 } from "path";
+function collectInlineModules(context, classSource) {
+  const { ts } = context;
+  const output = [];
+  const seen = new Set;
+  const stack = new Set;
+  const walk = (source) => {
+    const filePath = source.fileName;
+    if (seen.has(filePath)) {
+      return;
+    }
+    for (const statement of source.statements) {
+      if (!ts.isImportDeclaration(statement)) {
+        continue;
+      }
+      const specifier = statement.moduleSpecifier;
+      if (!ts.isStringLiteral(specifier)) {
+        continue;
+      }
+      const target = resolveRelativeModule(context, filePath, specifier.text);
+      if (!target) {
+        continue;
+      }
+      if (stack.has(target)) {
+        warn(context, `\u6A21\u5757\u5FAA\u73AF\u5F15\u7528\u5DF2\u8DF3\u8FC7: ${target}`);
+        continue;
+      }
+      stack.add(target);
+      walk(readSource(context, target));
+      stack.delete(target);
+    }
+    seen.add(filePath);
+    output.push(compileInlineModule(context, source));
+  };
+  walk(classSource.source);
+  return output;
+}
+function resolveRelativeModule(context, fromFile, specifier) {
+  if (!specifier.startsWith("./") && !specifier.startsWith("../")) {
+    return null;
+  }
+  const base = specifier.endsWith(".ts") ? specifier : `${specifier}.ts`;
+  const resolved = join2(dirname2(fromFile), base);
+  if (isComponentFile(context, resolved)) {
+    return null;
+  }
+  return resolved;
+}
+function isComponentFile(context, filePath) {
+  const { ts } = context;
+  const source = readSource(context, filePath);
+  for (const statement of source.statements) {
+    if (!ts.isClassDeclaration(statement)) {
+      continue;
+    }
+    const name = statement.name?.text;
+    if (!name) {
+      continue;
+    }
+    const isExported2 = statement.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+    if (!isExported2) {
+      continue;
+    }
+    const heritage = statement.heritageClauses?.some((clause) => clause.types.some((type) => {
+      const expr = type.expression;
+      if (!ts.isIdentifier(expr)) {
+        return false;
+      }
+      return expr.text === "Component" || expr.text.endsWith("Component");
+    }));
+    if (heritage) {
+      return true;
+    }
+  }
+  return false;
+}
+function compileInlineModule(context, source) {
+  const { ts } = context;
+  const kept = [];
+  for (const statement of source.statements) {
+    if (ts.isImportDeclaration(statement) || ts.isExportDeclaration(statement) || ts.isExportAssignment(statement) || ts.isInterfaceDeclaration(statement) || ts.isTypeAliasDeclaration(statement)) {
+      continue;
+    }
+    kept.push(statement);
+  }
+  const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
+  const printed = printer.printList(ts.ListFormat.MultiLine, ts.factory.createNodeArray(kept), source);
+  const transpiled = ts.transpileModule(printed, {
+    compilerOptions: {
+      target: ts.ScriptTarget.ESNext,
+      module: ts.ModuleKind.ES2015
+    },
+    reportDiagnostics: false
+  });
+  return transpiled.outputText.replace(/^export\s+/gm, "").trim();
+}
+
+// src/mp/compile.ts
+function compileUnit(context, classSource, options) {
+  const { kind, name } = options;
+  if (kind === "component") {
+    const cached = context.components.get(name);
+    if (cached) {
+      return cached;
+    }
+    if (context.compiling.has(name)) {
+      throw mpError(classSource.filePath, `\u7EC4\u4EF6\u5FAA\u73AF\u5F15\u7528: ${name}`);
+    }
+    context.compiling.add(name);
+  }
+  try {
+    const styles = compileStyles(context, classSource);
+    const { template, builder } = compileTemplate(context, classSource, kind, styles.hoverSelectors);
+    const data = compileState(context, classSource);
+    const usedNames = new Set(builder.handlers);
+    for (const emitter of builder.emitters) {
+      usedNames.add(emitter.method);
+    }
+    const customEvents = new Set;
+    const inlineModules = collectInlineModules(context, classSource);
+    const compiledMethods = compileMethods(context, classSource, usedNames, kind, customEvents);
+    const methods = [...compiledMethods.methods];
+    for (const emitter of builder.emitters) {
+      const key = emitter.key ?? `__transone_emitter_${emitter.event}`;
+      const fn = emitter.passArgs ? `function(e) { this.${emitter.method}(...e.detail.args); }` : `function() { this.${emitter.method}(); }`;
+      methods.push({ key, fn });
+    }
+    const usingComponents = {};
+    for (const [tag, source] of builder.usedComponents) {
+      compileUnit(context, source, { kind: "component", name: tag });
+      usingComponents[tag] = `/components/${tag}/${tag}`;
+    }
+    const unit = {
+      kind,
+      name,
+      template,
+      style: styles.style,
+      globalStyle: styles.global,
+      data,
+      properties: {},
+      propsReferenced: builder.propsReferenced,
+      methods,
+      lifecycle: compiledMethods.lifecycle,
+      customEvents: [...customEvents],
+      usingComponents,
+      inlineModules
+    };
+    if (kind === "component") {
+      context.components.set(name, unit);
+    }
+    return unit;
+  } finally {
+    if (kind === "component") {
+      context.compiling.delete(name);
+    }
+  }
+}
+function finalizeComponentProperties(context) {
+  for (const [tag, unit] of context.components) {
+    const properties = new Map;
+    for (const callSite of context.callSites.get(tag) ?? []) {
+      for (const [name, type] of Object.entries(callSite)) {
+        if (!properties.has(name) || properties.get(name) === "null") {
+          properties.set(name, type);
+        }
+      }
+    }
+    for (const name of unit.propsReferenced) {
+      if (!properties.has(name)) {
+        properties.set(name, "null");
+      }
+    }
+    unit.properties = Object.fromEntries(properties);
+  }
+}
+
+// src/mp/jsgen.ts
+var GENERATED_HEADER = (dialectId) => `// \u7531 transone build --target ${dialectId} \u751F\u6210\uFF0C\u8BF7\u52FF\u624B\u52A8\u7F16\u8F91`;
+function inlinePreamble(unit) {
+  if (unit.inlineModules.length === 0) {
+    return "";
+  }
+  return unit.inlineModules.join(`
+
+`) + `
+
+`;
+}
+function generatePageJs(unit, dialect) {
+  const parts = [
+    GENERATED_HEADER(dialect.id),
+    inlinePreamble(unit),
+    "Page({",
+    `  data: ${embedData(unit.data)},`
+  ];
+  for (const entry of [...unit.methods, ...unit.lifecycle]) {
+    parts.push(`  ${JSON.stringify(entry.key)}: ${entry.fn},`);
+  }
+  parts.push("});");
+  return parts.join(`
+`) + `
+`;
+}
+function generateComponentJs(unit, dialect) {
+  const parts = [
+    GENERATED_HEADER(dialect.id),
+    inlinePreamble(unit),
+    "Component({"
+  ];
+  parts.push(`  properties: ${generatePropertiesSource(unit.properties)},`);
+  parts.push(`  data: ${embedData(unit.data)},`);
+  parts.push("  methods: {");
+  for (const entry of unit.methods) {
+    parts.push(`    ${JSON.stringify(entry.key)}: ${entry.fn},`);
+  }
+  parts.push("  },");
+  if (unit.lifecycle.length > 0) {
+    parts.push("  lifetimes: {");
+    for (const entry of unit.lifecycle) {
+      parts.push(`    ${JSON.stringify(entry.key)}: ${entry.fn},`);
+    }
+    parts.push("  },");
+  }
+  parts.push("});");
+  return parts.join(`
+`) + `
+`;
+}
+function embedData(data) {
+  const body = data.trim().replace(/^\{/, "").replace(/\}$/, "").trim();
+  return `{
+  ${body.replace(/\n/g, `
+  `)}
+  }`;
+}
+function generatePropertiesSource(properties) {
+  const entries = Object.entries(properties);
+  if (entries.length === 0) {
+    return "{}";
+  }
+  const lines = entries.map(([name, type]) => `    ${JSON.stringify(name)}: { type: ${type === "null" ? "null" : type}, value: '' },`);
+  return `{
+${lines.join(`
+`)}
+  }`;
+}
+
+// src/mp/build-mp.ts
+var GENERATED_COMMENT = (dialectId) => `\u7531 transone build --target ${dialectId} \u751F\u6210\uFF0C\u8BF7\u52FF\u624B\u52A8\u7F16\u8F91`;
+async function buildMiniProgram(config, dialect) {
+  const mp = config.mp;
+  if (!mp) {
+    throw new Error("Mini program build requires config.mp");
+  }
+  const ts = await loadTypescript();
+  const context = {
+    ts,
+    root: config.root,
+    files: new Map,
+    components: new Map,
+    compiling: new Set,
+    callSites: new Map,
+    lengthUnit: mp.lengthUnit,
+    dialect,
+    warnings: []
+  };
+  const pages = [];
+  for (const [route, entry] of Object.entries(mp.pages)) {
+    const rootClass = findRootClass(context, entry);
+    const location = pageLocation(route);
+    const unit = compileUnit(context, rootClass, {
+      kind: "page",
+      name: location.name
+    });
+    pages.push({ route, unit });
+  }
+  finalizeComponentProperties(context);
+  for (const warning of context.warnings) {
+    console.warn(`[transone mp] ${warning}`);
+  }
+  const outDir = mp.outDir;
+  await rm(outDir, { recursive: true, force: true });
+  await mkdir(outDir, { recursive: true });
+  const assetsBuilt = [];
+  const write = async (path, content) => {
+    const target = join3(outDir, path);
+    await mkdir(dirname3(target), { recursive: true });
+    await writeFile(target, content, "utf8");
+    assetsBuilt.push(target);
+  };
+  await write(dialect.projectConfigFile, `${JSON.stringify(dialect.buildProjectConfig(mp, basename(config.root)), null, 2)}
+`);
+  await write("app.json", `${JSON.stringify({
+    pages: pages.map(({ route }) => appPagePath(route)),
+    window: {
+      ...dialect.windowDefaults(mp.navigationBarTitleText),
+      ...mp.window
+    },
+    ...mp.tabBar !== undefined ? { tabBar: mp.tabBar } : {},
+    ...mp.appExtra,
+    ...dialect.appJsonExtras()
+  }, null, 2)}
+`);
+  await write("app.js", `App(${JSON.stringify(mp.globalData !== undefined ? { globalData: mp.globalData } : {})});
+`);
+  if (dialect.sitemap) {
+    await write("sitemap.json", `${JSON.stringify({
+      desc: GENERATED_COMMENT(dialect.id),
+      rules: [{ action: "allow", page: "*" }]
+    }, null, 2)}
+`);
+  }
+  const globalStyles = new Set;
+  for (const { unit } of pages) {
+    if (unit.globalStyle) {
+      globalStyles.add(unit.globalStyle);
+    }
+  }
+  await write(dialect.appStyleFile, `${[...globalStyles].join(`
+`)}
+`);
+  for (const { route, unit } of pages) {
+    const base = pageFileBase(route);
+    await write(`pages/${base}.${dialect.templateExt}`, unit.template);
+    await write(`pages/${base}.${dialect.styleExt}`, `${unit.style}
+`);
+    await write(`pages/${base}.js`, generatePageJs(unit, dialect));
+    await write(`pages/${base}.json`, `${JSON.stringify({
+      usingComponents: unit.usingComponents,
+      ...mp.pageExtra?.[route]
+    }, null, 2)}
+`);
+  }
+  for (const [tag, unit] of context.components) {
+    await write(`components/${tag}/${tag}.${dialect.templateExt}`, unit.template);
+    await write(`components/${tag}/${tag}.${dialect.styleExt}`, `${unit.style}
+`);
+    await write(`components/${tag}/${tag}.js`, generateComponentJs(unit, dialect));
+    await write(`components/${tag}/${tag}.json`, `${JSON.stringify(dialect.componentJson(unit.usingComponents), null, 2)}
+`);
+  }
+  if (existsSync2(mp.publicDir)) {
+    for (const file of await listFiles(mp.publicDir)) {
+      const target = join3(outDir, file);
+      if (!existsSync2(target)) {
+        await cp(join3(mp.publicDir, file), target, {
+          recursive: true,
+          force: true,
+          errorOnExist: false
+        });
+      }
+    }
+  }
+  return {
+    root: config.root,
+    outDir: resolve2(outDir),
+    assetsBuilt
+  };
+}
+function pageLocation(route) {
+  const segments = route.replace(/^\/+/, "").split("/").filter(Boolean);
+  if (segments.length === 0) {
+    return { directory: "", name: "index" };
+  }
+  const name = segments[segments.length - 1];
+  const directory = segments.slice(0, -1).join("/");
+  return { directory, name };
+}
+function pageFileBase(route) {
+  const location = pageLocation(route);
+  const directory = location.directory === "" ? location.name : `${location.directory}/${location.name}`;
+  return `${directory}/${location.name}`;
+}
+function appPagePath(route) {
+  return `pages/${pageFileBase(route)}`;
+}
+async function listFiles(root, dir = root) {
+  const out = [];
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const abs = join3(dir, entry.name);
+    if (entry.isDirectory()) {
+      out.push(...await listFiles(root, abs));
+    } else {
+      out.push(relative(root, abs));
+    }
+  }
+  return out;
+}
+export {
+  buildMiniProgram
+};
+
+//# debugId=1B46276CC3CBABAA64756E2164756E21
+//# sourceMappingURL=build-mp-kcnx989m.js.map