@astralsight/astroforge-rsbuild-plugin 0.0.1

package/dist/index.mjs

@@ -0,0 +1,1538 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { dirname, extname, join, relative, resolve, sep } from "node:path";
+import { createHash } from "node:crypto";
+import { unsupportedCapabilities } from "@astralsight/astroforge-core/platform";
+import { parse } from "@babel/parser";
+//#region src/assets.ts
+function collectAssets(root, document) {
+	const assets = /* @__PURE__ */ new Map();
+	addAsset(root, document.manifest.icon, assets);
+	for (const page of Object.values(document.pages)) collectPageAssets(root, page, assets);
+	for (const component of Object.values(document.components)) collectComponentAssets(root, component, assets);
+	return [...assets.values()];
+}
+function collectPageAssets(root, page, assets) {
+	collectNodeAssets(root, page.template, assets);
+	collectStyleAssets(root, page.style, assets);
+}
+function collectComponentAssets(root, component, assets) {
+	collectNodeAssets(root, component.template, assets);
+	collectStyleAssets(root, component.style, assets);
+}
+function collectStyleAssets(root, style, assets) {
+	for (const rule of style.rules) for (const value of Object.values(rule.declarations)) for (const path of extractCssUrls(value)) addAsset(root, path, assets);
+}
+function extractCssUrls(value) {
+	const urls = [];
+	const pattern = /url\(\s*(?:"([^"]+)"|'([^']+)'|([^'")\s]+))\s*\)/g;
+	let match;
+	while (match = pattern.exec(value)) urls.push(match[1] ?? match[2] ?? match[3]);
+	return urls;
+}
+function collectNodeAssets(root, nodes, assets) {
+	for (const node of nodes) switch (node.kind) {
+		case "element":
+			if (node.value.tag === "image") {
+				const src = node.value.attrs.src;
+				if (src?.kind === "static" && typeof src.value === "string") addAsset(root, src.value, assets);
+			}
+			collectNodeAssets(root, node.value.children, assets);
+			break;
+		case "conditional":
+			for (const branch of node.value.branches) collectNodeAssets(root, branch.body, assets);
+			break;
+		case "list":
+			collectNodeAssets(root, node.value.body, assets);
+			break;
+		case "fragment":
+			collectNodeAssets(root, node.value, assets);
+			break;
+	}
+}
+function addAsset(root, path, assets) {
+	if (!path.startsWith("/") || assets.has(path)) return;
+	const sourcePath = resolve(root, "src", path.slice(1));
+	if (!existsSync(sourcePath)) return;
+	const bytes = readFileSync(sourcePath);
+	assets.set(path, {
+		path,
+		source_path: sourcePath,
+		digest: createHash("sha1").update(bytes).digest("hex")
+	});
+}
+//#endregion
+//#region src/capabilities.ts
+function validatePlatformCapabilities(document, platform) {
+	const apiLevel = document.manifest.min_platform_version;
+	const declared = /* @__PURE__ */ new Map();
+	for (const feature of document.manifest.features) declared.set(`feature:${feature.name}`, {
+		kind: "feature",
+		name: feature.name
+	});
+	for (const tag of collectRenderableTags(document)) declared.set(`component:${tag}`, {
+		kind: "component",
+		name: tag
+	});
+	const issues = unsupportedCapabilities(declared.values(), platform, apiLevel);
+	if (issues.length === 0) return;
+	throw new Error(platformCapabilityMessage(issues));
+}
+function collectRenderableTags(document) {
+	const out = /* @__PURE__ */ new Set();
+	for (const page of Object.values(document.pages)) collectTagsFromNodes(page.template, out);
+	for (const component of Object.values(document.components)) collectTagsFromNodes(component.template, out);
+	return out;
+}
+function collectTagsFromNodes(nodes, out) {
+	for (const node of nodes) switch (node.kind) {
+		case "element":
+			if (!node.value.is_component) out.add(node.value.tag);
+			collectTagsFromNodes(node.value.children, out);
+			break;
+		case "conditional":
+			for (const branch of node.value.branches) collectTagsFromNodes(branch.body, out);
+			break;
+		case "list":
+			collectTagsFromNodes(node.value.body, out);
+			break;
+		case "fragment":
+			collectTagsFromNodes(node.value, out);
+			break;
+	}
+}
+function platformCapabilityMessage(issues) {
+	return [
+		"AstroForge 平台能力校验失败。",
+		"请移除这些使用，或为目标平台增加后端支持 / 条件编译分支：",
+		...issues.map((issue) => {
+			const label = issue.kind === "feature" ? "接口" : "组件";
+			if (issue.reason === "api-level") return `- ${label} ${issue.name}: 当前 minPlatformVersion 低于 ${issue.required}`;
+			return `- ${label} ${issue.name}: 当前目标平台 ${issue.platform} 未声明支持`;
+		})
+	].join("\n");
+}
+//#endregion
+//#region src/config.ts
+function readAstroForgeConfig(root, configFile = "astroforge.config.ts") {
+	const path = resolve(root, configFile);
+	return parseAstroForgeConfig(readFileSync(path, "utf8"), path);
+}
+function parseAstroForgeConfig(source, filename = "astroforge.config.ts") {
+	const ast = parse(source, {
+		sourceType: "module",
+		plugins: ["typescript"]
+	});
+	for (const statement of ast.program.body) {
+		if (statement.type !== "ExportDefaultDeclaration") continue;
+		const declaration = unwrapTsExpression(statement.declaration);
+		if (declaration.type !== "ObjectExpression") throw new Error(`${filename}: default export 必须是对象字面量`);
+		const config = valueFromExpression(declaration);
+		assertProjectConfig(config, filename);
+		return config;
+	}
+	throw new Error(`${filename}: 未找到 default export`);
+}
+function assertProjectConfig(value, filename) {
+	if (!isRecord(value) || !isRecord(value.manifest)) throw new Error(`${filename}: 缺少 manifest 对象`);
+	const manifest = value.manifest;
+	assertString(manifest.package, filename, "manifest.package");
+	assertString(manifest.name, filename, "manifest.name");
+	assertString(manifest.versionName, filename, "manifest.versionName");
+	assertNumber(manifest.versionCode, filename, "manifest.versionCode");
+	assertNumber(manifest.minPlatformVersion, filename, "manifest.minPlatformVersion");
+	assertString(manifest.icon, filename, "manifest.icon");
+	if (!Array.isArray(manifest.deviceTypeList)) throw new Error(`${filename}: manifest.deviceTypeList 必须是字符串数组`);
+	for (const value of manifest.deviceTypeList) if (typeof value !== "string") throw new Error(`${filename}: manifest.deviceTypeList 必须是字符串数组`);
+}
+function valueFromExpression(node) {
+	const expression = unwrapTsExpression(node);
+	switch (expression.type) {
+		case "StringLiteral": return expression.value;
+		case "NumericLiteral": return expression.value;
+		case "BooleanLiteral": return expression.value;
+		case "NullLiteral": return null;
+		case "UnaryExpression": {
+			const argument = unwrapTsExpression(expression.argument);
+			if (expression.operator === "-" && argument.type === "NumericLiteral") return -argument.value;
+			break;
+		}
+		case "ArrayExpression": return expression.elements.map((element) => {
+			if (!element) return null;
+			if (element.type === "SpreadElement") throw new Error("配置数组暂不支持展开语法");
+			return valueFromExpression(element);
+		});
+		case "ObjectExpression": {
+			const out = {};
+			for (const property of expression.properties) {
+				if (property.type === "SpreadElement") throw new Error("配置对象暂不支持展开语法");
+				if (property.type !== "ObjectProperty") throw new Error("配置对象暂不支持访问器或方法");
+				const key = propertyKey(property.key);
+				out[key] = valueFromExpression(property.value);
+			}
+			return out;
+		}
+	}
+	throw new Error(`配置项仅支持可序列化字面量，收到 ${expression.type}`);
+}
+function propertyKey(node) {
+	switch (node.type) {
+		case "Identifier": return node.name;
+		case "StringLiteral":
+		case "NumericLiteral": return String(node.value);
+		default: throw new Error(`不支持的配置键类型：${node.type}`);
+	}
+}
+function unwrapTsExpression(node) {
+	let current = node;
+	while (current.type === "TSAsExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSTypeAssertion" || current.type === "TSNonNullExpression" || current.type === "ParenthesizedExpression") current = current.expression;
+	return current;
+}
+function assertString(value, filename, key) {
+	if (typeof value !== "string") throw new Error(`${filename}: ${key} 必须是字符串`);
+}
+function assertNumber(value, filename, key) {
+	if (typeof value !== "number") throw new Error(`${filename}: ${key} 必须是数字`);
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/ir.ts
+function createEmptyScript() {
+	return {
+		props: {},
+		private_data: {},
+		methods: {},
+		lifecycle: {}
+	};
+}
+function createEmptyStyleTable() {
+	return { rules: [] };
+}
+//#endregion
+//#region src/style.ts
+function parseStyleTable(source) {
+	const rules = [];
+	const css = stripComments(source);
+	const pattern = /([^{}]+)\{([^{}]*)\}/g;
+	let match;
+	while (match = pattern.exec(css)) {
+		const selectorSource = match[1].trim();
+		const body = match[2].trim();
+		if (!selectorSource || !body) continue;
+		rules.push({
+			selectors: selectorSource.split(",").map((selector) => parseSelector(selector.trim())),
+			declarations: parseDeclarations(body)
+		});
+	}
+	return { rules };
+}
+function stripComments(source) {
+	return source.replace(/\/\*[\s\S]*?\*\//g, "");
+}
+function parseSelector(selector) {
+	if (selector === "@font-face") return {
+		kind: "font_face",
+		name: "font-face"
+	};
+	if (selector.startsWith("@keyframes ")) return {
+		kind: "keyframes",
+		name: selector.slice(11).trim()
+	};
+	if (selector.startsWith(".")) return {
+		kind: "class",
+		name: selector.slice(1)
+	};
+	if (selector.startsWith("#")) return {
+		kind: "id",
+		name: selector.slice(1)
+	};
+	return {
+		kind: selectorKindForTag(selector),
+		name: selector
+	};
+}
+function selectorKindForTag(_selector) {
+	return "tag";
+}
+function parseDeclarations(body) {
+	const declarations = {};
+	for (const item of body.split(";")) {
+		const declaration = item.trim();
+		if (!declaration) continue;
+		const colon = declaration.indexOf(":");
+		if (colon === -1) continue;
+		const key = declaration.slice(0, colon).trim();
+		const value = declaration.slice(colon + 1).trim();
+		if (key && value) declarations[key] = value;
+	}
+	return declarations;
+}
+//#endregion
+//#region src/tsx.ts
+const BUILTIN_COMPONENTS = new Map([
+	["A", "a"],
+	["Barcode", "barcode"],
+	["Canvas", "canvas"],
+	["Chart", "chart"],
+	["View", "div"],
+	["Div", "div"],
+	["Text", "text"],
+	["Image", "image"],
+	["ImageAnimator", "image-animator"],
+	["Input", "input"],
+	["Label", "label"],
+	["List", "list"],
+	["ListItem", "list-item"],
+	["Marquee", "marquee"],
+	["Media", "media"],
+	["Option", "option"],
+	["Picker", "picker"],
+	["Popup", "popup"],
+	["Progress", "progress"],
+	["Prompt", "prompt"],
+	["QR", "qr"],
+	["Qr", "qr"],
+	["Rating", "rating"],
+	["Refresh", "refresh"],
+	["RefreshFooter", "refresh-footer"],
+	["RefreshHeader", "refresh-header"],
+	["RichText", "richtext"],
+	["Screen", "screen"],
+	["Scroll", "scroll"],
+	["Select", "select"],
+	["Slider", "slider"],
+	["Span", "span"],
+	["Stack", "stack"],
+	["Swiper", "swiper"],
+	["Switch", "switch"],
+	["TabContent", "tab-content"],
+	["TabBar", "tabbar"],
+	["Tabs", "tabs"],
+	["Textarea", "textarea"],
+	["Video", "video"]
+]);
+function extractPageFromTsx(source, options) {
+	return extractPageModuleFromTsx(source, options).page;
+}
+function extractPageModuleFromTsx(source, options) {
+	const ast = parse(source, {
+		sourceType: "module",
+		plugins: ["typescript", "jsx"]
+	});
+	const bindings = collectAstroForgeImports(ast.program.body);
+	const pageFunction = findDefaultPageFunction(ast.program.body, options.filename);
+	const script = extractScript(source, ast.program.body, pageFunction.node, options.filename);
+	const template = templateFromRenderExpression(pageFunction.renderExpression, bindings, options.filename);
+	const components = extractLocalComponents(source, ast.program.body, pageFunction.node, bindings, options.filename);
+	const componentImports = collectComponentImports(ast.program.body, bindings, Object.keys(components));
+	const imports = importsFromTemplate(template, components);
+	return {
+		page: {
+			route: options.route,
+			imports,
+			template,
+			script,
+			style: extractStyleTable(source, ast.program.body, options.filename, options.loadStyle)
+		},
+		components,
+		componentImports
+	};
+}
+function extractComponentFromTsx(source, options) {
+	const ast = parse(source, {
+		sourceType: "module",
+		plugins: ["typescript", "jsx"]
+	});
+	const bindings = collectAstroForgeImports(ast.program.body);
+	const located = locateComponentFunction(ast.program.body, options.exportName, options.filename);
+	const template = templateFromRenderExpression(located.renderExpression, bindings, options.filename);
+	const componentImports = collectComponentImports(ast.program.body, bindings, []);
+	return {
+		component: {
+			name: kebabCase(located.localName),
+			template,
+			script: {
+				...createEmptyScript(),
+				props: extractComponentProps(located.node, ast.program.body, options.filename)
+			},
+			style: extractStyleTable(source, ast.program.body, options.filename, options.loadStyle)
+		},
+		componentImports
+	};
+}
+function locateComponentFunction(body, exportName, filename) {
+	if (!exportName) {
+		const page = findDefaultPageFunction(body, filename);
+		return {
+			localName: page.node.id?.name ?? defaultExportName(body) ?? "Component",
+			node: page.node,
+			renderExpression: page.renderExpression
+		};
+	}
+	for (const statement of body) {
+		if (statement.type !== "ExportNamedDeclaration" || !statement.declaration) continue;
+		if (statement.declaration.type === "FunctionDeclaration" && statement.declaration.id?.name === exportName) return {
+			localName: exportName,
+			node: statement.declaration,
+			renderExpression: renderExpressionFromFunction(statement.declaration, filename)
+		};
+		if (statement.declaration.type === "VariableDeclaration") {
+			for (const declarator of statement.declaration.declarations) if (declarator.id.type === "Identifier" && declarator.id.name === exportName && declarator.init && isFunctionLike(unwrapExpression(declarator.init))) return {
+				localName: exportName,
+				node: unwrapExpression(declarator.init),
+				renderExpression: renderExpressionFromFunction(unwrapExpression(declarator.init), filename)
+			};
+		}
+	}
+	for (const statement of body) if (statement.type === "ExportNamedDeclaration" && !statement.declaration && statement.specifiers.some((s) => s.exported?.name === exportName)) {
+		const local = findTopLevelBinding(body, exportName);
+		if (local && isFunctionLike(local)) return {
+			localName: exportName,
+			node: local,
+			renderExpression: renderExpressionFromFunction(local, filename)
+		};
+	}
+	throw new Error(`${filename ?? "TSX"}: 未找到名为 ${exportName} 的命名导出函数`);
+}
+function defaultExportName(body) {
+	for (const statement of body) {
+		if (statement.type !== "ExportDefaultDeclaration") continue;
+		const declaration = unwrapExpression(statement.declaration);
+		if (declaration.type === "FunctionDeclaration" && declaration.id?.name) return declaration.id.name;
+		if (declaration.type === "Identifier") return declaration.name;
+	}
+}
+function collectComponentImports(body, builtinBindings, localComponentNames) {
+	const localTagSet = new Set(localComponentNames);
+	const out = [];
+	for (const statement of body) {
+		if (statement.type !== "ImportDeclaration") continue;
+		const source = statement.source.value;
+		if (typeof source !== "string") continue;
+		if (!source.startsWith("./") && !source.startsWith("../")) continue;
+		for (const specifier of statement.specifiers) {
+			const localName = specifier.type === "ImportDefaultSpecifier" ? specifier.local.name : specifier.type === "ImportSpecifier" ? specifier.local.name : void 0;
+			if (!localName || !isPascalCase(localName)) continue;
+			if (builtinBindings.has(localName)) continue;
+			const tag = kebabCase(localName);
+			if (localTagSet.has(tag)) continue;
+			const exportName = specifier.type === "ImportSpecifier" ? specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value : void 0;
+			out.push({
+				localName,
+				tag,
+				from: source,
+				exportName
+			});
+		}
+	}
+	return out;
+}
+function extractAppFromTsx(source, filename) {
+	const ast = parse(source, {
+		sourceType: "module",
+		plugins: ["typescript", "jsx"]
+	});
+	const context = createScriptContext(source, filename);
+	const lifecycle = {};
+	for (const statement of ast.program.body) {
+		if (statement.type !== "ExportDefaultDeclaration") continue;
+		const declaration = unwrapExpression(statement.declaration);
+		if (declaration.type !== "ObjectExpression") throw new Error(`${filename ?? "app.tsx"}: app default export 必须是对象字面量`);
+		collectLifecycleObject(lifecycle, context, declaration, "body");
+		return { lifecycle };
+	}
+	return { lifecycle };
+}
+function collectAstroForgeImports(body) {
+	const bindings = /* @__PURE__ */ new Map();
+	for (const statement of body) {
+		if (statement.type !== "ImportDeclaration" || !["@astralsight/astroforge-core", "@astralsight/astroforge-core/components"].includes(statement.source.value)) continue;
+		for (const specifier of statement.specifiers) {
+			if (specifier.type !== "ImportSpecifier") continue;
+			const imported = specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value;
+			const tag = BUILTIN_COMPONENTS.get(imported);
+			if (tag) bindings.set(specifier.local.name, tag);
+		}
+	}
+	return bindings;
+}
+function extractLocalComponents(source, body, pageFunction, bindings, filename) {
+	const components = {};
+	for (const statement of body) {
+		const candidate = componentCandidate(statement);
+		if (!candidate || candidate.node === pageFunction || !isPascalCase(candidate.name)) continue;
+		const fn = unwrapExpression(candidate.node);
+		if (!isFunctionLike(fn)) continue;
+		const name = kebabCase(candidate.name);
+		components[name] = {
+			name,
+			template: templateFromRenderExpression(renderExpressionFromFunction(fn, filename), bindings, filename),
+			script: {
+				...createEmptyScript(),
+				props: extractComponentProps(fn, body, filename)
+			},
+			style: createEmptyStyleTable()
+		};
+	}
+	return components;
+}
+function componentCandidate(statement) {
+	if (statement.type === "FunctionDeclaration" && statement.id?.name) return {
+		name: statement.id.name,
+		node: statement
+	};
+	if (statement.type !== "VariableDeclaration") return;
+	for (const declarator of statement.declarations) if (declarator.id.type === "Identifier" && declarator.init) return {
+		name: declarator.id.name,
+		node: unwrapExpression(declarator.init)
+	};
+}
+function extractComponentProps(fn, moduleBody, filename) {
+	const first = fn.params?.[0];
+	if (!first) return {};
+	const node = unwrapExpression(first);
+	const typeNode = propTypeNode(node);
+	const props = typeNode ? propsFromTypeNode(typeNode, moduleBody, filename) : {};
+	if (node.type === "ObjectPattern") for (const property of node.properties) {
+		if (property.type !== "ObjectProperty") continue;
+		if (property.computed) continue;
+		const key = objectPropertyKey(property.key, filename);
+		const value = unwrapExpression(property.value);
+		if (value.type === "AssignmentPattern") {
+			const fallback = staticAttrLiteral(value.right);
+			if (fallback !== void 0) props[key] = {
+				type: props[key]?.type ?? propTypeFromDefault(fallback),
+				default: fallback
+			};
+		} else if (!props[key]) props[key] = { type: "Object" };
+	}
+	return props;
+}
+function propTypeNode(param) {
+	if (param.type === "Identifier" || param.type === "ObjectPattern") return param.typeAnnotation?.typeAnnotation;
+	if (param.type === "AssignmentPattern") return propTypeNode(unwrapExpression(param.left));
+}
+function propsFromTypeNode(typeNode, moduleBody, filename) {
+	const node = unwrapExpression(typeNode);
+	if (node.type === "TSTypeLiteral") return propsFromTypeLiteral(node, moduleBody, filename);
+	if (node.type === "TSTypeReference" && node.typeName.type === "Identifier") {
+		const resolved = findTypeBinding(moduleBody, node.typeName.name);
+		if (!resolved) return {};
+		return propsFromTypeNode(resolved, moduleBody, filename);
+	}
+	if (node.type === "TSInterfaceDeclaration") return propsFromTypeLiteral(node.body, moduleBody, filename);
+	if (node.type === "TSTypeAliasDeclaration") return propsFromTypeNode(node.typeAnnotation, moduleBody, filename);
+	return {};
+}
+function propsFromTypeLiteral(node, moduleBody, filename) {
+	const out = {};
+	for (const member of node.members ?? node.body ?? []) {
+		if (member.type !== "TSPropertySignature") continue;
+		const key = objectPropertyKey(member.key, filename);
+		const valueType = member.typeAnnotation?.typeAnnotation;
+		out[key] = { type: valueType ? propRuntimeType(valueType, moduleBody, filename) : "Object" };
+	}
+	return out;
+}
+function findTypeBinding(moduleBody, name) {
+	for (const statement of moduleBody) {
+		const node = statement.type === "ExportNamedDeclaration" && statement.declaration ? statement.declaration : statement;
+		if ((node.type === "TSInterfaceDeclaration" || node.type === "TSTypeAliasDeclaration") && node.id?.name === name) return node;
+	}
+}
+function propRuntimeType(typeNode, moduleBody, filename) {
+	const node = unwrapExpression(typeNode);
+	switch (node.type) {
+		case "TSStringKeyword": return "String";
+		case "TSNumberKeyword": return "Number";
+		case "TSBooleanKeyword": return "Boolean";
+		case "TSArrayType":
+		case "TSTupleType": return "Array";
+		case "TSFunctionType": return "Function";
+		case "TSTypeLiteral": return "Object";
+		case "TSTypeReference": {
+			if (node.typeName.type !== "Identifier") return "Object";
+			const name = node.typeName.name;
+			if (["Array", "ReadonlyArray"].includes(name)) return "Array";
+			if (["Function"].includes(name)) return "Function";
+			const resolved = findTypeBinding(moduleBody, name);
+			if (!resolved) return "Object";
+			return propRuntimeType(resolved, moduleBody, filename);
+		}
+		case "TSInterfaceDeclaration": return "Object";
+		case "TSTypeAliasDeclaration": return propRuntimeType(node.typeAnnotation, moduleBody, filename);
+		case "TSUnionType": return propRuntimeTypeFromUnion(node.types, moduleBody, filename);
+		default: return "Object";
+	}
+}
+function propRuntimeTypeFromUnion(types, moduleBody, filename) {
+	const concrete = types.filter((item) => ![
+		"TSNullKeyword",
+		"TSUndefinedKeyword",
+		"TSVoidKeyword"
+	].includes(unwrapExpression(item).type));
+	const mapped = new Set(concrete.map((item) => propRuntimeType(item, moduleBody, filename)));
+	return mapped.size === 1 ? [...mapped][0] : "Object";
+}
+function propTypeFromDefault(value) {
+	if (typeof value === "string") return "String";
+	if (typeof value === "number") return "Number";
+	if (typeof value === "boolean") return "Boolean";
+	if (Array.isArray(value)) return "Array";
+	return "Object";
+}
+function importsFromTemplate(template, components) {
+	const imports = {};
+	collectTemplateImports(template, components, imports);
+	return imports;
+}
+function collectTemplateImports(nodes, components, imports) {
+	for (const node of nodes) switch (node.kind) {
+		case "element":
+			if (node.value.is_component && components[node.value.tag]) imports[node.value.tag] = node.value.tag;
+			collectTemplateImports(node.value.children, components, imports);
+			break;
+		case "conditional":
+			for (const branch of node.value.branches) collectTemplateImports(branch.body, components, imports);
+			break;
+		case "list":
+			collectTemplateImports(node.value.body, components, imports);
+			break;
+		case "fragment":
+			collectTemplateImports(node.value, components, imports);
+			break;
+	}
+}
+function extractStyleTable(source, body, filename, loadStyle) {
+	const chunks = [];
+	for (const statement of body) {
+		if (statement.type !== "ImportDeclaration") continue;
+		const specifier = statement.source.value;
+		if (typeof specifier !== "string" || !specifier.endsWith(".css")) continue;
+		const css = loadStyle?.(specifier, filename);
+		if (css === void 0) throw new Error(`${filename ?? "TSX"}: CSS import ${specifier} 无法解析`);
+		chunks.push(css);
+	}
+	for (const statement of body) {
+		if (statement.type !== "ExportNamedDeclaration" || statement.declaration?.type !== "VariableDeclaration") continue;
+		for (const declarator of statement.declaration.declarations) {
+			if (declarator.id.type !== "Identifier" || !["style", "styles"].includes(declarator.id.name) || !declarator.init) continue;
+			const init = unwrapExpression(declarator.init);
+			if (init.type === "StringLiteral") {
+				chunks.push(init.value);
+				continue;
+			}
+			if (init.type === "TemplateLiteral" && init.expressions.length === 0) {
+				chunks.push(init.quasis.map((quasi) => quasi.value.cooked).join(""));
+				continue;
+			}
+			throw new Error(`${filename ?? "TSX"}: styles 必须是静态字符串`);
+		}
+	}
+	if (chunks.length === 0) return createEmptyStyleTable();
+	return parseStyleTable(chunks.join("\n"));
+}
+function findDefaultPageFunction(body, filename) {
+	for (const statement of body) {
+		if (statement.type !== "ExportDefaultDeclaration") continue;
+		const declaration = unwrapExpression(statement.declaration);
+		if (isFunctionLike(declaration)) return {
+			node: declaration,
+			renderExpression: renderExpressionFromFunction(declaration, filename)
+		};
+		if (declaration.type === "Identifier") {
+			const binding = findTopLevelBinding(body, declaration.name);
+			if (binding && isFunctionLike(binding)) return {
+				node: binding,
+				renderExpression: renderExpressionFromFunction(binding, filename)
+			};
+		}
+		throw new Error(`${filename ?? "TSX"}: default export 必须是返回 JSX 的函数`);
+	}
+	throw new Error(`${filename ?? "TSX"}: 未找到 default export`);
+}
+function extractScript(source, moduleBody, pageFunction, filename) {
+	const script = createEmptyScript();
+	const body = unwrapExpression(pageFunction.body);
+	if (body.type !== "BlockStatement") return script;
+	const context = createScriptContext(source, filename);
+	for (const statement of body.body) collectUseStateDeclaration(script, context, statement);
+	for (const statement of body.body) collectMethod(script, context, statement);
+	collectPageLifecycle(script, context, moduleBody);
+	collectUseEffectCalls(script, context, body.body);
+	return script;
+}
+function createScriptContext(source, filename) {
+	return {
+		source,
+		filename,
+		stateVars: /* @__PURE__ */ new Set(),
+		stateSetters: /* @__PURE__ */ new Map()
+	};
+}
+function collectUseStateDeclaration(script, context, statement) {
+	if (statement.type !== "VariableDeclaration") return;
+	for (const declarator of statement.declarations) {
+		if (declarator.id.type !== "ArrayPattern" || declarator.id.elements.length < 2 || !declarator.init || !isUseStateCall(declarator.init)) continue;
+		const stateId = declarator.id.elements[0];
+		const setterId = declarator.id.elements[1];
+		if (stateId?.type !== "Identifier" || setterId?.type !== "Identifier") throw new Error(`${context.filename ?? "TSX"}: useState 解构必须形如 const [value, setValue] = useState(...)`);
+		const initial = declarator.init.arguments[0];
+		script.private_data[stateId.name] = initial ? staticJsonValue(initial, context.filename) : null;
+		context.stateVars.add(stateId.name);
+		context.stateSetters.set(setterId.name, stateId.name);
+	}
+}
+function collectMethod(script, context, statement) {
+	if (statement.type === "FunctionDeclaration") {
+		if (!statement.id?.name) return;
+		script.methods[statement.id.name] = lowerFunctionLike(context, statement, statement.id.name);
+		return;
+	}
+	if (statement.type !== "VariableDeclaration") return;
+	for (const declarator of statement.declarations) {
+		if (declarator.id.type !== "Identifier" || !declarator.init || !isFunctionLike(unwrapExpression(declarator.init))) continue;
+		script.methods[declarator.id.name] = lowerFunctionLike(context, unwrapExpression(declarator.init), declarator.id.name);
+	}
+}
+function collectUseEffectCalls(script, context, statements) {
+	for (const statement of statements) {
+		if (statement.type !== "ExpressionStatement" || !isUseEffectCall(statement.expression)) continue;
+		const call = unwrapExpression(statement.expression);
+		assertSupportedEffectDeps(call, context.filename);
+		const effect = effectBodies(context, call.arguments[0]);
+		if (effect.body) appendLifecycleBody(script.lifecycle, "onReady", effect.body);
+		if (effect.cleanup) appendLifecycleBody(script.lifecycle, "onDestroy", effect.cleanup);
+	}
+}
+function isUseEffectCall(node) {
+	const expression = unwrapExpression(node);
+	return expression.type === "CallExpression" && expression.callee.type === "Identifier" && expression.callee.name === "useEffect";
+}
+function assertSupportedEffectDeps(call, filename) {
+	const deps = call.arguments[1];
+	if (!deps) return;
+	const node = unwrapExpression(deps);
+	if (node.type === "ArrayExpression" && node.elements.length === 0) return;
+	throw new Error(`${filename ?? "TSX"}: useEffect 静态展开仅支持省略依赖或空依赖数组`);
+}
+function effectBodies(context, callback) {
+	const fn = unwrapExpression(callback);
+	if (!isFunctionLike(fn)) throw new Error(`${context.filename ?? "TSX"}: useEffect 参数必须是函数`);
+	const body = unwrapExpression(fn.body);
+	if (body.type !== "BlockStatement") return { body: `${lowerExpression(context, body)};` };
+	const statements = [];
+	let cleanup;
+	for (const statement of body.body) {
+		if (statement.type === "ReturnStatement") {
+			if (!statement.argument) continue;
+			const returned = unwrapExpression(statement.argument);
+			if (!isFunctionLike(returned)) throw new Error(`${context.filename ?? "TSX"}: useEffect cleanup 必须返回函数`);
+			cleanup = lowerFunctionBodySource(context, returned.body);
+			continue;
+		}
+		const lowered = lowerStatement(context, statement);
+		if (lowered) statements.push(lowered);
+	}
+	return {
+		body: statements.join("\n"),
+		cleanup
+	};
+}
+function collectPageLifecycle(script, context, moduleBody) {
+	for (const statement of moduleBody) {
+		if (statement.type !== "ExportNamedDeclaration" || statement.declaration?.type !== "VariableDeclaration") continue;
+		for (const declarator of statement.declaration.declarations) {
+			if (declarator.id.type !== "Identifier" || declarator.id.name !== "lifecycle" || !declarator.init) continue;
+			const init = unwrapExpression(declarator.init);
+			if (init.type !== "ObjectExpression") throw new Error(`${context.filename ?? "TSX"}: lifecycle 必须是对象字面量`);
+			collectLifecycleObject(script.lifecycle, context, init, "function");
+		}
+	}
+}
+function collectLifecycleObject(out, context, object, mode) {
+	for (const property of object.properties) {
+		if (property.type === "SpreadElement") throw new Error(`${context.filename ?? "TSX"}: lifecycle 暂不支持展开语法`);
+		const key = lifecycleKey(property.key, context.filename);
+		const fn = lifecycleFunctionNode(property, context.filename);
+		out[key] = mode === "function" ? lowerFunctionLike(context, fn, key) : lowerFunctionBodySource(context, fn.body);
+	}
+}
+function appendLifecycleBody(lifecycle, name, body) {
+	const existing = lifecycle[name];
+	lifecycle[name] = `function ${name}() {\n${indentJsBody([existing ? functionBodyFromSource(existing) : "", body].map((item) => item.trim()).filter(Boolean).join("\n"))}\n}`;
+}
+function functionBodyFromSource(source) {
+	const match = source.match(/^function\s+[A-Za-z_$][\w$]*\([^)]*\)\s*\{\n?([\s\S]*)\n?\}$/);
+	if (!match) return source;
+	return match[1].split("\n").map((line) => line.startsWith("  ") ? line.slice(2) : line).join("\n").trim();
+}
+function indentJsBody(source) {
+	return source.split("\n").map((line) => line.trim() ? `  ${line}` : "").join("\n");
+}
+function lifecycleFunctionNode(property, filename) {
+	if (property.type === "ObjectMethod") return property;
+	if (property.type !== "ObjectProperty") throw new Error(`${filename ?? "TSX"}: lifecycle 仅支持方法或函数属性`);
+	const value = unwrapExpression(property.value);
+	if (!isFunctionLike(value)) throw new Error(`${filename ?? "TSX"}: lifecycle 属性值必须是函数`);
+	return value;
+}
+function lifecycleKey(node, filename) {
+	switch (node.type) {
+		case "Identifier": return node.name;
+		case "StringLiteral": return node.value;
+		default: throw new Error(`${filename ?? "TSX"}: lifecycle key 必须是标识符或字符串`);
+	}
+}
+function isUseStateCall(node) {
+	const expression = unwrapExpression(node);
+	return expression.type === "CallExpression" && expression.callee.type === "Identifier" && expression.callee.name === "useState";
+}
+function lowerFunctionLike(context, node, methodName) {
+	return `function ${methodName}(${node.params.map((param) => lowerParameter(context, param)).join(", ")}) ${lowerFunctionBody(context, node.body)}`;
+}
+function lowerParameter(context, param) {
+	const node = unwrapExpression(param);
+	switch (node.type) {
+		case "Identifier": return node.name;
+		case "RestElement": return `...${lowerParameter(context, node.argument)}`;
+		case "AssignmentPattern": return `${lowerParameter(context, node.left)} = ${sourceForNode(context.source, node.right)}`;
+		default: throw new Error(`不支持的方法参数形态：${node.type}`);
+	}
+}
+function lowerFunctionBody(context, body) {
+	const block = unwrapExpression(body);
+	if (block.type !== "BlockStatement") return `{ return ${lowerExpression(context, block)}; }`;
+	const statements = block.body.map((statement) => lowerStatement(context, statement)).filter(Boolean);
+	if (statements.length === 0) return "{}";
+	return `{\n${statements.map((statement) => `  ${statement}`).join("\n")}\n}`;
+}
+function lowerFunctionBodySource(context, body) {
+	const block = unwrapExpression(body);
+	if (block.type !== "BlockStatement") return `return ${lowerExpression(context, block)};`;
+	return block.body.map((statement) => lowerStatement(context, statement)).filter(Boolean).join("\n");
+}
+function lowerStatement(context, statement) {
+	switch (statement.type) {
+		case "ExpressionStatement": return `${lowerExpression(context, statement.expression)};`;
+		case "ReturnStatement": return statement.argument ? `return ${lowerExpression(context, statement.argument)};` : "return;";
+		case "VariableDeclaration": return lowerVariableDeclaration(context, statement);
+		default: return sourceForNode(context.source, statement);
+	}
+}
+function lowerVariableDeclaration(context, statement) {
+	const declarations = statement.declarations.map((declarator) => {
+		const id = sourceForNode(context.source, declarator.id);
+		if (!declarator.init) return id;
+		return `${id} = ${lowerExpression(context, declarator.init)}`;
+	});
+	return `${statement.kind} ${declarations.join(", ")};`;
+}
+function lowerExpression(context, expression, aliases = /* @__PURE__ */ new Map()) {
+	const node = unwrapExpression(expression);
+	switch (node.type) {
+		case "Identifier": {
+			const alias = aliases.get(node.name);
+			if (alias) return `this.${alias}`;
+			if (context.stateVars.has(node.name)) return `this.${node.name}`;
+			return node.name;
+		}
+		case "StringLiteral": return JSON.stringify(node.value);
+		case "NumericLiteral": return String(node.value);
+		case "BooleanLiteral": return String(node.value);
+		case "NullLiteral": return "null";
+		case "BinaryExpression":
+		case "LogicalExpression": return `${lowerExpression(context, node.left, aliases)} ${node.operator} ${lowerExpression(context, node.right, aliases)}`;
+		case "UnaryExpression": return `${node.operator}${lowerExpression(context, node.argument, aliases)}`;
+		case "AssignmentExpression": return `${lowerExpression(context, node.left, aliases)} ${node.operator} ${lowerExpression(context, node.right, aliases)}`;
+		case "UpdateExpression": {
+			const argument = lowerExpression(context, node.argument, aliases);
+			return node.prefix ? `${node.operator}${argument}` : `${argument}${node.operator}`;
+		}
+		case "MemberExpression": return lowerMemberExpression(context, node, aliases);
+		case "CallExpression": {
+			const setterTarget = node.callee.type === "Identifier" ? context.stateSetters.get(node.callee.name) : void 0;
+			if (setterTarget) return lowerStateSetterCall(context, setterTarget, node);
+			return `${lowerExpression(context, node.callee, aliases)}(${node.arguments.map((arg) => {
+				if (arg.type === "SpreadElement") return `...${lowerExpression(context, arg.argument, aliases)}`;
+				return lowerExpression(context, arg, aliases);
+			}).join(", ")})`;
+		}
+		case "ArrowFunctionExpression": return sourceForNode(context.source, node);
+		default: return sourceForNode(context.source, node);
+	}
+}
+function lowerMemberExpression(context, node, aliases) {
+	const object = lowerExpression(context, node.object, aliases);
+	if (node.computed) return `${object}[${lowerExpression(context, node.property, aliases)}]`;
+	return `${object}.${sourceForNode(context.source, node.property)}`;
+}
+function lowerStateSetterCall(context, stateName, node) {
+	const next = node.arguments[0];
+	if (!next) return `this.${stateName} = null`;
+	const expression = unwrapExpression(next);
+	if (expression.type === "ArrowFunctionExpression") {
+		const aliases = /* @__PURE__ */ new Map();
+		const firstParam = expression.params[0];
+		if (firstParam?.type === "Identifier") aliases.set(firstParam.name, stateName);
+		if (expression.body.type === "BlockStatement") throw new Error(`${context.filename ?? "TSX"}: setState updater 暂不支持 block body`);
+		return `this.${stateName} = ${lowerExpression(context, expression.body, aliases)}`;
+	}
+	return `this.${stateName} = ${lowerExpression(context, expression)}`;
+}
+function findTopLevelBinding(body, name) {
+	for (const statement of body) {
+		if (statement.type === "FunctionDeclaration" && statement.id?.name === name) return statement;
+		if (statement.type !== "VariableDeclaration") continue;
+		for (const declarator of statement.declarations) if (declarator.id.type === "Identifier" && declarator.id.name === name) return declarator.init ? unwrapExpression(declarator.init) : void 0;
+	}
+}
+function renderExpressionFromFunction(node, filename) {
+	const body = unwrapExpression(node.body);
+	if (isJsxNode(body)) return body;
+	if (body.type !== "BlockStatement") throw new Error(`${filename ?? "TSX"}: 页面函数必须返回 JSX`);
+	for (const statement of body.body) {
+		if (statement.type !== "ReturnStatement") continue;
+		if (!statement.argument) throw new Error(`${filename ?? "TSX"}: 页面函数返回值不能为空`);
+		return unwrapExpression(statement.argument);
+	}
+	throw new Error(`${filename ?? "TSX"}: 页面函数缺少 return 语句`);
+}
+function templateFromRenderExpression(expression, bindings, filename) {
+	const node = nodeFromJsx(expression, bindings, filename);
+	if (node.kind === "fragment") return node.value;
+	return [node];
+}
+function nodeFromJsx(node, bindings, filename) {
+	switch (node.type) {
+		case "JSXElement": return {
+			kind: "element",
+			value: elementFromJsx(node, bindings, filename)
+		};
+		case "JSXFragment": return {
+			kind: "fragment",
+			value: childrenFromJsx(node.children, bindings, filename)
+		};
+		default: throw new Error(`${filename ?? "TSX"}: 不支持的 JSX 根节点 ${node.type}`);
+	}
+}
+function elementFromJsx(node, bindings, filename) {
+	const name = jsxElementName(node.openingElement.name, filename);
+	const tag = bindings.get(name) ?? name;
+	const isComponent = !bindings.has(name) && /^[A-Z]/.test(name);
+	const attrs = {};
+	const events = {};
+	for (const attr of node.openingElement.attributes) {
+		if (attr.type === "JSXSpreadAttribute") throw new Error(`${filename ?? "TSX"}: 暂不支持 JSX spread 属性`);
+		const attrName = jsxAttributeName(attr.name, filename);
+		if (attrName === "key") continue;
+		if (isEventAttribute(attrName)) {
+			events[eventNameFromAttribute(attrName)] = bindingFromAttribute(attr.value, true, filename);
+			continue;
+		}
+		const normalizedName = normalizeAttributeName(attrName, isComponent);
+		attrs[normalizedName] = attrFromValue(normalizedName, attr.value, filename);
+	}
+	return {
+		tag: isComponent ? kebabCase(tag) : tag,
+		is_component: isComponent,
+		attrs,
+		events,
+		children: childrenFromJsx(node.children, bindings, filename)
+	};
+}
+function childrenFromJsx(children, bindings, filename) {
+	const out = [];
+	for (const child of children) {
+		if (child.type === "JSXText") {
+			const text = normalizeJsxText(child.value);
+			if (text.length > 0) out.push({
+				kind: "text",
+				value: text
+			});
+			continue;
+		}
+		if (child.type === "JSXElement" || child.type === "JSXFragment") {
+			const node = nodeFromJsx(child, bindings, filename);
+			if (node.kind === "fragment") out.push(...node.value);
+			else out.push(node);
+			continue;
+		}
+		if (child.type === "JSXExpressionContainer") {
+			const expression = unwrapExpression(child.expression);
+			if (expression.type === "JSXEmptyExpression") continue;
+			out.push(nodeFromExpression(expression, bindings, filename));
+			continue;
+		}
+		throw new Error(`${filename ?? "TSX"}: 不支持的 JSX 子节点 ${child.type}`);
+	}
+	return out;
+}
+function nodeFromExpression(expression, bindings, filename) {
+	const conditional = conditionalFromExpression(expression, bindings, filename);
+	if (conditional) return conditional;
+	const list = listFromExpression(expression, bindings, filename);
+	if (list) return list;
+	const value = literalValue(expression);
+	if (value !== void 0) return {
+		kind: "text",
+		value: String(value)
+	};
+	return {
+		kind: "expression",
+		value: bindingFromExpression(expression, false, filename)
+	};
+}
+function conditionalFromExpression(expression, bindings, filename) {
+	const node = unwrapExpression(expression);
+	if (node.type === "ConditionalExpression") return {
+		kind: "conditional",
+		value: { branches: [{
+			guard: bindingFromExpression(node.test, false, filename),
+			body: nodesFromBranchExpression(node.consequent, bindings, filename)
+		}, ...alternateBranches(node.alternate, bindings, filename)] }
+	};
+	if (node.type === "LogicalExpression" && node.operator === "&&") return {
+		kind: "conditional",
+		value: { branches: [{
+			guard: bindingFromExpression(node.left, false, filename),
+			body: nodesFromBranchExpression(node.right, bindings, filename)
+		}] }
+	};
+}
+function alternateBranches(expression, bindings, filename) {
+	const node = unwrapExpression(expression);
+	if (node.type === "ConditionalExpression") return [{
+		guard: bindingFromExpression(node.test, false, filename),
+		body: nodesFromBranchExpression(node.consequent, bindings, filename)
+	}, ...alternateBranches(node.alternate, bindings, filename)];
+	return [{
+		guard: null,
+		body: nodesFromBranchExpression(node, bindings, filename)
+	}];
+}
+function nodesFromBranchExpression(expression, bindings, filename) {
+	const node = unwrapExpression(expression);
+	if (node.type === "NullLiteral") return [];
+	if (node.type === "BooleanLiteral" && node.value === false) return [];
+	if (node.type === "JSXElement" || node.type === "JSXFragment") {
+		const result = nodeFromJsx(node, bindings, filename);
+		return result.kind === "fragment" ? result.value : [result];
+	}
+	return [nodeFromExpression(node, bindings, filename)];
+}
+function listFromExpression(expression, bindings, filename) {
+	const node = unwrapExpression(expression);
+	if (node.type !== "CallExpression" || node.callee.type !== "MemberExpression" || node.callee.computed || node.callee.property.type !== "Identifier" || node.callee.property.name !== "map") return;
+	const callback = unwrapExpression(node.arguments[0]);
+	if (!callback || !isFunctionLike(callback)) throw new Error(`${filename ?? "TSX"}: list render 的 map 参数必须是函数`);
+	const itemParam = callback.params[0];
+	if (itemParam?.type !== "Identifier") throw new Error(`${filename ?? "TSX"}: list render 必须声明 item 参数`);
+	const indexParam = callback.params[1];
+	if (indexParam && indexParam.type !== "Identifier") throw new Error(`${filename ?? "TSX"}: list render 的 index 参数必须是标识符`);
+	const bodyExpression = renderExpressionFromMapCallback(callback, filename);
+	return {
+		kind: "list",
+		value: {
+			source: bindingFromExpression(node.callee.object, false, filename),
+			item_var: itemParam.name,
+			index_var: indexParam?.name,
+			key: keyBindingFromJsx(bodyExpression, filename),
+			body: nodesFromBranchExpression(bodyExpression, bindings, filename)
+		}
+	};
+}
+function renderExpressionFromMapCallback(callback, filename) {
+	const body = unwrapExpression(callback.body);
+	if (body.type !== "BlockStatement") return body;
+	for (const statement of body.body) {
+		if (statement.type !== "ReturnStatement") continue;
+		if (!statement.argument) throw new Error(`${filename ?? "TSX"}: list render 的 return 不能为空`);
+		return unwrapExpression(statement.argument);
+	}
+	throw new Error(`${filename ?? "TSX"}: list render 函数缺少 return 语句`);
+}
+function keyBindingFromJsx(expression, filename) {
+	const node = unwrapExpression(expression);
+	if (node.type !== "JSXElement") return;
+	const keyAttr = node.openingElement.attributes.find((attr) => attr.type === "JSXAttribute" && attr.name.type === "JSXIdentifier" && attr.name.name === "key");
+	if (!keyAttr) return;
+	return bindingFromAttribute(keyAttr.value, false, filename);
+}
+function attrFromValue(name, value, filename) {
+	if (!value) return {
+		kind: "static",
+		value: true
+	};
+	if (value.type === "StringLiteral") return {
+		kind: "static",
+		value: value.value
+	};
+	if (value.type !== "JSXExpressionContainer") throw new Error(`${filename ?? "TSX"}: 不支持的属性值 ${value.type}`);
+	const expression = unwrapExpression(value.expression);
+	const literal = literalValue(expression);
+	if (literal !== void 0) return {
+		kind: "static",
+		value: literal
+	};
+	const staticObject = staticAttrLiteral(expression);
+	if (staticObject !== void 0) return {
+		kind: "static",
+		value: staticObject
+	};
+	if (name === "style") {
+		const styleObject = styleObjectAttr(expression, filename);
+		if (styleObject) return {
+			kind: "style_object",
+			value: styleObject
+		};
+	}
+	return {
+		kind: "dynamic",
+		value: bindingFromExpression(expression, false, filename)
+	};
+}
+function styleObjectAttr(expression, filename) {
+	const node = unwrapExpression(expression);
+	if (node.type !== "ObjectExpression") return void 0;
+	const slots = [];
+	for (const property of node.properties) {
+		if (property.type !== "ObjectProperty" || property.computed) throw new Error(`${filename ?? "TSX"}: style 对象暂不支持展开、方法或计算键`);
+		const key = objectPropertyKey(property.key, filename);
+		const value = staticAttrLiteral(property.value);
+		if (value !== void 0) {
+			slots.push({
+				name: key,
+				value: {
+					kind: "static",
+					value
+				}
+			});
+			continue;
+		}
+		slots.push({
+			name: key,
+			value: {
+				kind: "dynamic",
+				value: bindingFromExpression(property.value, false, filename)
+			}
+		});
+	}
+	return slots;
+}
+function staticAttrLiteral(expression) {
+	const node = unwrapExpression(expression);
+	const literal = literalValue(node);
+	if (literal !== void 0) return literal;
+	if (node.type === "UnaryExpression" && node.operator === "-" && unwrapExpression(node.argument).type === "NumericLiteral") return -unwrapExpression(node.argument).value;
+	if (node.type === "ArrayExpression") {
+		const out = [];
+		for (const element of node.elements) {
+			if (!element) {
+				out.push(null);
+				continue;
+			}
+			if (element.type === "SpreadElement") return void 0;
+			const item = staticAttrLiteral(element);
+			if (item === void 0) return void 0;
+			out.push(item);
+		}
+		return out;
+	}
+	if (node.type === "ObjectExpression") {
+		const out = {};
+		for (const property of node.properties) {
+			if (property.type !== "ObjectProperty") return void 0;
+			if (property.computed) return void 0;
+			let key;
+			if (property.key.type === "Identifier") key = property.key.name;
+			else if (property.key.type === "StringLiteral" || property.key.type === "NumericLiteral") key = String(property.key.value);
+			else return;
+			const v = staticAttrLiteral(property.value);
+			if (v === void 0) return void 0;
+			out[key] = v;
+		}
+		return out;
+	}
+}
+function bindingFromAttribute(value, callable, filename) {
+	if (!value || value.type !== "JSXExpressionContainer") throw new Error(`${filename ?? "TSX"}: 事件属性必须使用表达式绑定`);
+	return bindingFromExpression(unwrapExpression(value.expression), callable, filename);
+}
+function bindingFromExpression(expression, callable, filename) {
+	const path = bindingPath(expression);
+	if (!path) throw new Error(`${filename ?? "TSX"}: 当前阶段仅支持标识符或成员访问绑定`);
+	return {
+		path,
+		is_callable: callable
+	};
+}
+function bindingPath(expression) {
+	const node = unwrapExpression(expression);
+	switch (node.type) {
+		case "Identifier": return node.name;
+		case "MemberExpression": {
+			const object = bindingPath(node.object);
+			if (!object || node.computed) return;
+			const property = node.property.type === "Identifier" ? node.property.name : void 0;
+			return property ? `${object}.${property}` : void 0;
+		}
+		case "OptionalMemberExpression": {
+			const object = bindingPath(node.object);
+			if (!object || node.computed) return;
+			const property = node.property.type === "Identifier" ? node.property.name : void 0;
+			return property ? `${object}.${property}` : void 0;
+		}
+		default: return;
+	}
+}
+function literalValue(expression) {
+	switch (expression.type) {
+		case "StringLiteral": return expression.value;
+		case "NumericLiteral": return expression.value;
+		case "BooleanLiteral": return expression.value;
+		case "NullLiteral": return null;
+		default: return;
+	}
+}
+function staticJsonValue(expression, filename) {
+	const node = unwrapExpression(expression);
+	const literal = literalValue(node);
+	if (literal !== void 0) return literal;
+	if (node.type === "ArrayExpression") return node.elements.map((element) => {
+		if (!element) return null;
+		if (element.type === "SpreadElement") throw new Error(`${filename ?? "TSX"}: useState 初值暂不支持数组展开`);
+		return staticJsonValue(element, filename);
+	});
+	if (node.type === "ObjectExpression") {
+		const out = {};
+		for (const property of node.properties) {
+			if (property.type === "SpreadElement") throw new Error(`${filename ?? "TSX"}: useState 初值暂不支持对象展开`);
+			if (property.type !== "ObjectProperty") throw new Error(`${filename ?? "TSX"}: useState 初值暂不支持对象方法`);
+			out[objectPropertyKey(property.key, filename)] = staticJsonValue(property.value, filename);
+		}
+		return out;
+	}
+	throw new Error(`${filename ?? "TSX"}: useState 初值必须是静态 JSON 字面量`);
+}
+function objectPropertyKey(node, filename) {
+	switch (node.type) {
+		case "Identifier": return node.name;
+		case "StringLiteral":
+		case "NumericLiteral": return String(node.value);
+		default: throw new Error(`${filename ?? "TSX"}: 不支持的对象键 ${node.type}`);
+	}
+}
+function sourceForNode(source, node) {
+	if (typeof node.start !== "number" || typeof node.end !== "number") throw new Error("AST 节点缺少源码区间");
+	return source.slice(node.start, node.end);
+}
+function jsxElementName(node, filename) {
+	switch (node.type) {
+		case "JSXIdentifier": return node.name;
+		case "JSXMemberExpression": throw new Error(`${filename ?? "TSX"}: 暂不支持命名空间组件`);
+		case "JSXNamespacedName": throw new Error(`${filename ?? "TSX"}: 暂不支持 JSX namespace 标签`);
+		default: throw new Error(`${filename ?? "TSX"}: 不支持的 JSX 标签 ${node.type}`);
+	}
+}
+function jsxAttributeName(node, filename) {
+	switch (node.type) {
+		case "JSXIdentifier": return node.name;
+		case "JSXNamespacedName": throw new Error(`${filename ?? "TSX"}: 暂不支持 JSX namespace 属性`);
+		default: throw new Error(`${filename ?? "TSX"}: 不支持的 JSX 属性 ${node.type}`);
+	}
+}
+function normalizeJsxText(value) {
+	return value.replace(/\s+/g, " ").trim();
+}
+function normalizeAttributeName(name, isComponent) {
+	if (name === "className") return "class";
+	if (isComponent) return name;
+	return name.replace(/[A-Z]/g, (ch) => `-${ch.toLowerCase()}`);
+}
+function isEventAttribute(name) {
+	return /^on[A-Z]/.test(name);
+}
+function eventNameFromAttribute(name) {
+	return name.slice(2).toLowerCase();
+}
+function isFunctionLike(node) {
+	return node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression" || node.type === "ObjectMethod";
+}
+function isPascalCase(value) {
+	return /^[A-Z]/.test(value);
+}
+function isJsxNode(node) {
+	return node.type === "JSXElement" || node.type === "JSXFragment";
+}
+function unwrapExpression(node) {
+	let current = node;
+	while (current.type === "TSAsExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSTypeAssertion" || current.type === "TSNonNullExpression" || current.type === "ParenthesizedExpression") current = current.expression;
+	return current;
+}
+function kebabCase(value) {
+	return value.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/_/g, "-").toLowerCase();
+}
+//#endregion
+//#region src/project.ts
+const PAGE_EXTENSIONS = new Set([
+	".tsx",
+	".ts",
+	".jsx"
+]);
+function compileAstroForgeProject(options) {
+	const root = resolve(options.root);
+	const config = options.config ?? readAstroForgeConfig(root, options.configFile);
+	const pages = discoverPages(root);
+	if (pages.length === 0) throw new Error(`${root}: 未发现 src/pages 下的页面入口`);
+	const document = createIrDocument(config.manifest, pages);
+	document.app = extractAppModule(root);
+	const visitedFiles = /* @__PURE__ */ new Set();
+	for (const page of pages) {
+		visitedFiles.add(resolve(page.file));
+		const module = extractPageModuleFromTsx(readFileSync(page.file, "utf8"), {
+			route: page.route,
+			filename: page.file,
+			loadStyle: loadStyleImport
+		});
+		document.pages[page.route] = module.page;
+		for (const [name, component] of Object.entries(module.components)) document.components[name] = component;
+		loadCrossFileComponents(document.components, visitedFiles, page.file, module.componentImports);
+		document.pages[page.route].imports = importsFromTemplateAndComponents(document.pages[page.route].template, document.components);
+	}
+	document.assets = collectAssets(root, document);
+	validatePlatformCapabilities(document, config.plugin?.target ?? "vela");
+	const outFile = options.outFile ?? defaultIrOutFile(root, options.cacheDir);
+	writeIrDocument(outFile, document);
+	return {
+		document,
+		outFile,
+		pages
+	};
+}
+function importsFromTemplateAndComponents(template, components) {
+	const imports = {};
+	const visit = (nodes) => {
+		for (const node of nodes) switch (node.kind) {
+			case "element":
+				if (node.value.is_component && components[node.value.tag]) imports[node.value.tag] = node.value.tag;
+				visit(node.value.children);
+				break;
+			case "conditional":
+				for (const branch of node.value.branches) visit(branch.body);
+				break;
+			case "list":
+				visit(node.value.body);
+				break;
+			case "fragment":
+				visit(node.value);
+				break;
+		}
+	};
+	visit(template);
+	return imports;
+}
+function extractAppModule(root) {
+	const appFile = resolve(root, "src", "app.tsx");
+	if (!existsSync(appFile)) return { lifecycle: {} };
+	return extractAppFromTsx(readFileSync(appFile, "utf8"), appFile);
+}
+const COMPONENT_RESOLUTION_EXTENSIONS = [
+	".tsx",
+	".ts",
+	".jsx",
+	""
+];
+function loadCrossFileComponents(components, visitedFiles, parentFile, initial) {
+	const queue = initial.map((ref) => ({
+		parent: parentFile,
+		ref
+	}));
+	while (queue.length > 0) {
+		const { parent, ref } = queue.shift();
+		if (components[ref.tag]) continue;
+		const resolved = resolveComponentImport(parent, ref.from);
+		if (!resolved) continue;
+		if (visitedFiles.has(resolved)) continue;
+		visitedFiles.add(resolved);
+		const result = extractComponentFromTsx(readFileSync(resolved, "utf8"), {
+			filename: resolved,
+			exportName: ref.exportName,
+			loadStyle: loadStyleImport
+		});
+		components[ref.tag] = {
+			...result.component,
+			name: ref.tag
+		};
+		for (const nested of result.componentImports) queue.push({
+			parent: resolved,
+			ref: nested
+		});
+	}
+}
+function loadStyleImport(specifier, importer) {
+	if (!importer) return void 0;
+	if (!specifier.startsWith("./") && !specifier.startsWith("../")) return;
+	const path = resolve(dirname(importer), specifier);
+	if (!existsSync(path)) return void 0;
+	return readFileSync(path, "utf8");
+}
+function resolveComponentImport(parent, spec) {
+	const base = resolve(dirname(parent), spec);
+	for (const ext of COMPONENT_RESOLUTION_EXTENSIONS) {
+		const candidate = `${base}${ext}`;
+		if (existsSync(candidate)) return candidate;
+	}
+	for (const ext of [
+		".tsx",
+		".ts",
+		".jsx"
+	]) {
+		const candidate = join(base, `index${ext}`);
+		if (existsSync(candidate)) return candidate;
+	}
+}
+function discoverPages(root) {
+	return walkFiles(resolve(root, "src", "pages")).filter((file) => PAGE_EXTENSIONS.has(extname(file))).map((file) => pageModuleFromFile(root, file)).sort((a, b) => compareRoutes(a.route, b.route));
+}
+function createRsbuildEntries(root) {
+	const entries = {};
+	for (const page of discoverPages(root)) entries[entryNameFromRoute(page.route)] = `./${toPosix(relative(root, page.file))}`;
+	return entries;
+}
+function defaultIrOutFile(root, cacheDir) {
+	return join(cacheDir ? resolve(root, cacheDir) : resolve(root, "node_modules/.cache/astroforge"), "ir-document.json");
+}
+function createIrDocument(manifestInput, pages) {
+	const routerPages = {};
+	for (const page of pages) routerPages[page.route] = { component: page.component };
+	const source = manifestSource(manifestInput, pages[0].route, routerPages);
+	return {
+		ir_version: 1,
+		manifest: {
+			package: manifestInput.package,
+			name: manifestInput.name,
+			version_name: manifestInput.versionName,
+			version_code: manifestInput.versionCode,
+			min_platform_version: manifestInput.minPlatformVersion,
+			icon: manifestInput.icon,
+			simulation_version: manifestInput.simulationVersion ?? "default",
+			device_type_list: manifestInput.deviceTypeList,
+			features: manifestInput.features ?? [],
+			config: {
+				log_level: manifestInput.config?.logLevel,
+				design_width: manifestInput.config?.designWidth
+			},
+			router: {
+				entry: pages[0].route,
+				pages: routerPages
+			},
+			source
+		},
+		app: { lifecycle: {} },
+		pages: {},
+		components: {},
+		assets: []
+	};
+}
+function manifestSource(input, defaultEntry, routerPages) {
+	const source = {};
+	for (const [key, value] of Object.entries(input)) {
+		if (value === void 0) continue;
+		source[key] = value;
+	}
+	if (!("simulationVersion" in source)) source.simulationVersion = "default";
+	if (!("features" in source)) source.features = [];
+	if (!("config" in source)) source.config = {};
+	source.router = {
+		entry: defaultEntry,
+		pages: Object.fromEntries(Object.entries(routerPages).map(([route, page]) => [route, { component: page.component }]))
+	};
+	return source;
+}
+function pageModuleFromFile(root, file) {
+	let route = stripExtension(toPosix(relative(resolve(root, "src"), file)));
+	if (route.endsWith("/index")) route = route.slice(0, -6);
+	const component = stripExtension(file.split(sep).at(-1) ?? "index");
+	return {
+		route,
+		component,
+		file
+	};
+}
+function walkFiles(root) {
+	const entries = readdirSync(root, { withFileTypes: true });
+	const files = [];
+	for (const entry of entries) {
+		const path = join(root, entry.name);
+		if (entry.isDirectory()) files.push(...walkFiles(path));
+		else if (entry.isFile()) files.push(path);
+	}
+	return files;
+}
+function writeIrDocument(path, document) {
+	mkdirSync(dirname(path), { recursive: true });
+	writeFileSync(path, `${JSON.stringify(document, null, 2)}\n`);
+}
+function stripExtension(path) {
+	const ext = extname(path);
+	return ext ? path.slice(0, -ext.length) : path;
+}
+function entryNameFromRoute(route) {
+	return route.replace(/\//g, "_");
+}
+function compareRoutes(a, b) {
+	if (a === "pages/index") return -1;
+	if (b === "pages/index") return 1;
+	return a.localeCompare(b);
+}
+function toPosix(path) {
+	return path.split(sep).join("/");
+}
+//#endregion
+//#region src/index.ts
+function pluginAstroForge(options = {}) {
+	const target = options.target ?? "vela";
+	if (target !== "vela") throw new Error(`@astralsight/astroforge-rsbuild-plugin: 暂不支持 target=${target}`);
+	return {
+		name: "@astralsight/astroforge-rsbuild-plugin",
+		setup(api) {
+			const root = () => options.root ?? api.context.rootPath;
+			const outFile = () => options.outFile ?? defaultIrOutFile(root(), options.cacheDir);
+			api.modifyRsbuildConfig((config, { mergeRsbuildConfig }) => {
+				return mergeRsbuildConfig(config, {
+					source: { entry: createRsbuildEntries(root()) },
+					tools: { swc(swcConfig) {
+						swcConfig.jsc ??= {};
+						swcConfig.jsc.transform ??= {};
+						swcConfig.jsc.transform.react = {
+							...swcConfig.jsc.transform.react,
+							runtime: "automatic",
+							importSource: "@astralsight/astroforge-core"
+						};
+						return swcConfig;
+					} }
+				});
+			});
+			const emitIr = () => {
+				const result = compileAstroForgeProject({
+					root: root(),
+					configFile: options.configFile,
+					cacheDir: options.cacheDir,
+					outFile: options.outFile,
+					config: options.manifest ? { manifest: options.manifest } : void 0
+				});
+				api.logger.info(`AstroForge IR 已写入 ${outFile()}，页面数：${result.pages.length}`);
+			};
+			api.onBeforeBuild(emitIr);
+			api.onBeforeDevCompile(emitIr);
+			api.expose("astroforge:ir", {
+				emitIr,
+				outFile
+			});
+		}
+	};
+}
+//#endregion
+export { compileAstroForgeProject, createRsbuildEntries, defaultIrOutFile, discoverPages, extractPageFromTsx, parseAstroForgeConfig, pluginAstroForge, readAstroForgeConfig };