@analogjs/vite-plugin-angular 2.5.0-beta.9 → 2.5.1-beta.1

package/src/lib/compiler/compile.js

@@ -0,0 +1,1160 @@
+import * as ts from 'typescript';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as o from '@angular/compiler';
+import MagicString from 'magic-string';
+import { parseSync } from 'oxc-parser';
+import { ConstantPool, compileComponentFromMetadata, compileDirectiveFromMetadata, compilePipeFromMetadata, compileNgModule, compileInjector, R3NgModuleMetadataKind, R3SelectorScopeMode, FactoryTarget, compileFactoryFunction, parseTemplate, makeBindingParser, parseHostBindings, ParseSourceFile, ParseLocation, ParseSourceSpan, compileClassMetadata, compileDeclareComponentFromMetadata, compileDeclareDirectiveFromMetadata, compileDeclarePipeFromMetadata, compileDeclareNgModuleFromMetadata, compileDeclareInjectorFromMetadata, compileDeclareInjectableFromMetadata, compileDeclareFactoryFunction, compileDeclareClassMetadata, } from '@angular/compiler';
+import { findAllClasses } from './utils.js';
+import { ANGULAR_DECORATORS, FIELD_DECORATORS } from './constants.js';
+import { detectTypeOnlyImportNames, elideTypeOnlyImportsMagicString, } from './type-elision.js';
+import { emitAngularExpr, emitAngularStmt, setEmitterSourceFile, setEmitterSourceCode, } from './js-emitter.js';
+import { lowerClassFields } from './class-field-lowering.js';
+import { extractMetadata, collectStringConstants, detectSignals, detectFieldDecorators, extractConstructorDeps, } from './metadata.js';
+import { buildDeferDependencyMap } from './defer.js';
+import { debugCompile } from './debug.js';
+import { ANGULAR_MAJOR } from './angular-version.js';
+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 = new Set();
+    function walk(n) {
+        if (ts.isIdentifier(n)) {
+            ids.add(n.text);
+        }
+        // Stop recursing into lazily-evaluated scopes
+        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);
+            }
+        }
+    }
+}
+export function compile(sourceCode, fileName, optionsOrRegistry) {
+    // Backward compat: accept ComponentRegistry directly
+    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);
+    // OXC parse for metadata extraction (faster than TS for decorator/signal analysis)
+    const { program: oxcProgram } = parseSync(fileName, sourceCode);
+    const oxcClassMap = 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);
+        }
+    }
+    // Collect module-level string constants so decorator metadata can resolve
+    // template-literal interpolations like `template: \`<div class="${tw}">x</div>\``.
+    const stringConsts = collectStringConstants(oxcProgram);
+    const constantPool = new ConstantPool();
+    const resourceDependencies = [];
+    const parseFile = new ParseSourceFile(sourceCode, fileName);
+    const parseLoc = new ParseLocation(parseFile, 0, 0, 0);
+    const typeSourceSpan = new ParseSourceSpan(parseLoc, parseLoc);
+    const typeOnlyImports = detectTypeOnlyImportNames(sourceCode);
+    const importSpecifierByName = new Map();
+    const importedNames = 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;
+        // Explicit `import type { X }` — declaration-level type-only import
+        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);
+            // Explicit `import { type X }` — specifier-level type-only import.
+            // Both forms erase the symbol at runtime, so they cannot be used as
+            // DI tokens. Add them to typeOnlyImports so extractConstructorDeps
+            // surfaces ɵɵinvalidFactory() instead of emitting a broken
+            // ɵɵdirectiveInject(X) referring to a non-existent value.
+            if (isDeclarationTypeOnly || element.isTypeOnly) {
+                typeOnlyImports.add(localName);
+            }
+        }
+    }
+    // Inject 'import * as i0 from "@angular/core"'
+    const sourceFile = injectAngularImport(origSourceFile);
+    // Build a file-local selector map as fallback when no external registry is provided.
+    // Skip the expensive extractMetadata scan when a registry covers all classes.
+    const localSelectors = 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 ? undefined : makeBindingParser();
+    setEmitterSourceFile(origSourceFile);
+    setEmitterSourceCode(sourceCode);
+    const classResults = [];
+    // Per-class hoisted helper statements returned via R3CompiledExpression.statements
+    // (e.g. nested template helper functions for `@if`/`@for`/`@switch` blocks).
+    // Older Angular majors (≤19) return these on `cmp.statements` rather than
+    // pushing them into the shared ConstantPool, so we collect them here and
+    // emit them alongside the constant-pool helpers in step 3. Without this,
+    // any component with control-flow blocks references undefined symbols like
+    // `MyComponent_Conditional_0_Template`.
+    const hoistedHelpers = [];
+    // Track synthetic imports needed for NgModule export expansion.
+    // Maps exported class name → import specifier.
+    const syntheticImports = new Map();
+    // ANGULAR_DECORATORS imported from utils
+    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;
+        // Store resolved resources per decorator for metadata inlining
+        const resolvedResources = new Map();
+        const classRef = {
+            value: new o.WrappedNodeExpr(className),
+            type: new o.WrappedNodeExpr(className),
+        };
+        // Detect `class Foo extends Bar` so the directive/component def
+        // gets `usesInheritance: true`. Angular's compiler turns that into
+        // `features: [InheritDefinitionFeature]`, which is what causes the
+        // runtime to merge inputs/outputs/queries/host bindings from the
+        // base class. Without it, derived directives like
+        // `BrnPopover extends BrnDialog` lose every input declared on the
+        // base, and any host directive that references those inputs by
+        // public name fails at runtime with NG0311.
+        const extendsClause = node.heritageClauses?.find((h) => h.token === ts.SyntaxKind.ExtendsKeyword);
+        const usesInheritance = !!extendsClause && extendsClause.types.length > 0;
+        // Look up the corresponding OXC class node for metadata extraction
+        const oxcNode = oxcClassMap.get(className);
+        let classCompileError = null;
+        angularDecorators.forEach((dec) => {
+            const decoratorName = dec.expression.expression.getText(origSourceFile);
+            // Find the matching OXC decorator by name
+            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 = [];
+                    // Dedupe by class name across direct imports, tuple-barrel
+                    // expansion, and NgModule export expansion so the final
+                    // `dependencies: () => [...]` list never contains the same
+                    // class twice. Otherwise Angular's runtime throws NG0300
+                    // ("Multiple components match …") when a file lists both
+                    // `NgIcon` and a barrel like `HlmIconImports = [HlmIcon, NgIcon]`
+                    // that re-exports it, or when two NgModules re-export the same
+                    // directive (e.g. FormsModule + ReactiveFormsModule →
+                    // DefaultValueAccessor).
+                    const seenDeclarationNames = new Set();
+                    // Expand `imports` entries that are not directives themselves
+                    // (e.g. NgModules and tuple barrels like `HlmSelectImports =
+                    // [HlmSelect, HlmSelectContent, ...] as const`) into the
+                    // underlying directive class names. Returns the original entry
+                    // when it doesn't match either expansion case.
+                    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);
+                        // Tuple barrel: `imports: [HlmSelectImports]` where the
+                        // const is `[HlmSelect, HlmSelectContent, ...] as const`.
+                        // Expand into the underlying directive declarations and
+                        // track synthetic imports for any classes not already
+                        // referenced in this file.
+                        if (registryEntry?.kind === 'tuple' && registryEntry.members) {
+                            const expanded = collectExpandedImports(depClassName, 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);
+                            // Recursively collect all non-module exports (handles nested NgModules
+                            // like ReactiveFormsModule → ɵInternalFormsSharedModule → DefaultValueAccessor)
+                            const allExports = [];
+                            const expandModule = (moduleName, visited = 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;
+                                    // Create a reference to the exported class. If it's not
+                                    // already imported, track it for synthetic import injection.
+                                    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 } : {}),
+                        };
+                        // Pass inputs/outputs from registry so template bindings resolve.
+                        // R3DirectiveDependencyMetadata expects inputs/outputs as string[]
+                        // of binding property names.
+                        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);
+                        }
+                    }
+                    // Add self-reference so recursive components (e.g. tree views)
+                    // can use their own selector in their template.
+                    // Skip in partial mode — the linker handles self-resolution.
+                    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.resolve(path.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.resolve(path.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;
+                            }
+                        }
+                    }
+                    // Store resolved resources for metadata inlining
+                    resolvedResources.set(dec, {
+                        template: templateContent || undefined,
+                        styles: meta.styles?.length > 0 ? [...meta.styles] : undefined,
+                    });
+                    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,
+                            // Honor the binding name (alias) extracted by detectSignals
+                            // so `input(null, { alias: 'aria-label' })` registers with
+                            // the public name `aria-label`, not the class property name.
+                            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 = 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 },
+                        // Angular v19/v20's `createComponentDefinitionMap` reads
+                        // `meta.interpolation.start` and `meta.interpolation.end`
+                        // unconditionally (the `!== DEFAULT_INTERPOLATION_CONFIG` check
+                        // is reference-equality, so a missing field enters the block
+                        // and crashes with `Cannot read properties of undefined`). v21
+                        // dropped the field from `createComponentDefinitionMap`
+                        // entirely. Use the v19/v20 singleton when the Angular package
+                        // exports it (matches the reference-equality check, skipping
+                        // the partial-mode emission block) and fall back to a plain
+                        // shape on v21+ where the field is ignored anyway.
+                        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) {
+                        // Angular v17 reads `meta.deferBlocks`, `meta.deferrableTypes`,
+                        // and `meta.deferBlockDepsEmitMode` as flat top-level fields on
+                        // the component metadata; v18 nested them under `meta.defer`.
+                        // `compileComponentFromMetadata` on v17 reads `.size` on the two
+                        // Maps unconditionally (compiler.mjs ~30770), so the fields must
+                        // exist as Maps even for components that don't use @defer.
+                        // Empty Maps are sufficient for the no-@defer case — components
+                        // that actually use @defer on v17 are not supported (the v17
+                        // @defer ABI is significantly different from v18+ and is not
+                        // worth back-porting per the minimum-effort policy).
+                        componentMeta.deferBlocks = new Map();
+                        componentMeta.deferrableTypes = new Map();
+                        componentMeta.deferBlockDepsEmitMode = 0;
+                    }
+                    if (ANGULAR_MAJOR >= 20) {
+                        componentMeta.hasDirectiveDependencies =
+                            declarations.length > 0 ||
+                                (Array.isArray(meta.imports) && meta.imports.length > 0);
+                    }
+                    if (isPartial) {
+                        // Partial compilation accesses .inputs, .outputs, .exportAs on
+                        // each declaration — ensure they are arrays (not undefined).
+                        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)}`);
+                        // Hoist nested template helper functions returned via
+                        // R3CompiledExpression.statements. On Angular ≤19 these contain
+                        // `*_Conditional_*_Template`, `*_For_*_Template`, etc. functions
+                        // that the component definition references; on Angular ≥20 they
+                        // are typically pushed into the shared constantPool instead and
+                        // this loop is a no-op.
+                        for (const stmt of cmp.statements ?? []) {
+                            hoistedHelpers.push(emitAngularStmt(stmt));
+                        }
+                    }
+                    break;
+                }
+                case 'Directive': {
+                    targetType = FactoryTarget.Directive;
+                    // Build proper input descriptors (same as Component path)
+                    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,
+                            // Honor the binding name (alias) extracted by detectSignals.
+                            bindingPropertyName: sigDesc.bindingPropertyName ?? key,
+                            isSignal: true,
+                            required: sigDesc.required || false,
+                            transformFunction: sigDesc.transform || null,
+                        };
+                    }
+                    const directiveMeta = {
+                        ...meta,
+                        // Abstract base directives are declared as `@Directive()` with
+                        // no metadata. Angular's R3DirectiveMetadata accepts
+                        // `selector: string | null`, but the downstream selector parser
+                        // calls `.replace()` on the value and crashes on `undefined`.
+                        // Coerce missing selectors to `null` so abstract base classes
+                        // compile correctly.
+                        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],
+                        // Angular's compiler treats `providers` as an Expression and
+                        // emits `ɵɵProvidersFeature(<expr>)` whenever it is truthy.
+                        // Passing the bare JS array of WrappedNodeExpr from
+                        // extractMetadata causes the emitter to lower it to `null`,
+                        // which then crashes Angular at runtime in `resolveProvider`
+                        // because it tries to read `.provide` on `null`. Wrap into a
+                        // LiteralArrayExpr (matching the Component branch) so it
+                        // emits a real array literal — and pass `null` when there are
+                        // no providers so Angular skips the feature entirely.
+                        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,
+                        },
+                    };
+                    // Forward provider configuration so `ɵprov` honors useFactory/
+                    // useClass/useExisting/useValue. Without this, an
+                    // `@Injectable({ useFactory: () => ... })` quietly falls back
+                    // to constructor instantiation.
+                    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;
+        }
+        // Generate factory
+        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)}`);
+            }
+        }
+        // Emit setClassMetadata for runtime decorator reflection (devMode only)
+        angularDecorators.forEach((dec) => {
+            const call = dec.expression;
+            const decName = call.expression.getText(origSourceFile);
+            const decArgsNode = call.arguments[0];
+            // Build the decorator args for setClassMetadata, inlining resources if needed.
+            const resources = resolvedResources.get(dec);
+            let metadataArgsExpr = null;
+            if (decArgsNode) {
+                if (resources && ts.isObjectLiteralExpression(decArgsNode)) {
+                    // Inline external templateUrl/styleUrl(s) into the metadata so Angular's
+                    // runtime doesn't try to fetch relative URLs (which fails during SSR).
+                    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 {
+                // `LiteralMapPropertyAssignment` was a class with a constructor in
+                // Angular up through ~v19, removed-then-restored in later v20/v21
+                // patches. The only stable shape across versions is the plain
+                // `{ key, value, quoted }` object literal — Angular's own emitter
+                // and Analog's `JSEmitter` both consume entries via duck typing
+                // (`.key` / `.value` / `.quoted`), and `compileClassMetadata` does
+                // not `instanceof`-check entries. The js-emitter has a matching
+                // comment at the consumption site. Using `new o.LiteralMapProperty
+                // Assignment(...)` would throw "is not a constructor" on Angular
+                // versions where the class export is missing (e.g. 20.3.x), and
+                // the surrounding try/catch would silently disable class metadata
+                // emission for every class in the project.
+                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) {
+                // Skip if compileClassMetadata fails — surfaced via DEBUG=analog-fast-compile
+                if (debugCompile.enabled) {
+                    debugCompile('compileClassMetadata failed for %s in %s: %s', className, fileName, e?.message);
+                }
+            }
+        });
+        // Collect member decorators (@HostListener, @HostBinding, @Input, @Output,
+        // @ViewChild, @ContentChild, etc.) so they are removed from the source.
+        // The metadata has already been extracted by detectFieldDecorators().
+        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(),
+        });
+    }
+    // Apply edits via MagicString
+    const ms = new MagicString(sourceCode, { filename: fileName });
+    // 1. Prepend i0 import (skip if already present)
+    if (!sourceCode.includes('import * as i0 from')) {
+        ms.prepend('import * as i0 from "@angular/core";\n');
+    }
+    // 1b. Inject synthetic imports for NgModule-exported classes
+    for (const [name, specifier] of syntheticImports) {
+        if (!importedNames.has(name)) {
+            ms.prepend(`import { ${name} } from "${specifier}";\n`);
+            importedNames.add(name);
+        }
+    }
+    // 2a. Hoist non-exported variable/function declarations that appear after
+    // a class to just before the first class. This avoids TDZ errors when
+    // static ɵcmp references file-level constants declared after the class.
+    //
+    // We must NOT hoist a statement whose initializer references a name
+    // (class, exported const/let) that is defined between firstClassPos and
+    // the statement itself — doing so would move the reference before the
+    // definition and cause a TDZ error at runtime.
+    if (classResults.length > 0) {
+        // Find the position right before the first class (any class, not just Angular-decorated)
+        let firstClassPos = Infinity;
+        const nonHoistableNames = new Set();
+        for (const stmt of origSourceFile.statements) {
+            if (ts.isClassDeclaration(stmt)) {
+                firstClassPos = stmt.getStart(origSourceFile);
+                // The first class itself is non-hoistable — statements hoisted
+                // before it must not reference it.
+                if (stmt.name) {
+                    nonHoistableNames.add(stmt.name.text);
+                }
+                break;
+            }
+        }
+        // Pass 1: collect names defined by statements that will NOT be hoisted
+        // (classes, exported vars/functions) and therefore remain after firstClassPos.
+        for (const stmt of origSourceFile.statements) {
+            const stmtStart = stmt.getStart(origSourceFile);
+            if (stmtStart <= 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);
+            }
+        }
+        // Pass 2: for each hoist candidate, check if it references any
+        // non-hoistable name. If it does, skip it and add its own names to the
+        // non-hoistable set (transitivity).
+        for (const stmt of origSourceFile.statements) {
+            const stmtStart = stmt.getStart(origSourceFile);
+            if (stmtStart <= firstClassPos)
+                continue;
+            const isCandidate = (ts.isVariableStatement(stmt) && !hasExportModifier(stmt)) ||
+                (ts.isFunctionDeclaration(stmt) && !hasExportModifier(stmt));
+            if (!isCandidate)
+                continue;
+            const referencedIds = collectIdentifiers(stmt);
+            let referencesNonHoistable = false;
+            for (const id of referencedIds) {
+                if (nonHoistableNames.has(id)) {
+                    referencesNonHoistable = true;
+                    break;
+                }
+            }
+            if (referencesNonHoistable) {
+                // Don't hoist — mark this statement's names as non-hoistable too
+                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');
+            }
+        }
+    }
+    // 2. For each compiled class: remove decorators + insert Ivy definitions
+    for (const cr of classResults) {
+        // Remove Angular decorators from source
+        for (const dec of cr.decorators) {
+            const start = dec.getStart(origSourceFile);
+            const end = dec.getEnd();
+            let trimEnd = end;
+            while (trimEnd < sourceCode.length &&
+                (sourceCode[trimEnd] === ' ' ||
+                    sourceCode[trimEnd] === '\n' ||
+                    sourceCode[trimEnd] === '\r')) {
+                trimEnd++;
+            }
+            ms.remove(start, trimEnd);
+        }
+        // Insert static members before closing }
+        if (cr.ivyCode.length > 0) {
+            const memberCode = cr.ivyCode.map((c) => '  ' + c + ';').join('\n');
+            ms.appendLeft(cr.classEnd - 1, '\n' + memberCode + '\n');
+        }
+    }
+    // 3. Emit constant pool statements.
+    // Split into: helper declarations (const/function) that must appear before
+    // the class (since static property initializers reference them), and
+    // side-effect statements (setClassMetadata IIFEs) that go after.
+    const helpers = [];
+    const sideEffects = [];
+    // Per-class hoisted helpers (nested template functions) come first so they
+    // are available when subsequent constant-pool helpers reference them.
+    helpers.push(...hoistedHelpers);
+    for (const s of constantPool.statements) {
+        const code = emitAngularStmt(s);
+        if (s instanceof o.ExpressionStatement &&
+            s.expr instanceof o.InvokeFunctionExpr) {
+            // setClassMetadata is wrapped in `(() => { ... })()` — annotate
+            // the IIFE call so bundlers can drop it when ngDevMode is folded
+            // to false at production build time.
+            sideEffects.push(`/*@__PURE__*/ ${code}`);
+        }
+        else {
+            helpers.push(code);
+        }
+    }
+    if (helpers.length > 0) {
+        // Insert helpers after the last import / top-level non-class statement,
+        // well before any class that references them.
+        // Detect which imported names are type-only so we skip imports that will
+        // be fully removed by elideTypeOnlyImportsMagicString (step 4).
+        // Inserting at a position inside a soon-to-be-removed range would cause
+        // MagicString to discard the helpers along with the import.
+        const willElide = detectTypeOnlyImportNames(ms.toString());
+        let insertPos = 0;
+        for (const stmt of origSourceFile.statements) {
+            if (ts.isImportDeclaration(stmt)) {
+                // Skip imports that will be entirely removed by type elision
+                if (willElide.size > 0 && stmt.importClause) {
+                    const clause = stmt.importClause;
+                    const namedBindings = clause.namedBindings && ts.isNamedImports(clause.namedBindings)
+                        ? clause.namedBindings.elements
+                        : undefined;
+                    const defaultName = clause.name;
+                    const allElided = (!defaultName || willElide.has(defaultName.text)) &&
+                        (!namedBindings ||
+                            namedBindings.every((el) => el.isTypeOnly || willElide.has(el.name.text)));
+                    if (allElided)
+                        continue;
+                }
+                insertPos = stmt.getEnd();
+            }
+            else if (ts.isVariableStatement(stmt) &&
+                !stmt.getText(origSourceFile).includes('class')) {
+                insertPos = stmt.getEnd();
+            }
+            else if (!ts.isExportAssignment(stmt)) {
+                // Stop at the first class or non-import/non-variable statement
+                break;
+            }
+        }
+        // Helpers must survive downstream `ms.overwrite()` / `ms.remove()` of
+        // imports performed by the type-only specifier elision pass (step 5).
+        //
+        // Case `insertPos > 0`: a surviving import ends at `insertPos`. Use
+        // `appendRight(insertPos, …)` so helpers bind to the `\n` after the
+        // import's `;` — outside any overwrite range `[node.start, node.end)`
+        // of a preceding import. `appendLeft(insertPos, …)` would bind to the
+        // `;` itself, which IS inside the overwrite range and would be wiped.
+        //
+        // Case `insertPos === 0`: no import survives — every import is going
+        // to be elided, and `elideTypeOnlyImportsMagicString` will
+        // `ms.remove(0, declEnd)` the first one. `appendRight(0, …)` anchors
+        // to the character at position 0 (the first import's first char),
+        // which is inside `[0, declEnd)` and gets wiped. Use `appendLeft(0, …)`
+        // instead — it anchors to the LEFT of position 0, outside any range
+        // starting at 0, so the helpers survive. Ordering is still correct
+        // because the i0 import prepended in step 1 lives in MagicString's
+        // `intro` (from `ms.prepend`), which always emits before any
+        // `appendLeft` content at position 0.
+        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'));
+    }
+    // 4. Lower class field initializers to constructor assignments when
+    //    useDefineForClassFields is false (standard Angular tsconfig).
+    //    Uses the original OXC AST positions which are still valid for MagicString
+    //    since MagicString tracks edits relative to the original source.
+    //    Ivy static definitions (ɵcmp, ɵfac) are not in the original AST so they
+    //    are unaffected, and shouldLowerField skips static fields regardless.
+    if (!useDefineForClassFields) {
+        lowerClassFields(ms, sourceCode, oxcProgram);
+    }
+    // 5. Elide imports that are only used in type positions (type annotations,
+    //    implements, generics, etc.).  Without this pass, single-file transpilers
+    //    like OXC / esbuild cannot tell that `import { SomeType }` is type-only
+    //    and will leave the import in the output, causing runtime errors.
+    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(undefined, ts.factory.createImportClause(false, undefined, ts.factory.createNamespaceImport(ts.factory.createIdentifier('i0'))), ts.factory.createStringLiteral('@angular/core')),
+        ...sf.statements,
+    ]);
+}
+//# sourceMappingURL=compile.js.map