@analogjs/vite-plugin-angular 3.0.0-alpha.5 → 3.0.0-alpha.50

package/src/lib/compiler/compile.js

@@ -0,0 +1,731 @@
+import { ANGULAR_DECORATORS, FIELD_DECORATORS } from "./constants.js";
+import { findAllClasses } from "./utils.js";
+import { detectTypeOnlyImportNames, elideTypeOnlyImportsMagicString } from "./type-elision.js";
+import { emitAngularExpr, emitAngularStmt, setEmitterSourceCode, setEmitterSourceFile } from "./js-emitter.js";
+import { lowerClassFields } from "./class-field-lowering.js";
+import { collectStringConstants, detectFieldDecorators, detectSignals, extractConstructorDeps, extractMetadata } from "./metadata.js";
+import { buildDeferDependencyMap } from "./defer.js";
+import { debugCompile } from "./debug.js";
+import { ANGULAR_MAJOR } from "./angular-version.js";
+import * as fs from "node:fs";
+import * as path$1 from "node:path";
+import { parseSync } from "oxc-parser";
+import * as ts from "typescript";
+import * as o from "@angular/compiler";
+import { ConstantPool, FactoryTarget, ParseLocation, ParseSourceFile, ParseSourceSpan, R3NgModuleMetadataKind, R3SelectorScopeMode, compileClassMetadata, compileComponentFromMetadata, compileDeclareClassMetadata, compileDeclareComponentFromMetadata, compileDeclareDirectiveFromMetadata, compileDeclareFactoryFunction, compileDeclareInjectableFromMetadata, compileDeclareInjectorFromMetadata, compileDeclareNgModuleFromMetadata, compileDeclarePipeFromMetadata, compileDirectiveFromMetadata, compileFactoryFunction, compileInjector, compileNgModule, compilePipeFromMetadata, makeBindingParser, parseHostBindings, parseTemplate } from "@angular/compiler";
+import MagicString from "magic-string";
+//#region packages/vite-plugin-angular/src/lib/compiler/compile.ts
+function hasExportModifier(node) {
+	return ts.canHaveModifiers(node) && ts.getModifiers(node)?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) === true;
+}
+/**
+* Collect identifier names referenced in eagerly-evaluated code only.
+* Skips function/arrow/class bodies so that lazy references
+* (e.g. `const TOKEN = () => LaterClass`) are not treated as dependencies.
+*/
+function collectIdentifiers(node) {
+	const ids = /* @__PURE__ */ new Set();
+	function walk(n) {
+		if (ts.isIdentifier(n)) ids.add(n.text);
+		if (ts.isFunctionLike(n) || ts.isClassLike(n)) return;
+		ts.forEachChild(n, walk);
+	}
+	ts.forEachChild(node, walk);
+	return ids;
+}
+/** Extract the names defined by a top-level statement. */
+function getDefinedNames(stmt) {
+	if (ts.isVariableStatement(stmt)) {
+		const names = [];
+		for (const decl of stmt.declarationList.declarations) collectBindingNames(decl.name, names);
+		return names;
+	}
+	if (ts.isFunctionDeclaration(stmt) && stmt.name) return [stmt.name.text];
+	if (ts.isClassDeclaration(stmt) && stmt.name) return [stmt.name.text];
+	return [];
+}
+/** Recursively collect all bound identifiers from a binding name/pattern. */
+function collectBindingNames(name, out) {
+	if (ts.isIdentifier(name)) out.push(name.text);
+	else if (ts.isObjectBindingPattern(name) || ts.isArrayBindingPattern(name)) {
+		for (const el of name.elements) if (!ts.isOmittedExpression(el)) collectBindingNames(el.name, out);
+	}
+}
+function compile(sourceCode, fileName, optionsOrRegistry) {
+	const opts = optionsOrRegistry instanceof Map ? { registry: optionsOrRegistry } : optionsOrRegistry || {};
+	const registry = opts.registry;
+	const resolvedStyles = opts.resolvedStyles;
+	const resolvedInlineStyles = opts.resolvedInlineStyles;
+	const useDefineForClassFields = opts.useDefineForClassFields ?? false;
+	const isPartial = opts.compilationMode === "partial";
+	const startTimeMs = debugCompile.enabled ? performance.now() : 0;
+	debugCompile("compile %s (mode=%s, registry=%d entries)", fileName, isPartial ? "partial" : "full", registry?.size ?? 0);
+	const origSourceFile = ts.createSourceFile(fileName, sourceCode, ts.ScriptTarget.Latest, true);
+	const { program: oxcProgram } = parseSync(fileName, sourceCode);
+	const oxcClassMap = /* @__PURE__ */ new Map();
+	for (const stmt of oxcProgram.body) {
+		const decl = stmt.type === "ExportNamedDeclaration" || stmt.type === "ExportDefaultDeclaration" ? stmt.declaration : stmt;
+		if (decl && (decl.type === "ClassDeclaration" || decl.type === "ClassExpression") && decl.id?.name) oxcClassMap.set(decl.id.name, decl);
+	}
+	const stringConsts = collectStringConstants(oxcProgram);
+	const constantPool = new ConstantPool();
+	const resourceDependencies = [];
+	const parseLoc = new ParseLocation(new ParseSourceFile(sourceCode, fileName), 0, 0, 0);
+	const typeSourceSpan = new ParseSourceSpan(parseLoc, parseLoc);
+	const typeOnlyImports = detectTypeOnlyImportNames(sourceCode);
+	const importSpecifierByName = /* @__PURE__ */ new Map();
+	const importedNames = /* @__PURE__ */ new Set();
+	for (const stmt of origSourceFile.statements) {
+		if (!ts.isImportDeclaration(stmt) || !stmt.importClause?.namedBindings || !ts.isNamedImports(stmt.importClause.namedBindings)) continue;
+		const moduleSpecifier = stmt.moduleSpecifier.text;
+		const isDeclarationTypeOnly = stmt.importClause.isTypeOnly;
+		for (const element of stmt.importClause.namedBindings.elements) {
+			const localName = element.name.text;
+			importedNames.add(localName);
+			importSpecifierByName.set(localName, moduleSpecifier);
+			if (isDeclarationTypeOnly || element.isTypeOnly) typeOnlyImports.add(localName);
+		}
+	}
+	const sourceFile = injectAngularImport(origSourceFile);
+	const localSelectors = /* @__PURE__ */ new Map();
+	if (!registry) for (const [clsName, oxcNode] of oxcClassMap) {
+		const decs = oxcNode.decorators || [];
+		if (decs.length > 0) {
+			const meta = extractMetadata(decs[0], sourceCode, stringConsts);
+			if (meta?.selector) localSelectors.set(clsName, meta.selector.split(",")[0].trim());
+		}
+	}
+	const bindingParser = isPartial ? void 0 : makeBindingParser();
+	setEmitterSourceFile(origSourceFile);
+	setEmitterSourceCode(sourceCode);
+	const classResults = [];
+	const hoistedHelpers = [];
+	const syntheticImports = /* @__PURE__ */ new Map();
+	for (const node of findAllClasses(origSourceFile)) {
+		const decorators = ts.getDecorators(node);
+		if (!decorators || decorators.length === 0) continue;
+		const className = node.name?.text;
+		if (!className) continue;
+		const angularDecorators = decorators.filter((dec) => {
+			if (!ts.isCallExpression(dec.expression)) return false;
+			const name = dec.expression.expression.getText(origSourceFile);
+			return ANGULAR_DECORATORS.has(name);
+		});
+		if (angularDecorators.length === 0) continue;
+		const ivyCode = [];
+		let targetType = FactoryTarget.Injectable;
+		const resolvedResources = /* @__PURE__ */ new Map();
+		const classRef = {
+			value: new o.WrappedNodeExpr(className),
+			type: new o.WrappedNodeExpr(className)
+		};
+		const extendsClause = node.heritageClauses?.find((h) => h.token === ts.SyntaxKind.ExtendsKeyword);
+		const usesInheritance = !!extendsClause && extendsClause.types.length > 0;
+		const oxcNode = oxcClassMap.get(className);
+		let classCompileError = null;
+		angularDecorators.forEach((dec) => {
+			const decoratorName = dec.expression.expression.getText(origSourceFile);
+			const oxcDec = oxcNode?.decorators?.find((d) => {
+				const expr = d.expression;
+				return expr?.type === "CallExpression" && expr.callee?.name === decoratorName;
+			});
+			const meta = extractMetadata(oxcDec, sourceCode, stringConsts);
+			const sigs = oxcNode ? detectSignals(oxcNode, sourceCode) : {
+				inputs: {},
+				outputs: {},
+				viewQueries: [],
+				contentQueries: []
+			};
+			const fields = oxcNode ? detectFieldDecorators(oxcNode, sourceCode) : {
+				inputs: {},
+				outputs: {},
+				viewQueries: [],
+				contentQueries: [],
+				hostProperties: {},
+				hostListeners: {}
+			};
+			const hostBindings = parseHostBindings(meta.hostRaw || {});
+			const hostMetadata = {
+				attributes: hostBindings.attributes,
+				listeners: {
+					...hostBindings.listeners,
+					...fields.hostListeners
+				},
+				properties: {
+					...hostBindings.properties,
+					...fields.hostProperties
+				},
+				specialAttributes: hostBindings.specialAttributes
+			};
+			switch (decoratorName) {
+				case "Component": {
+					targetType = FactoryTarget.Component;
+					if (!meta.selector) meta.selector = `ng-component-${className.toLowerCase()}`;
+					const declarations = [];
+					const seenDeclarationNames = /* @__PURE__ */ new Set();
+					const collectExpandedImports = (depClassName, visited) => {
+						if (visited.has(depClassName)) return [];
+						visited.add(depClassName);
+						const entry = registry?.get(depClassName);
+						if (!entry) return [depClassName];
+						if (entry.kind === "ngmodule" && entry.exports) {
+							const out = [];
+							for (const name of entry.exports) out.push(...collectExpandedImports(name, visited));
+							return out;
+						}
+						if (entry.kind === "tuple" && entry.members) {
+							const out = [];
+							for (const name of entry.members) out.push(...collectExpandedImports(name, visited));
+							return out;
+						}
+						return [depClassName];
+					};
+					for (const dep of Array.isArray(meta.imports) ? meta.imports : []) {
+						const depNode = dep.node;
+						const depClassName = typeof depNode === "string" ? depNode : depNode?.name ?? depNode?.type === "Identifier" ? depNode.name : sourceCode.slice(depNode?.start ?? 0, depNode?.end ?? 0);
+						const registryEntry = registry?.get(depClassName);
+						if (registryEntry?.kind === "tuple" && registryEntry.members) {
+							const expanded = collectExpandedImports(depClassName, /* @__PURE__ */ new Set());
+							const tupleSpecifier = importSpecifierByName.get(depClassName);
+							for (const memberName of expanded) {
+								const memberEntry = registry?.get(memberName);
+								if (!memberEntry || memberEntry.kind === "tuple") continue;
+								const memberRef = new o.WrappedNodeExpr(memberName);
+								if (memberEntry.sourcePackage || tupleSpecifier) {
+									if (!importedNames.has(memberName)) syntheticImports.set(memberName, memberEntry.sourcePackage || tupleSpecifier);
+								}
+								const kind = memberEntry.kind === "pipe" ? 1 : 0;
+								const memberDecl = {
+									type: memberRef,
+									selector: memberEntry.selector,
+									kind,
+									...kind === 1 ? { name: memberEntry.pipeName } : {}
+								};
+								if (memberEntry.inputs) memberDecl.inputs = Object.values(memberEntry.inputs).map((i) => i.bindingPropertyName);
+								if (memberEntry.outputs) memberDecl.outputs = Object.values(memberEntry.outputs);
+								if (!seenDeclarationNames.has(memberName)) {
+									seenDeclarationNames.add(memberName);
+									declarations.push(memberDecl);
+								}
+							}
+							continue;
+						}
+						if (registryEntry?.kind === "ngmodule" && registryEntry.exports) {
+							const moduleSpecifier = importSpecifierByName.get(depClassName);
+							const allExports = [];
+							const expandModule = (moduleName, visited = /* @__PURE__ */ new Set()) => {
+								if (visited.has(moduleName)) return;
+								visited.add(moduleName);
+								const mod = registry?.get(moduleName);
+								if (!mod?.exports) return;
+								for (const name of mod.exports) {
+									const entry = registry?.get(name);
+									if (!entry) continue;
+									if (entry.kind === "ngmodule") expandModule(name, visited);
+									else allExports.push(name);
+								}
+							};
+							expandModule(depClassName);
+							for (const exportedName of allExports) {
+								const exportedEntry = registry?.get(exportedName);
+								if (exportedEntry) {
+									const kind = exportedEntry.kind === "pipe" ? 1 : 0;
+									const exportedRef = new o.WrappedNodeExpr(exportedName);
+									if (exportedEntry.sourcePackage || moduleSpecifier) syntheticImports.set(exportedName, exportedEntry.sourcePackage || moduleSpecifier);
+									const decl = {
+										type: exportedRef,
+										selector: exportedEntry.selector,
+										kind,
+										...kind === 1 ? { name: exportedEntry.pipeName } : {}
+									};
+									if (exportedEntry.inputs) decl.inputs = Object.values(exportedEntry.inputs).map((i) => i.bindingPropertyName);
+									if (exportedEntry.outputs) decl.outputs = Object.values(exportedEntry.outputs);
+									if (!seenDeclarationNames.has(exportedName)) {
+										seenDeclarationNames.add(exportedName);
+										declarations.push(decl);
+									}
+								}
+							}
+							continue;
+						}
+						const selector = registryEntry?.selector ?? localSelectors.get(depClassName);
+						const kind = registryEntry?.kind === "pipe" ? 1 : 0;
+						const decl = {
+							type: dep,
+							selector: selector || `_unresolved-${depClassName}`,
+							kind,
+							...kind === 1 ? { name: registryEntry?.pipeName } : {}
+						};
+						if (registryEntry?.inputs) decl.inputs = Object.values(registryEntry.inputs).map((i) => i.bindingPropertyName);
+						if (registryEntry?.outputs) decl.outputs = Object.values(registryEntry.outputs);
+						if (!seenDeclarationNames.has(depClassName)) {
+							seenDeclarationNames.add(depClassName);
+							declarations.push(decl);
+						}
+					}
+					if (!isPartial && !seenDeclarationNames.has(className)) {
+						const selfInputs = Object.entries(sigs.inputs).map(([, v]) => v.bindingPropertyName);
+						const selfOutputs = Object.values({
+							...meta.outputs,
+							...fields.outputs,
+							...sigs.outputs
+						});
+						seenDeclarationNames.add(className);
+						declarations.push({
+							type: classRef.value,
+							selector: meta.selector,
+							kind: 0,
+							...selfInputs.length > 0 ? { inputs: selfInputs } : {},
+							...selfOutputs.length > 0 ? { outputs: selfOutputs } : {}
+						});
+					}
+					let templateContent = meta.template || "";
+					if (!templateContent && meta.templateUrl) try {
+						const templatePath = path$1.resolve(path$1.dirname(fileName), meta.templateUrl);
+						templateContent = fs.readFileSync(templatePath, "utf-8");
+						resourceDependencies.push(templatePath);
+					} catch {
+						console.warn(`[fast-compile] Could not read template file "${meta.templateUrl}" for ${className}`);
+					}
+					if (Array.isArray(meta.styleUrls)) for (const url of meta.styleUrls) try {
+						const stylePath = path$1.resolve(path$1.dirname(fileName), url);
+						const styleContent = resolvedStyles?.get(stylePath) ?? fs.readFileSync(stylePath, "utf-8");
+						meta.styles.push(styleContent);
+						resourceDependencies.push(stylePath);
+					} catch {
+						console.warn(`[fast-compile] Could not read style file "${url}" for ${className}`);
+					}
+					if (resolvedInlineStyles) {
+						for (const [idx, css] of resolvedInlineStyles) if (idx < meta.styles.length) meta.styles[idx] = css;
+					}
+					resolvedResources.set(dec, {
+						template: templateContent || void 0,
+						styles: meta.styles?.length > 0 ? [...meta.styles] : void 0
+					});
+					const parsedTemplate = parseTemplate(templateContent, fileName, {
+						preserveWhitespaces: meta.preserveWhitespaces,
+						enableI18nLegacyMessageIdFormat: opts.enableI18nLegacyMessageIdFormat ?? true,
+						i18nNormalizeLineEndingsInICUs: opts.i18nNormalizeLineEndingsInICUs ?? true
+					});
+					const ivyInputs = {};
+					if (Array.isArray(meta.inputs)) meta.inputs.forEach((i) => ivyInputs[i] = i);
+					else if (meta.inputs) Object.assign(ivyInputs, meta.inputs);
+					Object.assign(ivyInputs, fields.inputs);
+					for (const [key, val] of Object.entries(sigs.inputs)) {
+						const sigDesc = val;
+						ivyInputs[key] = {
+							classPropertyName: key,
+							bindingPropertyName: sigDesc.bindingPropertyName ?? key,
+							isSignal: true,
+							required: sigDesc.required || false,
+							transformFunction: sigDesc.transform || null
+						};
+					}
+					const templateErrors = parsedTemplate.errors ?? [];
+					if (templateErrors.length > 0) {
+						const firstError = templateErrors[0];
+						classCompileError = /* @__PURE__ */ new Error(`[fast-compile] Template parse error in ${fileName} (${className}): ${firstError.msg}`);
+						return;
+					}
+					const componentMeta = {
+						...meta,
+						name: className,
+						type: classRef,
+						typeSourceSpan,
+						declarations,
+						template: {
+							nodes: parsedTemplate.nodes,
+							ngContentSelectors: parsedTemplate.ngContentSelectors,
+							preserveWhitespaces: parsedTemplate.preserveWhitespaces
+						},
+						styles: [...meta.styles || [], ...parsedTemplate.styles || []],
+						inputs: ivyInputs,
+						outputs: {
+							...meta.outputs,
+							...fields.outputs,
+							...sigs.outputs
+						},
+						viewQueries: [...fields.viewQueries, ...sigs.viewQueries],
+						queries: [...fields.contentQueries, ...sigs.contentQueries],
+						host: hostMetadata,
+						changeDetection: meta.changeDetection ?? (isPartial ? null : 1),
+						encapsulation: meta.encapsulation ?? 0,
+						exportAs: meta.exportAs,
+						providers: meta.providers?.length ? new o.LiteralArrayExpr(meta.providers) : null,
+						viewProviders: meta.viewProviders?.length ? new o.LiteralArrayExpr(meta.viewProviders) : null,
+						animations: meta.animations?.length ? new o.LiteralArrayExpr(meta.animations) : null,
+						isStandalone: meta.standalone,
+						imports: meta.imports,
+						lifecycle: { usesOnChanges: false },
+						interpolation: o.DEFAULT_INTERPOLATION_CONFIG ?? {
+							start: "{{",
+							end: "}}"
+						},
+						usesInheritance,
+						defer: {
+							mode: 0,
+							blocks: buildDeferDependencyMap(parsedTemplate, sourceFile, registry, localSelectors).blocks
+						},
+						declarationListEmitMode: 1,
+						i18nUseExternalIds: opts.i18nUseExternalIds ?? false,
+						relativeContextFilePath: fileName,
+						controlCreate: null
+					};
+					if (ANGULAR_MAJOR < 18) {
+						componentMeta.deferBlocks = /* @__PURE__ */ new Map();
+						componentMeta.deferrableTypes = /* @__PURE__ */ new Map();
+						componentMeta.deferBlockDepsEmitMode = 0;
+					}
+					if (ANGULAR_MAJOR >= 20) componentMeta.hasDirectiveDependencies = declarations.length > 0 || Array.isArray(meta.imports) && meta.imports.length > 0;
+					if (isPartial) {
+						componentMeta.declarations = declarations.map((d) => ({
+							...d,
+							inputs: d.inputs ?? null,
+							outputs: d.outputs ?? null,
+							exportAs: d.exportAs ?? null,
+							isComponent: d.isComponent ?? false
+						}));
+						const cmp = compileDeclareComponentFromMetadata(componentMeta, parsedTemplate, {
+							content: templateContent,
+							sourceUrl: fileName,
+							isInline: !meta.templateUrl,
+							inlineTemplateLiteralExpression: null
+						});
+						ivyCode.push(`static ɵcmp = /*@__PURE__*/ ${emitAngularExpr(cmp.expression)}`);
+						for (const stmt of cmp.statements ?? []) hoistedHelpers.push(emitAngularStmt(stmt));
+					} else {
+						const cmp = compileComponentFromMetadata(componentMeta, constantPool, bindingParser);
+						ivyCode.push(`static ɵcmp = /*@__PURE__*/ ${emitAngularExpr(cmp.expression)}`);
+						for (const stmt of cmp.statements ?? []) hoistedHelpers.push(emitAngularStmt(stmt));
+					}
+					break;
+				}
+				case "Directive": {
+					targetType = FactoryTarget.Directive;
+					const dirInputs = {};
+					if (Array.isArray(meta.inputs)) meta.inputs.forEach((i) => dirInputs[i] = i);
+					else if (meta.inputs) Object.assign(dirInputs, meta.inputs);
+					Object.assign(dirInputs, fields.inputs);
+					for (const [key, val] of Object.entries(sigs.inputs)) {
+						const sigDesc = val;
+						dirInputs[key] = {
+							classPropertyName: key,
+							bindingPropertyName: sigDesc.bindingPropertyName ?? key,
+							isSignal: true,
+							required: sigDesc.required || false,
+							transformFunction: sigDesc.transform || null
+						};
+					}
+					const directiveMeta = {
+						...meta,
+						selector: meta.selector ?? null,
+						name: className,
+						type: classRef,
+						typeSourceSpan,
+						host: hostMetadata,
+						inputs: dirInputs,
+						outputs: {
+							...meta.outputs,
+							...fields.outputs,
+							...sigs.outputs
+						},
+						viewQueries: [...fields.viewQueries, ...sigs.viewQueries],
+						queries: [...fields.contentQueries, ...sigs.contentQueries],
+						providers: meta.providers?.length ? new o.LiteralArrayExpr(meta.providers) : null,
+						exportAs: meta.exportAs,
+						isStandalone: meta.standalone,
+						lifecycle: { usesOnChanges: false },
+						usesInheritance,
+						controlCreate: null
+					};
+					if (isPartial) {
+						const dir = compileDeclareDirectiveFromMetadata(directiveMeta);
+						ivyCode.push(`static ɵdir = /*@__PURE__*/ ${emitAngularExpr(dir.expression)}`);
+					} else {
+						const dir = compileDirectiveFromMetadata(directiveMeta, constantPool, bindingParser);
+						ivyCode.push(`static ɵdir = /*@__PURE__*/ ${emitAngularExpr(dir.expression)}`);
+					}
+					break;
+				}
+				case "Pipe": {
+					targetType = FactoryTarget.Pipe;
+					const pipeMeta = {
+						...meta,
+						name: className,
+						pipeName: meta.name,
+						type: classRef,
+						isStandalone: meta.standalone,
+						pure: meta.pure ?? true
+					};
+					if (isPartial) {
+						const pipe = compileDeclarePipeFromMetadata(pipeMeta);
+						ivyCode.push(`static ɵpipe = /*@__PURE__*/ ${emitAngularExpr(pipe.expression)}`);
+					} else {
+						const pipe = compilePipeFromMetadata(pipeMeta);
+						ivyCode.push(`static ɵpipe = /*@__PURE__*/ ${emitAngularExpr(pipe.expression)}`);
+					}
+					break;
+				}
+				case "Injectable": {
+					targetType = FactoryTarget.Injectable;
+					const injectableMeta = {
+						name: className,
+						type: classRef,
+						typeArgumentCount: 0,
+						providedIn: {
+							expression: new o.LiteralExpr(meta.providedIn || "root"),
+							forwardRef: 0
+						}
+					};
+					if (meta.useClass) injectableMeta.useClass = meta.useClass;
+					if (meta.useFactory) injectableMeta.useFactory = meta.useFactory;
+					if (meta.useExisting) injectableMeta.useExisting = meta.useExisting;
+					if (meta.useValue) injectableMeta.useValue = meta.useValue;
+					if (isPartial) {
+						const inj = compileDeclareInjectableFromMetadata(injectableMeta);
+						ivyCode.push(`static ɵprov = /*@__PURE__*/ ${emitAngularExpr(inj.expression)}`);
+					} else {
+						const inj = o.compileInjectable(injectableMeta, true);
+						ivyCode.push(`static ɵprov = /*@__PURE__*/ ${emitAngularExpr(inj.expression)}`);
+					}
+					break;
+				}
+				case "NgModule": {
+					targetType = FactoryTarget.NgModule;
+					const ngModuleImports = Array.isArray(meta.imports) ? meta.imports : [];
+					const ngModuleDeclarations = Array.isArray(meta.declarations) ? meta.declarations : [];
+					const ngModuleExports = Array.isArray(meta.exports) ? meta.exports : [];
+					const ngModuleBootstrap = Array.isArray(meta.bootstrap) ? meta.bootstrap : [];
+					const ngModuleMeta = {
+						kind: R3NgModuleMetadataKind.Global,
+						type: classRef,
+						bootstrap: ngModuleBootstrap.map((e) => ({
+							value: e,
+							type: e
+						})),
+						declarations: ngModuleDeclarations.map((e) => ({
+							value: e,
+							type: e
+						})),
+						publicDeclarationTypes: null,
+						imports: ngModuleImports.map((e) => ({
+							value: e,
+							type: e
+						})),
+						includeImportTypes: true,
+						exports: ngModuleExports.map((e) => ({
+							value: e,
+							type: e
+						})),
+						selectorScopeMode: R3SelectorScopeMode.Inline,
+						containsForwardDecls: false,
+						schemas: [],
+						id: null
+					};
+					const injectorMeta = {
+						name: className,
+						type: classRef,
+						providers: meta.providers ? new o.LiteralArrayExpr(meta.providers) : null,
+						imports: ngModuleImports.map((e) => e)
+					};
+					if (isPartial) {
+						const ngMod = compileDeclareNgModuleFromMetadata(ngModuleMeta);
+						ivyCode.push(`static ɵmod = /*@__PURE__*/ ${emitAngularExpr(ngMod.expression)}`);
+						const injector = compileDeclareInjectorFromMetadata(injectorMeta);
+						ivyCode.push(`static ɵinj = /*@__PURE__*/ ${emitAngularExpr(injector.expression)}`);
+					} else {
+						const ngMod = compileNgModule(ngModuleMeta);
+						ivyCode.push(`static ɵmod = /*@__PURE__*/ ${emitAngularExpr(ngMod.expression)}`);
+						const injector = compileInjector(injectorMeta);
+						ivyCode.push(`static ɵinj = /*@__PURE__*/ ${emitAngularExpr(injector.expression)}`);
+					}
+					break;
+				}
+			}
+		});
+		if (classCompileError) throw classCompileError;
+		const deps = oxcNode ? extractConstructorDeps(oxcNode, sourceCode, typeOnlyImports) : [];
+		if (deps === null) {
+			const baseVar = `ɵ${className}_BaseFactory`;
+			ivyCode.unshift(`static ɵfac = /*@__PURE__*/ (() => { let ${baseVar}; return function ${className}_Factory(__ngFactoryType__) { return (${baseVar} || (${baseVar} = i0.ɵɵgetInheritedFactory(${className})))(__ngFactoryType__ || ${className}); }; })()`);
+		} else if (deps === "invalid") ivyCode.unshift(`static ɵfac = function ${className}_Factory(__ngFactoryType__) { i0.ɵɵinvalidFactory(); }`);
+		else {
+			const factoryMeta = {
+				name: className,
+				type: classRef,
+				typeArgumentCount: 0,
+				deps,
+				target: targetType
+			};
+			if (isPartial) {
+				const fac = compileDeclareFactoryFunction(factoryMeta);
+				ivyCode.unshift(`static ɵfac = /*@__PURE__*/ ${emitAngularExpr(fac.expression)}`);
+			} else {
+				const fac = compileFactoryFunction(factoryMeta);
+				ivyCode.unshift(`static ɵfac = /*@__PURE__*/ ${emitAngularExpr(fac.expression)}`);
+			}
+		}
+		angularDecorators.forEach((dec) => {
+			const call = dec.expression;
+			const decName = call.expression.getText(origSourceFile);
+			const decArgsNode = call.arguments[0];
+			const resources = resolvedResources.get(dec);
+			let metadataArgsExpr = null;
+			if (decArgsNode) if (resources && ts.isObjectLiteralExpression(decArgsNode)) {
+				const rewrittenProps = [];
+				let needsTransform = false;
+				for (const prop of decArgsNode.properties) {
+					if (!ts.isPropertyAssignment(prop)) {
+						rewrittenProps.push(prop.getText(origSourceFile));
+						continue;
+					}
+					const propName = prop.name?.getText(origSourceFile);
+					if (propName === "templateUrl" && resources.template) {
+						rewrittenProps.push(`template: ${JSON.stringify(resources.template)}`);
+						needsTransform = true;
+					} else if ((propName === "styleUrl" || propName === "styleUrls") && resources.styles?.length) {
+						rewrittenProps.push(`styles: [${resources.styles.map((s) => JSON.stringify(s)).join(", ")}]`);
+						needsTransform = true;
+					} else rewrittenProps.push(prop.getText(origSourceFile));
+				}
+				metadataArgsExpr = needsTransform ? `{${rewrittenProps.join(", ")}}` : decArgsNode.getText(origSourceFile);
+			} else metadataArgsExpr = decArgsNode.getText(origSourceFile);
+			try {
+				const classMetaInput = {
+					type: new o.WrappedNodeExpr(ts.factory.createIdentifier(className)),
+					decorators: new o.LiteralArrayExpr([new o.LiteralMapExpr([{
+						key: "type",
+						value: new o.WrappedNodeExpr(decName),
+						quoted: false
+					}, ...metadataArgsExpr ? [{
+						key: "args",
+						value: new o.LiteralArrayExpr([new o.WrappedNodeExpr(metadataArgsExpr)]),
+						quoted: false
+					}] : []])]),
+					ctorParameters: null,
+					propDecorators: null
+				};
+				const classMetadataExpr = isPartial ? compileDeclareClassMetadata(classMetaInput) : compileClassMetadata(classMetaInput);
+				constantPool.statements.push(new o.ExpressionStatement(classMetadataExpr));
+			} catch (e) {
+				if (debugCompile.enabled) debugCompile("compileClassMetadata failed for %s in %s: %s", className, fileName, e?.message);
+			}
+		});
+		const memberDecorators = [];
+		for (const member of node.members) {
+			const mDecorators = ts.getDecorators(member);
+			if (!mDecorators) continue;
+			for (const dec of mDecorators) {
+				if (!ts.isCallExpression(dec.expression)) continue;
+				const decName = dec.expression.expression.getText(origSourceFile);
+				if (FIELD_DECORATORS.has(decName)) memberDecorators.push(dec);
+			}
+		}
+		classResults.push({
+			ivyCode,
+			decorators: [...angularDecorators, ...memberDecorators],
+			classEnd: node.getEnd()
+		});
+	}
+	const ms = new MagicString(sourceCode, { filename: fileName });
+	if (!sourceCode.includes("import * as i0 from")) ms.prepend("import * as i0 from \"@angular/core\";\n");
+	for (const [name, specifier] of syntheticImports) if (!importedNames.has(name)) {
+		ms.prepend(`import { ${name} } from "${specifier}";\n`);
+		importedNames.add(name);
+	}
+	if (classResults.length > 0) {
+		let firstClassPos = Infinity;
+		const nonHoistableNames = /* @__PURE__ */ new Set();
+		for (const stmt of origSourceFile.statements) if (ts.isClassDeclaration(stmt)) {
+			firstClassPos = stmt.getStart(origSourceFile);
+			if (stmt.name) nonHoistableNames.add(stmt.name.text);
+			break;
+		}
+		for (const stmt of origSourceFile.statements) {
+			if (stmt.getStart(origSourceFile) <= firstClassPos) continue;
+			if (ts.isClassDeclaration(stmt) && stmt.name) nonHoistableNames.add(stmt.name.text);
+			if (ts.isEnumDeclaration(stmt)) nonHoistableNames.add(stmt.name.text);
+			if (ts.isVariableStatement(stmt) && hasExportModifier(stmt)) for (const decl of stmt.declarationList.declarations) {
+				const names = [];
+				collectBindingNames(decl.name, names);
+				for (const n of names) nonHoistableNames.add(n);
+			}
+			if (ts.isFunctionDeclaration(stmt) && hasExportModifier(stmt) && stmt.name) nonHoistableNames.add(stmt.name.text);
+		}
+		for (const stmt of origSourceFile.statements) {
+			const stmtStart = stmt.getStart(origSourceFile);
+			if (stmtStart <= firstClassPos) continue;
+			if (!(ts.isVariableStatement(stmt) && !hasExportModifier(stmt) || ts.isFunctionDeclaration(stmt) && !hasExportModifier(stmt))) continue;
+			const referencedIds = collectIdentifiers(stmt);
+			let referencesNonHoistable = false;
+			for (const id of referencedIds) if (nonHoistableNames.has(id)) {
+				referencesNonHoistable = true;
+				break;
+			}
+			if (referencesNonHoistable) for (const name of getDefinedNames(stmt)) nonHoistableNames.add(name);
+			else {
+				const text = stmt.getText(origSourceFile);
+				ms.remove(stmtStart, stmt.getEnd());
+				ms.appendLeft(firstClassPos, text + "\n");
+			}
+		}
+	}
+	for (const cr of classResults) {
+		for (const dec of cr.decorators) {
+			const start = dec.getStart(origSourceFile);
+			let trimEnd = dec.getEnd();
+			while (trimEnd < sourceCode.length && (sourceCode[trimEnd] === " " || sourceCode[trimEnd] === "\n" || sourceCode[trimEnd] === "\r")) trimEnd++;
+			ms.remove(start, trimEnd);
+		}
+		if (cr.ivyCode.length > 0) {
+			const memberCode = cr.ivyCode.map((c) => "  " + c + ";").join("\n");
+			ms.appendLeft(cr.classEnd - 1, "\n" + memberCode + "\n");
+		}
+	}
+	const helpers = [];
+	const sideEffects = [];
+	helpers.push(...hoistedHelpers);
+	for (const s of constantPool.statements) {
+		const code = emitAngularStmt(s);
+		if (s instanceof o.ExpressionStatement && s.expr instanceof o.InvokeFunctionExpr) sideEffects.push(`/*@__PURE__*/ ${code}`);
+		else helpers.push(code);
+	}
+	if (helpers.length > 0) {
+		const willElide = detectTypeOnlyImportNames(ms.toString());
+		let insertPos = 0;
+		for (const stmt of origSourceFile.statements) if (ts.isImportDeclaration(stmt)) {
+			if (willElide.size > 0 && stmt.importClause) {
+				const clause = stmt.importClause;
+				const namedBindings = clause.namedBindings && ts.isNamedImports(clause.namedBindings) ? clause.namedBindings.elements : void 0;
+				const defaultName = clause.name;
+				if ((!defaultName || willElide.has(defaultName.text)) && (!namedBindings || namedBindings.every((el) => el.isTypeOnly || willElide.has(el.name.text)))) continue;
+			}
+			insertPos = stmt.getEnd();
+		} else if (ts.isVariableStatement(stmt) && !stmt.getText(origSourceFile).includes("class")) insertPos = stmt.getEnd();
+		else if (!ts.isExportAssignment(stmt)) break;
+		if (insertPos === 0) ms.appendLeft(0, helpers.join("\n") + "\n");
+		else ms.appendRight(insertPos, "\n" + helpers.join("\n") + "\n");
+	}
+	if (sideEffects.length > 0) ms.append("\n\n" + sideEffects.join("\n"));
+	if (!useDefineForClassFields) lowerClassFields(ms, sourceCode, oxcProgram);
+	elideTypeOnlyImportsMagicString(ms);
+	const map = ms.generateMap({
+		source: fileName,
+		file: fileName + ".js",
+		includeContent: true,
+		hires: "boundary"
+	});
+	if (debugCompile.enabled) debugCompile("compile %s done (%dms, %d classes, %d resource deps)", fileName, Math.round(performance.now() - startTimeMs), classResults.length, resourceDependencies.length);
+	return {
+		code: ms.toString(),
+		map,
+		resourceDependencies
+	};
+}
+function injectAngularImport(sf) {
+	return ts.factory.updateSourceFile(sf, [ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(false, void 0, ts.factory.createNamespaceImport(ts.factory.createIdentifier("i0"))), ts.factory.createStringLiteral("@angular/core")), ...sf.statements]);
+}
+//#endregion
+export { compile };
+
+//# sourceMappingURL=compile.js.map