transone-cli 0.7.0 → 0.10.0

package/dist/{build-mp-vk5ap2cw.js → build-mp-y5pwahsy.js}

@@ -1,16 +1,28 @@
 // @bun
 import {
-  loadTypescript
-} from "./index-k1qfvp0y.js";
-import"./index-yb2wsc7f.js";
+  buildInputPaths,
+  buildOutputPath,
+  loadTypescript,
+  withBuildOutput
+} from "./index-xgn9fbc6.js";
+import {
+  createComponentIndex
+} from "./index-j4h0wd27.js";
 
 // src/mp/build-mp.ts
-import { cp, mkdir, readdir, rm, writeFile } from "fs/promises";
-import { existsSync as existsSync2 } from "fs";
+import { cp, mkdir, readdir, writeFile } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
 import { fileURLToPath } from "url";
-import { basename, dirname as dirname3, join as join3, relative, resolve as resolve2 } from "path";
+import { basename, dirname as dirname4, join as join4, relative, resolve as resolve3 } from "path";
 
 // src/mp/analyze.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { dirname as dirname2, join as join2, resolve as resolve2 } from "path";
+
+// src/mp/inheritance.ts
+import { createHash } from "crypto";
+
+// src/mp/source.ts
 import { existsSync, readFileSync } from "fs";
 import { dirname, join, resolve } from "path";
 
@@ -27,6 +39,217 @@ function mpError(file, message) {
   return new MpCompileError(file, message);
 }
 
+// src/mp/source.ts
+function runtimeOwner(context, reference) {
+  if (!reference.source.isDeclarationFile)
+    return { ...reference, reference };
+  const cache = context.packageSources ??= new Map;
+  const cached = cache.get(reference.id);
+  if (cached)
+    return cached;
+  let directory = dirname(reference.filePath);
+  let entry;
+  for (;; ) {
+    const manifest = join(directory, "package.json");
+    if (existsSync(manifest)) {
+      const pkg = JSON.parse(readFileSync(manifest, "utf8"));
+      if (typeof pkg.source !== "string" || !pkg.source)
+        throw mpError(reference.filePath, "\u58F0\u660E\u7EC4\u4EF6\u6240\u5728\u5305\u7F3A\u5C11 source \u5B57\u6BB5\uFF1A\u5C0F\u7A0B\u5E8F\u9700\u8981\u53EF\u7F16\u8BD1\u7684 TypeScript \u6E90\u7801");
+      const base = resolve(directory, pkg.source);
+      entry = [base, `${base}.ts`, `${base}.tsx`].find(existsSync);
+      if (!entry)
+        throw mpError(reference.filePath, `\u5305 source \u6307\u5411\u7684\u6587\u4EF6\u4E0D\u5B58\u5728: ${pkg.source}`);
+      break;
+    }
+    const parent = dirname(directory);
+    if (parent === directory)
+      throw mpError(reference.filePath, "\u65E0\u6CD5\u5B9A\u4F4D\u58F0\u660E\u7EC4\u4EF6\u7684 package.json/source");
+    directory = parent;
+  }
+  const owner = {
+    ...loadSourceExport(context, entry, [reference.exportName, reference.className].filter((name) => !!name)),
+    reference
+  };
+  cache.set(reference.id, owner);
+  return owner;
+}
+function loadSourceExport(context, entry, names) {
+  const program = sourceProgram(context, entry);
+  const checker = program.getTypeChecker();
+  const source = program.getSourceFile(entry);
+  const module = checker.getSymbolAtLocation(source);
+  const exports = module ? checker.getExportsOfModule(module) : [];
+  const exported = names.map((name) => exports.find((symbol2) => symbol2.name === name)).find(Boolean);
+  const symbol = exported && unalias(context, checker, exported);
+  const declaration = symbol?.valueDeclaration ?? symbol?.declarations?.find(context.ts.isClassDeclaration);
+  if (!declaration || !context.ts.isClassDeclaration(declaration))
+    throw mpError(entry, `source \u4E2D\u627E\u4E0D\u5230\u7EC4\u4EF6\u7C7B ${names.join(" / ")}`);
+  const owner = {
+    filePath: declaration.getSourceFile().fileName,
+    source: declaration.getSourceFile(),
+    declaration,
+    className: declaration.name?.text ?? names[0]
+  };
+  (context.packageComponentSources ??= new Set).add(owner.source);
+  return owner;
+}
+function sourceProgram(context, entry) {
+  const programs = context.sourcePrograms ??= new Map;
+  const cached = programs.get(entry);
+  if (cached)
+    return cached;
+  const { ts } = context;
+  const configPath = ts.findConfigFile(context.root, ts.sys.fileExists);
+  const config = configPath && ts.readConfigFile(configPath, ts.sys.readFile);
+  const options = configPath && config && !config.error ? ts.parseJsonConfigFileContent(config.config, ts.sys, dirname(configPath)).options : {
+    target: ts.ScriptTarget.ESNext,
+    module: ts.ModuleKind.ESNext,
+    moduleResolution: ts.ModuleResolutionKind.Bundler
+  };
+  const program = ts.createProgram([entry], { ...options, noEmit: true });
+  program.getTypeChecker();
+  for (const source of program.getSourceFiles()) {
+    if (source.isDeclarationFile)
+      continue;
+    programs.set(source.fileName, program);
+    context.files.set(source.fileName, source);
+  }
+  programs.set(entry, program);
+  return program;
+}
+function sourceSymbolAt(context, node, source = node.getSourceFile()) {
+  const indexed = context.index?.symbolAt(node, source);
+  if (indexed)
+    return indexed;
+  const program = context.sourcePrograms?.get(source.fileName);
+  if (!program)
+    return;
+  const { ts } = context;
+  const checker = program.getTypeChecker();
+  const original = ts.getOriginalNode(node);
+  let symbol = ts.isIdentifier(original) && ts.isShorthandPropertyAssignment(original.parent) ? checker.getShorthandAssignmentValueSymbol(original.parent) : checker.getSymbolAtLocation(original);
+  if (!symbol && ts.isElementAccessExpression(original) && (ts.isStringLiteralLike(original.argumentExpression) || ts.isNumericLiteral(original.argumentExpression))) {
+    symbol = checker.getPropertyOfType(checker.getTypeAtLocation(original.expression), original.argumentExpression.text);
+  }
+  return symbol && unalias(context, checker, symbol);
+}
+function unalias(context, checker, symbol) {
+  const seen = new Set;
+  while (symbol.flags & context.ts.SymbolFlags.Alias && !seen.has(symbol)) {
+    seen.add(symbol);
+    symbol = checker.getAliasedSymbol(symbol);
+  }
+  return symbol;
+}
+
+// src/mp/inheritance.ts
+function reference(context, source) {
+  return source.reference ?? context.index?.findClass(source.filePath, source.className);
+}
+function selected(context, ref) {
+  const implementation = context.index.select(ref);
+  return { ...runtimeOwner(context, implementation), logical: ref };
+}
+function ownedMethods(context, source) {
+  const ref = reference(context, source);
+  const effectiveOwners = new Set(ref && context.index ? context.index.members(ref).filter((member) => context.ts.isMethodDeclaration(member.declaration)).map((member) => member.owner.id) : []);
+  const owners = ref && context.index ? context.index.hierarchy(ref).filter((owner) => !owner.source.isDeclarationFile || effectiveOwners.has(owner.id)).map((owner) => runtimeOwner(context, owner)) : [source];
+  const effective = new Map;
+  for (const owner of owners) {
+    for (const declaration of owner.declaration.members) {
+      if (!declaration.name)
+        continue;
+      const isStatic = context.ts.canHaveModifiers(declaration) && context.ts.getModifiers(declaration)?.some((item) => item.kind === context.ts.SyntaxKind.StaticKeyword);
+      const name = context.ts.isIdentifier(declaration.name) || context.ts.isStringLiteralLike(declaration.name) ? declaration.name.text : declaration.name.getText(owner.source);
+      effective.set(`${isStatic ? "static:" : ""}${name}`, {
+        owner,
+        declaration
+      });
+    }
+  }
+  const members = [...effective.values()];
+  return members.filter((item) => context.ts.isMethodDeclaration(item.declaration) && !item.declaration.modifiers?.some((m) => m.kind === context.ts.SyntaxKind.StaticKeyword)).map((item) => ({ owner: item.owner, declaration: item.declaration }));
+}
+function ownedMethod(context, source, name) {
+  return ownedMethods(context, source).find((item) => item.declaration.name.getText(item.owner.source) === name);
+}
+function parentSource(context, source) {
+  const ref = reference(context, source);
+  return ref && context.index?.metadata(ref).parent;
+}
+function stableTag(context, source) {
+  const ref = source.logical ?? reference(context, source);
+  const name = ref?.className ?? source.className;
+  const normalize = (value) => value.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[^A-Za-z0-9-]/g, "").toLowerCase();
+  const tag = normalize(name);
+  if (!tag)
+    throw new Error(`\u65E0\u6CD5\u4ECE\u7C7B\u540D "${name}" \u751F\u6210\u7EC4\u4EF6\u6807\u7B7E\u540D`);
+  if (!ref || !context.index)
+    return tag;
+  const metadata = context.index.metadata(ref);
+  const explicitImplementation = metadata.platforms.length > 0;
+  const collides = context.index.classes.some((other) => {
+    if (other.id === ref.id || !context.index.isComponent(other))
+      return false;
+    const otherMetadata = context.index.metadata(other);
+    if (!explicitImplementation && otherMetadata.platforms.length > 0)
+      return false;
+    return normalize(other.className) === tag;
+  });
+  return collides ? `${tag}-${createHash("sha256").update(ref.id.replace(context.root, "")).digest("hex").slice(0, 8)}` : tag;
+}
+function moduleConstants(context, source) {
+  const api = context.ts;
+  const constants = new Map;
+  const expand = (expression, seen = new Set) => {
+    if (!context.index)
+      return expression;
+    const result = api.transform(expression, [
+      (transformContext) => (root) => {
+        const visit = (node) => {
+          if (api.isShorthandPropertyAssignment(node)) {
+            return api.factory.createPropertyAssignment(node.name.text, visit(node.name));
+          }
+          const keyOnly = api.isIdentifier(node) && node.parent && (api.isPropertyAssignment(node.parent) && node.parent.name === node || api.isPropertyAccessExpression(node.parent) && node.parent.name === node);
+          if (!keyOnly && (api.isIdentifier(node) || api.isPropertyAccessExpression(node))) {
+            const declaration = sourceSymbolAt(context, node)?.valueDeclaration;
+            if (declaration && api.isVariableDeclaration(declaration) && declaration.initializer && !seen.has(declaration) && api.isVariableDeclarationList(declaration.parent) && declaration.parent.flags & api.NodeFlags.Const) {
+              return expand(declaration.initializer, new Set([...seen, declaration]));
+            }
+          }
+          return api.visitEachChild(node, visit, transformContext);
+        };
+        return api.visitNode(root, visit);
+      }
+    ]);
+    const value = result.transformed[0];
+    result.dispose();
+    return value;
+  };
+  for (const statement of source.source.statements) {
+    if (api.isVariableStatement(statement) && statement.declarationList.flags & api.NodeFlags.Const) {
+      for (const declaration of statement.declarationList.declarations) {
+        if (api.isIdentifier(declaration.name) && declaration.initializer)
+          constants.set(declaration.name.text, expand(declaration.initializer));
+      }
+    }
+    if (context.index && api.isImportDeclaration(statement)) {
+      const clause = statement.importClause;
+      const bindings = clause?.namedBindings;
+      const names = [
+        ...clause?.name ? [clause.name] : [],
+        ...bindings && api.isNamedImports(bindings) ? bindings.elements.map((item) => item.name) : []
+      ];
+      for (const name of names) {
+        const declaration = sourceSymbolAt(context, name)?.valueDeclaration;
+        if (declaration && api.isVariableDeclaration(declaration) && declaration.initializer)
+          constants.set(name.text, expand(declaration.initializer));
+      }
+    }
+  }
+  return constants;
+}
+
 // src/mp/fold.ts
 function foldExpression(ts, node, consts, seen = new Set) {
   node = unwrapParentheses(ts, node);
@@ -104,6 +327,13 @@ function foldExpression(ts, node, consts, seen = new Set) {
   if (ts.isObjectLiteralExpression(node)) {
     const result = {};
     for (const property of node.properties) {
+      if (ts.isSpreadAssignment(property)) {
+        const spread = foldExpression(ts, property.expression, consts, seen);
+        if (!spread || typeof spread !== "object" || Array.isArray(spread))
+          return;
+        Object.assign(result, spread);
+        continue;
+      }
       if (ts.isPropertyAssignment(property)) {
         const key = propertyNameText(ts, property.name);
         const value = foldExpression(ts, property.initializer, consts, seen);
@@ -238,10 +468,10 @@ function readSource(context, filePath) {
   if (cached) {
     return cached;
   }
-  if (!existsSync(filePath)) {
+  if (!existsSync2(filePath)) {
     throw mpError(filePath, "\u6E90\u6587\u4EF6\u4E0D\u5B58\u5728");
   }
-  const text = readFileSync(filePath, "utf8");
+  const text = readFileSync2(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;
@@ -280,12 +510,8 @@ function findRootClass(context, filePath) {
       declaration: statement,
       className: name
     })) {
-      return {
-        filePath,
-        source,
-        declaration: statement,
-        className: name
-      };
+      const ref = context.index?.findClass(filePath, name);
+      return ref ? selected(context, ref) : { filePath, source, declaration: statement, className: name };
     }
   }
   for (const [name, declaration] of localClasses) {
@@ -295,13 +521,17 @@ function findRootClass(context, filePath) {
       declaration,
       className: name
     })) {
-      return { filePath, source, declaration, className: name };
+      const ref = context.index?.findClass(filePath, name);
+      return ref ? selected(context, ref) : { 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;
+  const indexed = context.index?.resolve(expr, from.source);
+  if (indexed)
+    return selected(context, indexed);
   expr = unwrapParentheses(ts, expr);
   if (ts.isClassExpression(expr) || ts.isClassDeclaration(expr)) {
     const name2 = expr.name?.text;
@@ -337,6 +567,9 @@ function resolveClassReference(context, from, expr) {
 }
 function isComponentSubclass(context, classSource) {
   const { ts } = context;
+  const indexed = reference(context, classSource);
+  if (indexed && context.index.isComponent(indexed))
+    return true;
   const heritage = classSource.declaration.heritageClauses ?? [];
   const imports = collectImports(ts, classSource.source);
   for (const clause of heritage) {
@@ -396,6 +629,8 @@ function resolvePackageClass(context, from, localName, binding) {
   if (!targetPath) {
     throw mpError(from.filePath, `\u5305 "${binding.specifier}" \u7684 "source" \u6307\u5411\u7684\u6587\u4EF6\u4E0D\u5B58\u5728: ${sourceField}`);
   }
+  if (context.index)
+    return loadSourceExport(context, targetPath, [binding.importedName]);
   const source = readSource(context, targetPath);
   const importedName = binding.importedName;
   const found = findExportedClass(context, source, importedName, new Set);
@@ -411,19 +646,22 @@ function resolvePackageClass(context, from, localName, binding) {
 }
 function findPackageInfo(fromFile, specifier) {
   const segments = specifier.split("/");
-  const packageJsonRelative = join("node_modules", ...segments, "package.json");
-  let current = dirname(fromFile);
+  const packageJsonRelative = join2("node_modules", ...segments, "package.json");
+  let current = dirname2(fromFile);
   for (;; ) {
-    const candidate = join(current, packageJsonRelative);
-    if (existsSync(candidate)) {
+    const candidate = join2(current, packageJsonRelative);
+    if (existsSync2(candidate)) {
       try {
-        const json = JSON.parse(readFileSync(candidate, "utf8"));
-        return { dir: join(current, "node_modules", ...segments), source: json.source };
+        const json = JSON.parse(readFileSync2(candidate, "utf8"));
+        return {
+          dir: join2(current, "node_modules", ...segments),
+          source: json.source
+        };
       } catch {
         return;
       }
     }
-    const parent = dirname(current);
+    const parent = dirname2(current);
     if (parent === current) {
       return;
     }
@@ -431,9 +669,9 @@ function findPackageInfo(fromFile, specifier) {
   }
 }
 function resolvePackageSource(packageDir, sourceField) {
-  const base = resolve(packageDir, sourceField);
+  const base = resolve2(packageDir, sourceField);
   const candidates = [base, `${base}.ts`, `${base}.tsx`];
-  return candidates.find((candidate) => existsSync(candidate));
+  return candidates.find((candidate) => existsSync2(candidate));
 }
 function findExportedClass(context, source, name, seen) {
   const { ts } = context;
@@ -544,15 +782,15 @@ function collectImports(ts, source) {
   return imports;
 }
 function resolveImportPath(fromFile, specifier) {
-  const base = resolve(dirname(fromFile), specifier);
+  const base = resolve2(dirname2(fromFile), specifier);
   const candidates = [
     base,
     `${base}.ts`,
     `${base}.tsx`,
-    join(base, "index.ts"),
-    join(base, "index.tsx")
+    join2(base, "index.ts"),
+    join2(base, "index.tsx")
   ];
-  return candidates.find((candidate) => existsSync(candidate));
+  return candidates.find((candidate) => existsSync2(candidate));
 }
 function isExported(ts, declaration) {
   return (declaration.modifiers ?? []).some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword);
@@ -941,7 +1179,10 @@ function eventNameFromProp(key) {
 }
 function compileTemplate(context, classSource, _kind, hoverSelectors = new Set) {
   const { ts } = context;
-  const renderMethod = findMethod(context, classSource, "render");
+  const owned = ownedMethod(context, classSource, "render");
+  const renderMethod = owned?.declaration;
+  if (owned)
+    classSource = owned.owner;
   if (!renderMethod) {
     throw mpError(classSource.filePath, `\u7EC4\u4EF6 ${classSource.className} \u7F3A\u5C11 render() \u65B9\u6CD5`);
   }
@@ -1218,7 +1459,9 @@ 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}}}">`];
+  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) {
@@ -1360,7 +1603,7 @@ function compileComponent(context, classSource, classExpr, propsExpr, childrenEx
   if (!isComponentSubclass(context, target)) {
     throw mpError(classSource.filePath, `createComponent \u53EA\u63A5\u53D7 Component \u5B50\u7C7B: ${target.className}`);
   }
-  const tag = kebabCase(target.className);
+  const tag = stableTag(context, target);
   env.builder.usedComponents.set(tag, target);
   const attrs = [...env.extraAttrs];
   const callSiteProps = {};
@@ -1480,7 +1723,12 @@ 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: "" };
+    return {
+      event: "pending",
+      method: handlerExpr.name.text,
+      passArgs: true,
+      key: ""
+    };
   }
   if (!ts.isArrowFunction(handlerExpr)) {
     return;
@@ -1760,22 +2008,7 @@ function objectProperty(ts, object, key) {
   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;
+  return moduleConstants(context, classSource);
 }
 function collectFactoryOrigins(ts, source) {
   const origins = new Map;
@@ -1847,10 +2080,6 @@ function escapeAttr(value) {
 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([
@@ -1871,29 +2100,39 @@ var UNITLESS_PROPERTIES = new Set([
 ]);
 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 entries = new Map;
+  const collect = (source) => {
+    const owned = ownedMethod(context, source, "initStyles");
+    if (!owned?.declaration.body)
+      return;
+    const owner = owned.owner;
+    const consts = collectModuleConsts2(context, owner);
+    for (const statement of owned.declaration.body.statements) {
+      if (ts.isEmptyStatement(statement))
+        continue;
+      if (!ts.isExpressionStatement(statement))
+        throw mpError(owner.filePath, "initStyles() \u53EA\u652F\u6301 this.styleManager.addStyle(...) \u4E0E super.initStyles() \u8C03\u7528");
+      const expression = statement.expression;
+      if (ts.isCallExpression(expression) && ts.isPropertyAccessExpression(expression.expression) && expression.expression.expression.kind === ts.SyntaxKind.SuperKeyword && expression.expression.name.text === "initStyles" && expression.arguments.length === 0) {
+        const parent = parentSource(context, owner);
+        if (parent)
+          collect(parent);
+        continue;
+      }
+      const entry = addStyleEntry(context, owner, expression, consts);
+      if (entry && ts.isCallExpression(expression)) {
+        const name = expression.arguments[0] && foldExpression(ts, expression.arguments[0], consts);
+        if (typeof name !== "string")
+          throw mpError(owner.filePath, "addStyle \u540D\u79F0\u5FC5\u987B\u80FD\u9759\u6001\u6C42\u503C");
+        entries.set(name, entry);
+      }
     }
-  }
+  };
+  collect(classSource);
   const local = [];
   const global = [];
   const hoverSelectors = new Set;
-  for (const entry of entries) {
+  for (const entry of entries.values()) {
     const target = entry.selector === "body" ? global : local;
     target.push(renderStyle(entry, context.lengthUnit));
     if (entry.hover && entry.selector !== "body") {
@@ -2035,28 +2274,16 @@ function objectProperty2(ts, object, key) {
   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;
+  return moduleConstants(context, classSource);
 }
 
 // src/mp/state.ts
 function compileState(context, classSource) {
   const { ts } = context;
-  const method = findMethod(context, classSource, "initState");
+  const owned = ownedMethod(context, classSource, "initState");
+  const method = owned?.declaration;
+  if (owned)
+    classSource = owned.owner;
   if (!method?.body) {
     return "{}";
   }
@@ -2086,29 +2313,435 @@ function compileState(context, classSource) {
     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);
+  const replaceSuper = (expression) => {
+    const transformed = ts.transform(expression, [
+      (transformContext) => (node) => {
+        const visit = (current) => {
+          if (ts.isCallExpression(current) && ts.isPropertyAccessExpression(current.expression) && current.expression.expression.kind === ts.SyntaxKind.SuperKeyword && current.expression.name.text === "initState" && current.arguments.length === 0) {
+            const parent = parentSource(context, classSource);
+            const text = parent ? compileState(context, parent) : "{}";
+            return ts.createSourceFile("state.ts", `(${text})`, ts.ScriptTarget.Latest, true).statements.filter(ts.isExpressionStatement)[0].expression;
+          }
+          return ts.visitEachChild(current, visit, transformContext);
+        };
+        return ts.visitNode(node, visit);
+      }
+    ]);
+    const result = transformed.transformed[0];
+    transformed.dispose();
+    return result;
+  };
+  for (const [name, value2] of allConsts)
+    allConsts.set(name, replaceSuper(value2));
+  const value = foldExpression(ts, replaceSuper(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)) {
+  return moduleConstants(context, classSource);
+}
+
+// src/mp/inline.ts
+import { dirname as dirname3, join as join3 } 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 = join3(dirname3(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 isConst = statement.declarationList.flags & context.ts.NodeFlags.Const;
-    if (!isConst) {
+    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 = [];
+  const requestImports = [];
+  for (const statement of source.statements) {
+    if (ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier) && statement.moduleSpecifier.text === "transone/request" && !statement.importClause?.isTypeOnly) {
+      const clause = statement.importClause;
+      if (clause?.name)
+        requestImports.push(`const ${clause.name.text} = getApp().__transoneRequest.default;`);
+      const bindings = clause?.namedBindings;
+      if (bindings && ts.isNamespaceImport(bindings)) {
+        requestImports.push(`const ${bindings.name.text} = getApp().__transoneRequest;`);
+      } else if (bindings && ts.isNamedImports(bindings)) {
+        for (const item of bindings.elements) {
+          if (!item.isTypeOnly)
+            requestImports.push(`const ${item.name.text} = getApp().__transoneRequest[${JSON.stringify(item.propertyName?.text ?? item.name.text)}];`);
+        }
+      }
+    }
+    if (ts.isImportDeclaration(statement) || ts.isExportDeclaration(statement) || ts.isExportAssignment(statement) || ts.isInterfaceDeclaration(statement) || ts.isTypeAliasDeclaration(statement)) {
+      continue;
+    }
+    if (ts.isClassDeclaration(statement) && statement.heritageClauses?.some((clause) => clause.types.some((type) => ts.isIdentifier(type.expression) && (type.expression.text === "Component" || type.expression.text.endsWith("Component")))))
       continue;
+    if (ts.isVariableStatement(statement)) {
+      const declarations = statement.declarationList.declarations.filter((declaration) => !(declaration.initializer && ts.isCallExpression(declaration.initializer) && ts.isIdentifier(declaration.initializer.expression) && declaration.initializer.expression.text === "createApp"));
+      if (declarations.length === 0)
+        continue;
+      kept.push(ts.factory.updateVariableStatement(statement, statement.modifiers, ts.factory.updateVariableDeclarationList(statement.declarationList, declarations)));
+      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 [
+    ...requestImports,
+    transpiled.outputText.replace(/^export\s+/gm, "").trim()
+  ].join(`
+`);
+}
+
+class MethodModuleLinker {
+  context;
+  names = new Map;
+  entries = new Map;
+  dependencies = new Map;
+  constructor(context) {
+    this.context = context;
+  }
+  modules() {
+    const { ts } = this.context;
+    let size = -1;
+    const linkedSize = () => this.names.size + [...this.entries.values()].reduce((count, entries) => count + entries.size, 0);
+    while (size !== linkedSize()) {
+      size = linkedSize();
+      for (const [source, entries] of this.entries) {
+        const componentModule = this.context.packageComponentSources?.has(source) || this.context.index.classes.some((ref) => ref.source === source && this.context.index.isComponent(ref));
+        for (const statement of source.statements) {
+          if (ts.isImportDeclaration(statement)) {
+            if (!statement.importClause && !componentModule)
+              throw mpError(source.fileName, `\u5C0F\u7A0B\u5E8F helper \u6682\u4E0D\u652F\u6301\u526F\u4F5C\u7528\u5BFC\u5165: ${statement.moduleSpecifier.getText(source)}`);
+            continue;
+          }
+          if (ts.isVariableStatement(statement)) {
+            for (const declaration of statement.declarationList.declarations) {
+              if (componentModule && !this.names.has(declaration) && (!declaration.initializer || !this.referencesLinkedValue(declaration.initializer)))
+                continue;
+              if (!componentModule && !this.names.has(declaration) && (!declaration.initializer || !this.mayInitialize(declaration.initializer)))
+                continue;
+              if (!ts.isIdentifier(declaration.name))
+                throw mpError(source.fileName, "\u5C0F\u7A0B\u5E8F helper \u9876\u5C42\u89E3\u6784\u521D\u59CB\u5316\u6682\u4E0D\u652F\u6301");
+              this.link(declaration);
+            }
+            continue;
+          }
+          if (ts.isClassDeclaration(statement) && !componentModule && !this.names.has(statement) && statement.members.some((member) => ts.isClassStaticBlockDeclaration(member) || ts.isPropertyDeclaration(member) && member.initializer && member.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword))) {
+            throw mpError(source.fileName, `\u5C0F\u7A0B\u5E8F helper \u672A\u5F15\u7528\u7C7B\u7684\u9759\u6001\u521D\u59CB\u5316\u6682\u4E0D\u652F\u6301: ${statement.name?.text ?? "default"}`);
+          }
+          if (ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement) || ts.isInterfaceDeclaration(statement) || ts.isTypeAliasDeclaration(statement) || ts.isExportDeclaration(statement))
+            continue;
+          if (componentModule && !this.referencesLinkedValue(statement))
+            continue;
+          if (ts.isExportAssignment(statement) || ts.isEnumDeclaration(statement) || ts.isModuleDeclaration(statement)) {
+            throw mpError(source.fileName, `\u5C0F\u7A0B\u5E8F helper \u4E0D\u652F\u6301\u6B64\u521D\u59CB\u5316\u8BED\u53E5: ${statement.getText(source).slice(0, 80)}`);
+          }
+          entries.set(statement, this.rewrite(statement, source));
+        }
+      }
     }
-    for (const declaration of statement.declarationList.declarations) {
-      if (context.ts.isIdentifier(declaration.name) && declaration.initializer) {
-        consts.set(declaration.name.text, declaration.initializer);
+    const output = [];
+    const visited = new Set;
+    const active = new Set;
+    const emit = (source) => {
+      if (visited.has(source))
+        return;
+      if (active.has(source))
+        throw mpError(source.fileName, "\u5C0F\u7A0B\u5E8F helper \u6A21\u5757\u5B58\u5728\u5FAA\u73AF\u521D\u59CB\u5316\u4F9D\u8D56");
+      active.add(source);
+      for (const dependency of this.orderedDependencies(source))
+        emit(dependency);
+      active.delete(source);
+      visited.add(source);
+      const statements = [...this.entries.get(source)?.entries() ?? []].sort(([a], [b]) => a.pos - b.pos).map(([, node]) => node);
+      const printer = ts.createPrinter();
+      const printed = statements.map((node) => printer.printNode(ts.EmitHint.Unspecified, node, source)).join(`
+`);
+      const result = ts.transpileModule(printed, {
+        compilerOptions: {
+          target: ts.ScriptTarget.ESNext,
+          module: ts.ModuleKind.ESNext
+        },
+        reportDiagnostics: true
+      });
+      const error = result.diagnostics?.find((item) => item.category === ts.DiagnosticCategory.Error);
+      if (error)
+        throw mpError(source.fileName, `helper \u8F6C\u6362\u5931\u8D25: ${ts.flattenDiagnosticMessageText(error.messageText, " ")}`);
+      output.push(result.outputText.replace(/^export\s+(default\s+)?/gm, "").trim());
+    };
+    const dependedOn = new Set([...this.dependencies.values()].flatMap((values) => [...values]));
+    for (const source of this.entries.keys())
+      if (!dependedOn.has(source))
+        emit(source);
+    for (const source of this.entries.keys())
+      emit(source);
+    return output;
+  }
+  mayInitialize(node) {
+    const { ts } = this.context;
+    if (ts.isArrowFunction(node) || ts.isFunctionExpression(node) || ts.isIdentifier(node) || ts.isStringLiteralLike(node) || ts.isNumericLiteral(node) || [
+      ts.SyntaxKind.TrueKeyword,
+      ts.SyntaxKind.FalseKeyword,
+      ts.SyntaxKind.NullKeyword
+    ].includes(node.kind))
+      return false;
+    if (ts.isParenthesizedExpression(node) || ts.isAsExpression(node) || ts.isTypeAssertionExpression(node) || ts.isSatisfiesExpression(node) || ts.isNonNullExpression(node))
+      return this.mayInitialize(node.expression);
+    if (ts.isArrayLiteralExpression(node))
+      return node.elements.some((item) => ts.isSpreadElement(item) || this.mayInitialize(item));
+    if (ts.isObjectLiteralExpression(node))
+      return node.properties.some((property) => {
+        if (ts.isSpreadAssignment(property))
+          return true;
+        if (property.name && ts.isComputedPropertyName(property.name) && this.mayInitialize(property.name.expression))
+          return true;
+        return ts.isPropertyAssignment(property) && this.mayInitialize(property.initializer);
+      });
+    return true;
+  }
+  orderedDependencies(source) {
+    const { ts } = this.context;
+    const order = new Map;
+    source.statements.forEach((statement, position) => {
+      if (!ts.isImportDeclaration(statement))
+        return;
+      const clause = statement.importClause;
+      const bindings = clause?.namedBindings;
+      const names = [
+        statement.moduleSpecifier,
+        ...clause?.name ? [clause.name] : [],
+        ...bindings && ts.isNamedImports(bindings) ? bindings.elements.map((item) => item.name) : bindings ? [bindings.name] : []
+      ];
+      for (const name of names) {
+        const symbol = sourceSymbolAt(this.context, name, source);
+        for (const declaration of symbol?.declarations ?? []) {
+          const owner = declaration.getSourceFile();
+          if (!order.has(owner))
+            order.set(owner, position);
+        }
       }
+    });
+    return [...this.dependencies.get(source) ?? []].sort((a, b) => (order.get(a) ?? Number.MAX_SAFE_INTEGER) - (order.get(b) ?? Number.MAX_SAFE_INTEGER));
+  }
+  referencesLinkedValue(node, seen = new Set) {
+    const { ts } = this.context;
+    if (seen.has(node))
+      return false;
+    seen.add(node);
+    if (ts.isIdentifier(node) || ts.isPropertyAccessExpression(node)) {
+      const declaration = sourceSymbolAt(this.context, node)?.valueDeclaration;
+      if (declaration && this.names.has(declaration))
+        return true;
+      if (declaration && !seen.has(declaration)) {
+        if (ts.isFunctionDeclaration(declaration) && declaration.body && this.referencesLinkedValue(declaration.body, seen))
+          return true;
+        if (ts.isVariableDeclaration(declaration) && declaration.initializer && this.referencesLinkedValue(declaration.initializer, seen))
+          return true;
+      }
+    }
+    return ts.forEachChild(node, (child) => this.referencesLinkedValue(child, seen) || undefined) ?? false;
+  }
+  linkFrom(declaration, source) {
+    const name = this.link(declaration);
+    const dependency = declaration.getSourceFile();
+    if (name && dependency !== source) {
+      if (!this.entries.has(source))
+        this.entries.set(source, new Map);
+      const dependencies = this.dependencies.get(source) ?? new Set;
+      dependencies.add(dependency);
+      this.dependencies.set(source, dependencies);
+    }
+    return name;
+  }
+  rewrite(node, source) {
+    const { ts } = this.context;
+    const result = ts.transform(node, [
+      (transformContext) => (root) => {
+        const visit = (current) => {
+          if (ts.isShorthandPropertyAssignment(current)) {
+            const request = this.requestReference(current.name, source);
+            if (request)
+              return ts.factory.createPropertyAssignment(current.name.text, request);
+            const original = ts.getOriginalNode(current.name);
+            const declaration = original.pos >= 0 && original.getSourceFile() ? sourceSymbolAt(this.context, original, source)?.valueDeclaration : undefined;
+            const linked = declaration && this.linkFrom(declaration, source);
+            if (linked)
+              return ts.factory.createPropertyAssignment(current.name.text, ts.factory.createIdentifier(linked));
+            return current;
+          }
+          if (ts.isIdentifier(current) || ts.isPropertyAccessExpression(current)) {
+            const parent = current.parent;
+            const keyOnly = ts.isIdentifier(current) && parent && (ts.isPropertyAccessExpression(parent) && parent.name === current || ts.isPropertyAssignment(parent) && parent.name === current || ts.isMethodDeclaration(parent) && parent.name === current);
+            if (!keyOnly) {
+              const request = this.requestReference(current, source);
+              if (request)
+                return request;
+              const original = ts.getOriginalNode(current);
+              const symbol = original.pos >= 0 && original.getSourceFile() ? sourceSymbolAt(this.context, original, source) : undefined;
+              const declaration = symbol?.valueDeclaration;
+              const linked = declaration && this.linkFrom(declaration, source);
+              if (linked)
+                return ts.factory.createIdentifier(linked);
+            }
+          }
+          return ts.visitEachChild(current, visit, transformContext);
+        };
+        return ts.visitNode(root, visit);
+      }
+    ]);
+    const transformed = result.transformed[0];
+    result.dispose();
+    return transformed;
+  }
+  requestReference(node, source) {
+    const { ts } = this.context;
+    const parent = node.parent;
+    if (parent && ts.isIdentifier(node) && (ts.isParameter(parent) || ts.isVariableDeclaration(parent) || ts.isFunctionDeclaration(parent) || ts.isClassDeclaration(parent) || ts.isBindingElement(parent)) && parent.name === node)
+      return;
+    let local;
+    let member;
+    if (ts.isIdentifier(node))
+      local = node.text;
+    if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression)) {
+      local = node.expression.text;
+      member = node.name.text;
+    }
+    if (!local)
+      return;
+    const original = ts.getOriginalNode(ts.isPropertyAccessExpression(node) ? node.expression : node);
+    if (original.pos < 0 || !original.getSourceFile())
+      return;
+    const symbol = sourceSymbolAt(this.context, original, source);
+    if (!symbol)
+      return;
+    const sameBinding = (name) => name.text === local && sourceSymbolAt(this.context, name, source) === symbol;
+    for (const statement of source.statements) {
+      if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier) || statement.moduleSpecifier.text !== "transone/request")
+        continue;
+      const clause = statement.importClause;
+      const bindings = clause?.namedBindings;
+      let exported;
+      if (clause?.name && sameBinding(clause.name))
+        exported = "default";
+      if (bindings && ts.isNamedImports(bindings))
+        exported = bindings.elements.find((item) => sameBinding(item.name))?.propertyName?.text ?? (bindings.elements.some((item) => sameBinding(item.name)) ? local : exported);
+      if (bindings && ts.isNamespaceImport(bindings) && sameBinding(bindings.name))
+        exported = member ?? "*";
+      if (!exported)
+        continue;
+      if (member && !(bindings && ts.isNamespaceImport(bindings) && sameBinding(bindings.name)))
+        return;
+      const runtime = ts.factory.createPropertyAccessExpression(ts.factory.createCallExpression(ts.factory.createIdentifier("getApp"), undefined, []), "__transoneRequest");
+      return exported === "*" ? runtime : ts.factory.createElementAccessExpression(runtime, ts.factory.createStringLiteral(exported));
     }
+    return;
+  }
+  link(declaration) {
+    const { ts } = this.context;
+    const source = declaration.getSourceFile();
+    if (source.isDeclarationFile)
+      return;
+    const topVariable = ts.isVariableDeclaration(declaration) && ts.isVariableDeclarationList(declaration.parent) && ts.isVariableStatement(declaration.parent.parent) && ts.isSourceFile(declaration.parent.parent.parent);
+    const topFunction = ts.isFunctionDeclaration(declaration) && ts.isSourceFile(declaration.parent);
+    const topClass = ts.isClassDeclaration(declaration) && ts.isSourceFile(declaration.parent);
+    if (!topVariable && !topFunction && !topClass)
+      return;
+    if (topClass) {
+      const ref = this.context.index?.findClass(source.fileName, declaration.name?.text ?? "default");
+      if (ref && this.context.index.isComponent(ref))
+        return;
+    }
+    const existing = this.names.get(declaration);
+    if (existing)
+      return existing;
+    const name = `__mp_module_${this.names.size}`;
+    this.names.set(declaration, name);
+    const entries = this.entries.get(source) ?? new Map;
+    this.entries.set(source, entries);
+    const transformed = this.rewrite(declaration, source);
+    let statement = transformed;
+    if (ts.isVariableDeclaration(transformed))
+      statement = ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([transformed], ts.isVariableDeclarationList(declaration.parent) ? declaration.parent.flags : ts.NodeFlags.Const));
+    entries.set(declaration, statement);
+    return name;
   }
-  return consts;
 }
 
 // src/mp/methods.ts
@@ -2131,13 +2764,26 @@ var COMPONENT_LIFECYCLE = {
   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 methods = new Map(ownedMethods(context, classSource).map((item) => [
+    item.declaration.name.getText(item.owner.source),
+    item
+  ]));
+  const linker = context.index ? new MethodModuleLinker(context) : undefined;
+  const parentAliases = new Map;
+  const resolveSuper = (owner, name) => {
+    const parent = parentSource(context, owner);
+    const owned = parent && ownedMethod(context, parent, name);
+    if (!owned)
+      throw mpError(owner.filePath, `\u4E0D\u652F\u6301 super.${name}(): \u672A\u627E\u5230\u7236\u4E1A\u52A1\u65B9\u6CD5`);
+    const identity = `${owned.owner.filePath}:${owned.declaration.pos}`;
+    const existing = parentAliases.get(identity);
+    if (existing)
+      return existing;
+    const alias = `__mp_super_${parentAliases.size}_${name}`;
+    parentAliases.set(identity, alias);
+    methods.set(alias, owned);
+    return alias;
+  };
   const lifecycleMap = kind === "page" ? PAGE_LIFECYCLE : COMPONENT_LIFECYCLE;
   const seed = new Set(usedNames);
   for (const hook of Object.keys(lifecycleMap)) {
@@ -2159,8 +2805,8 @@ function compileMethods(context, classSource, usedNames, kind, customEvents) {
       continue;
     }
     visited.add(name);
-    const declaration = methods.get(name);
-    if (!declaration) {
+    const owned = methods.get(name);
+    if (!owned) {
       throw mpError(classSource.filePath, `\u672A\u627E\u5230\u4E8B\u4EF6\u5904\u7406\u65B9\u6CD5 "${name}"`);
     }
     const lifecycleKey = lifecycleMap[name];
@@ -2169,16 +2815,20 @@ function compileMethods(context, classSource, usedNames, kind, customEvents) {
       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);
+    const fn = compileMethod(context, owned.owner, owned.declaration, kind, customEvents, queue, resolveSuper, linker);
     if (lifecycleKey) {
       lifecycleEntries.push({ key, fn });
     } else {
       entries.push({ key, fn });
     }
   }
-  return { methods: entries, lifecycle: lifecycleEntries };
+  return {
+    methods: entries,
+    lifecycle: lifecycleEntries,
+    inlineModules: linker?.modules()
+  };
 }
-function compileMethod(context, classSource, declaration, kind, customEvents, referencedMethods) {
+function compileMethod(context, classSource, declaration, kind, customEvents, referencedMethods, resolveSuper, linker) {
   const { ts } = context;
   if (!declaration.body) {
     throw mpError(classSource.filePath, `\u65B9\u6CD5 ${declaration.name.getText()} \u7F3A\u5C11\u65B9\u6CD5\u4F53`);
@@ -2195,16 +2845,20 @@ function compileMethod(context, classSource, declaration, kind, customEvents, re
       customEvents,
       consts,
       locals,
-      referencedMethods
+      referencedMethods,
+      resolveSuper
     });
   };
   const result = ts.transform(functionExpression, [transformerFactory]);
-  const transformed = result.transformed[0];
+  const transformed = linker ? linker.rewrite(result.transformed[0], classSource.source) : 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 },
+    compilerOptions: {
+      target: ts.ScriptTarget.ESNext,
+      module: ts.ModuleKind.None
+    },
     reportDiagnostics: false
   });
   return transpiled.outputText.trim();
@@ -2221,6 +2875,14 @@ function visit(context, classSource, node, state) {
   if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name)) {
     state.locals.add(node.name.text);
   }
+  if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.expression.kind === ts.SyntaxKind.SuperKeyword) {
+    const alias = state.resolveSuper(classSource, node.expression.name.text);
+    state.referencedMethods.push(alias);
+    const call = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createThis(), alias), undefined, node.arguments);
+    return ts.visitEachChild(call, (child) => visit(context, classSource, child, state), state.transformContext);
+  }
+  if (node.kind === ts.SyntaxKind.SuperKeyword)
+    throw mpError(classSource.filePath, "\u4E0D\u652F\u6301\u7684 super \u8868\u8FBE\u5F0F\uFF1A\u4EC5\u652F\u6301\u7236\u4E1A\u52A1\u65B9\u6CD5\u8C03\u7528");
   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({ ... })");
@@ -2268,7 +2930,12 @@ function visit(context, classSource, node, state) {
       return ts.factory.createPropertyAccessExpression(ts.factory.createThis(), "properties");
     }
   }
-  if (ts.isIdentifier(node) && !state.locals.has(node.text) && state.consts.has(node.text)) {
+  if (ts.isShorthandPropertyAssignment(node) && !state.locals.has(node.name.text) && state.consts.has(node.name.text)) {
+    const value = foldExpression(ts, state.consts.get(node.name.text), state.consts);
+    if (value !== undefined && !(context.index && value !== null && typeof value === "object"))
+      return ts.factory.createPropertyAssignment(node.name.text, valueToNode(ts, value));
+  }
+  if (ts.isIdentifier(node) && isValueReference(ts, node) && !state.locals.has(node.text) && state.consts.has(node.text)) {
     const initializer = state.consts.get(node.text);
     if (ts.isCallExpression(initializer) && ts.isIdentifier(initializer.expression)) {
       const factoryName = initializer.expression.text;
@@ -2278,12 +2945,24 @@ function visit(context, classSource, node, state) {
     }
     const folded = foldExpression(ts, state.consts.get(node.text), state.consts);
     if (folded === undefined) {
+      if (context.index)
+        return node;
       throw mpError(classSource.filePath, `\u65B9\u6CD5\u4E2D\u5F15\u7528\u4E86\u65E0\u6CD5\u9759\u6001\u6C42\u503C\u7684\u6A21\u5757\u5E38\u91CF "${node.text}"`);
     }
+    if (context.index && folded !== null && typeof folded === "object")
+      return node;
     return valueToNode(ts, folded);
   }
   return ts.visitEachChild(node, (child) => visit(context, classSource, child, state), state.transformContext);
 }
+function isValueReference(ts, node) {
+  const parent = node.parent;
+  if (!parent)
+    return true;
+  if ((ts.isPropertyAccessExpression(parent) || ts.isPropertyAssignment(parent) || ts.isVariableDeclaration(parent) || ts.isParameter(parent) || ts.isMethodDeclaration(parent) || ts.isFunctionDeclaration(parent) || ts.isBindingElement(parent)) && parent.name === node)
+    return false;
+  return !ts.isShorthandPropertyAssignment(parent);
+}
 var BRIDGE_METHODS = new Set(["emit", "setState", "setData", "triggerEvent"]);
 function buildStateAssignment(ts, node, filePath) {
   const path = statePath(ts, node.left);
@@ -2360,9 +3039,6 @@ function compoundOperatorText(ts, kind) {
 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);
 }
@@ -2385,145 +3061,7 @@ function valueToNode(ts, value) {
   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 = [];
-  const requestImports = [];
-  for (const statement of source.statements) {
-    if (ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier) && statement.moduleSpecifier.text === "transone/request" && !statement.importClause?.isTypeOnly) {
-      const clause = statement.importClause;
-      if (clause?.name)
-        requestImports.push(`const ${clause.name.text} = getApp().__transoneRequest.default;`);
-      const bindings = clause?.namedBindings;
-      if (bindings && ts.isNamespaceImport(bindings)) {
-        requestImports.push(`const ${bindings.name.text} = getApp().__transoneRequest;`);
-      } else if (bindings && ts.isNamedImports(bindings)) {
-        for (const item of bindings.elements) {
-          if (!item.isTypeOnly)
-            requestImports.push(`const ${item.name.text} = getApp().__transoneRequest[${JSON.stringify(item.propertyName?.text ?? item.name.text)}];`);
-        }
-      }
-    }
-    if (ts.isImportDeclaration(statement) || ts.isExportDeclaration(statement) || ts.isExportAssignment(statement) || ts.isInterfaceDeclaration(statement) || ts.isTypeAliasDeclaration(statement)) {
-      continue;
-    }
-    if (ts.isClassDeclaration(statement) && statement.heritageClauses?.some((clause) => clause.types.some((type) => ts.isIdentifier(type.expression) && (type.expression.text === "Component" || type.expression.text.endsWith("Component")))))
-      continue;
-    if (ts.isVariableStatement(statement)) {
-      const declarations = statement.declarationList.declarations.filter((declaration) => !(declaration.initializer && ts.isCallExpression(declaration.initializer) && ts.isIdentifier(declaration.initializer.expression) && declaration.initializer.expression.text === "createApp"));
-      if (declarations.length === 0)
-        continue;
-      kept.push(ts.factory.updateVariableStatement(statement, statement.modifiers, ts.factory.updateVariableDeclarationList(statement.declarationList, declarations)));
-      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 [...requestImports, transpiled.outputText.replace(/^export\s+/gm, "").trim()].join(`
-`);
+  return moduleConstants(context, classSource);
 }
 
 // src/mp/compile.ts
@@ -2548,7 +3086,7 @@ function compileUnit(context, classSource, options) {
       usedNames.add(emitter.method);
     }
     const customEvents = new Set;
-    const inlineModules = collectInlineModules(context, classSource);
+    const legacyModules = context.index ? undefined : collectInlineModules(context, classSource);
     const compiledMethods = compileMethods(context, classSource, usedNames, kind, customEvents);
     const methods = [...compiledMethods.methods];
     for (const emitter of builder.emitters) {
@@ -2574,7 +3112,7 @@ function compileUnit(context, classSource, options) {
       lifecycle: compiledMethods.lifecycle,
       customEvents: [...customEvents],
       usingComponents,
-      inlineModules
+      inlineModules: compiledMethods.inlineModules ?? legacyModules ?? []
     };
     if (kind === "component") {
       context.components.set(name, unit);
@@ -2693,6 +3231,12 @@ async function buildMiniProgram(config, dialect) {
   const ts = await loadTypescript();
   const context = {
     ts,
+    index: createComponentIndex({
+      root: config.root,
+      entrypoints: Object.values(mp.pages),
+      platform: config.platform,
+      ...config.components
+    }),
     root: config.root,
     files: new Map,
     components: new Map,
@@ -2716,13 +3260,22 @@ async function buildMiniProgram(config, dialect) {
   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 });
+  return withBuildOutput({
+    root: config.root,
+    outDir: mp.outDir,
+    protectedPaths: buildInputPaths(config, Object.values(mp.pages), [
+      mp.publicDir,
+      ...context.index.sources.map((source) => source.fileName),
+      ...context.files.keys()
+    ])
+  }, (outDir) => writeMiniProgram(config, dialect, outDir, pages, context));
+}
+async function writeMiniProgram(config, dialect, outDir, pages, context) {
+  const mp = config.mp;
   const assetsBuilt = [];
   const write = async (path, content) => {
-    const target = join3(outDir, path);
-    await mkdir(dirname3(target), { recursive: true });
+    const target = buildOutputPath(outDir, path);
+    await mkdir(dirname4(target), { recursive: true });
     await writeFile(target, content, "utf8");
     assetsBuilt.push(target);
   };
@@ -2790,11 +3343,11 @@ async function buildMiniProgram(config, dialect) {
     await write(`components/${tag}/${tag}.json`, `${JSON.stringify(dialect.componentJson(unit.usingComponents), null, 2)}
 `);
   }
-  if (existsSync2(mp.publicDir)) {
+  if (existsSync3(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, {
+      const target = buildOutputPath(outDir, file);
+      if (!existsSync3(target)) {
+        await cp(join4(mp.publicDir, file), target, {
           recursive: true,
           force: true,
           errorOnExist: false
@@ -2804,7 +3357,7 @@ async function buildMiniProgram(config, dialect) {
   }
   return {
     root: config.root,
-    outDir: resolve2(outDir),
+    outDir: resolve3(outDir),
     assetsBuilt
   };
 }
@@ -2829,7 +3382,7 @@ 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);
+    const abs = join4(dir, entry.name);
     if (entry.isDirectory()) {
       out.push(...await listFiles(root, abs));
     } else {
@@ -2842,5 +3395,5 @@ export {
   buildMiniProgram
 };
 
-//# debugId=AE3147F44337807364756E2164756E21
-//# sourceMappingURL=build-mp-vk5ap2cw.js.map
+//# debugId=2351C11ACC1AB08664756E2164756E21
+//# sourceMappingURL=build-mp-y5pwahsy.js.map