@angular/core 19.0.0-rc.0 → 19.0.0-rc.2

package/schematics/bundles/{checker-2451e7c5.js → checker-cd95ebda.js}

@@ -1,6 +1,6 @@
 'use strict';
 /**
- * @license Angular v19.0.0-rc.0
+ * @license Angular v19.0.0-rc.2
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -896,12 +896,12 @@ const STRING_TYPE = new BuiltinType(BuiltinTypeName.String);
 new BuiltinType(BuiltinTypeName.Function);
 const NONE_TYPE = new BuiltinType(BuiltinTypeName.None);
 ///// Expressions
-exports.UnaryOperator = void 0;
+var UnaryOperator;
 (function (UnaryOperator) {
     UnaryOperator[UnaryOperator["Minus"] = 0] = "Minus";
     UnaryOperator[UnaryOperator["Plus"] = 1] = "Plus";
-})(exports.UnaryOperator || (exports.UnaryOperator = {}));
-exports.BinaryOperator = void 0;
+})(UnaryOperator || (UnaryOperator = {}));
+var BinaryOperator;
 (function (BinaryOperator) {
     BinaryOperator[BinaryOperator["Equals"] = 0] = "Equals";
     BinaryOperator[BinaryOperator["NotEquals"] = 1] = "NotEquals";
@@ -921,7 +921,7 @@ exports.BinaryOperator = void 0;
     BinaryOperator[BinaryOperator["Bigger"] = 15] = "Bigger";
     BinaryOperator[BinaryOperator["BiggerEquals"] = 16] = "BiggerEquals";
     BinaryOperator[BinaryOperator["NullishCoalesce"] = 17] = "NullishCoalesce";
-})(exports.BinaryOperator || (exports.BinaryOperator = {}));
+})(BinaryOperator || (BinaryOperator = {}));
 function nullSafeIsEquivalent(base, other) {
     if (base == null || other == null) {
         return base == other;
@@ -966,55 +966,55 @@ class Expression {
         return new ConditionalExpr(this, trueCase, falseCase, null, sourceSpan);
     }
     equals(rhs, sourceSpan) {
-        return new BinaryOperatorExpr(exports.BinaryOperator.Equals, this, rhs, null, sourceSpan);
+        return new BinaryOperatorExpr(BinaryOperator.Equals, this, rhs, null, sourceSpan);
     }
     notEquals(rhs, sourceSpan) {
-        return new BinaryOperatorExpr(exports.BinaryOperator.NotEquals, this, rhs, null, sourceSpan);
+        return new BinaryOperatorExpr(BinaryOperator.NotEquals, this, rhs, null, sourceSpan);
     }
     identical(rhs, sourceSpan) {
-        return new BinaryOperatorExpr(exports.BinaryOperator.Identical, this, rhs, null, sourceSpan);
+        return new BinaryOperatorExpr(BinaryOperator.Identical, this, rhs, null, sourceSpan);
     }
     notIdentical(rhs, sourceSpan) {
-        return new BinaryOperatorExpr(exports.BinaryOperator.NotIdentical, this, rhs, null, sourceSpan);
+        return new BinaryOperatorExpr(BinaryOperator.NotIdentical, this, rhs, null, sourceSpan);
     }
     minus(rhs, sourceSpan) {
-        return new BinaryOperatorExpr(exports.BinaryOperator.Minus, this, rhs, null, sourceSpan);
+        return new BinaryOperatorExpr(BinaryOperator.Minus, this, rhs, null, sourceSpan);
     }
     plus(rhs, sourceSpan) {
-        return new BinaryOperatorExpr(exports.BinaryOperator.Plus, this, rhs, null, sourceSpan);
+        return new BinaryOperatorExpr(BinaryOperator.Plus, this, rhs, null, sourceSpan);
     }
     divide(rhs, sourceSpan) {
-        return new BinaryOperatorExpr(exports.BinaryOperator.Divide, this, rhs, null, sourceSpan);
+        return new BinaryOperatorExpr(BinaryOperator.Divide, this, rhs, null, sourceSpan);
     }
     multiply(rhs, sourceSpan) {
-        return new BinaryOperatorExpr(exports.BinaryOperator.Multiply, this, rhs, null, sourceSpan);
+        return new BinaryOperatorExpr(BinaryOperator.Multiply, this, rhs, null, sourceSpan);
     }
     modulo(rhs, sourceSpan) {
-        return new BinaryOperatorExpr(exports.BinaryOperator.Modulo, this, rhs, null, sourceSpan);
+        return new BinaryOperatorExpr(BinaryOperator.Modulo, this, rhs, null, sourceSpan);
     }
     and(rhs, sourceSpan) {
-        return new BinaryOperatorExpr(exports.BinaryOperator.And, this, rhs, null, sourceSpan);
+        return new BinaryOperatorExpr(BinaryOperator.And, this, rhs, null, sourceSpan);
     }
     bitwiseOr(rhs, sourceSpan, parens = true) {
-        return new BinaryOperatorExpr(exports.BinaryOperator.BitwiseOr, this, rhs, null, sourceSpan, parens);
+        return new BinaryOperatorExpr(BinaryOperator.BitwiseOr, this, rhs, null, sourceSpan, parens);
     }
     bitwiseAnd(rhs, sourceSpan, parens = true) {
-        return new BinaryOperatorExpr(exports.BinaryOperator.BitwiseAnd, this, rhs, null, sourceSpan, parens);
+        return new BinaryOperatorExpr(BinaryOperator.BitwiseAnd, this, rhs, null, sourceSpan, parens);
     }
     or(rhs, sourceSpan) {
-        return new BinaryOperatorExpr(exports.BinaryOperator.Or, this, rhs, null, sourceSpan);
+        return new BinaryOperatorExpr(BinaryOperator.Or, this, rhs, null, sourceSpan);
     }
     lower(rhs, sourceSpan) {
-        return new BinaryOperatorExpr(exports.BinaryOperator.Lower, this, rhs, null, sourceSpan);
+        return new BinaryOperatorExpr(BinaryOperator.Lower, this, rhs, null, sourceSpan);
     }
     lowerEquals(rhs, sourceSpan) {
-        return new BinaryOperatorExpr(exports.BinaryOperator.LowerEquals, this, rhs, null, sourceSpan);
+        return new BinaryOperatorExpr(BinaryOperator.LowerEquals, this, rhs, null, sourceSpan);
     }
     bigger(rhs, sourceSpan) {
-        return new BinaryOperatorExpr(exports.BinaryOperator.Bigger, this, rhs, null, sourceSpan);
+        return new BinaryOperatorExpr(BinaryOperator.Bigger, this, rhs, null, sourceSpan);
     }
     biggerEquals(rhs, sourceSpan) {
-        return new BinaryOperatorExpr(exports.BinaryOperator.BiggerEquals, this, rhs, null, sourceSpan);
+        return new BinaryOperatorExpr(BinaryOperator.BiggerEquals, this, rhs, null, sourceSpan);
     }
     isBlank(sourceSpan) {
         // Note: We use equals by purpose here to compare to null and undefined in JS.
@@ -1022,7 +1022,7 @@ class Expression {
         return this.equals(TYPED_NULL_EXPR, sourceSpan);
     }
     nullishCoalesce(rhs, sourceSpan) {
-        return new BinaryOperatorExpr(exports.BinaryOperator.NullishCoalesce, this, rhs, null, sourceSpan);
+        return new BinaryOperatorExpr(BinaryOperator.NullishCoalesce, this, rhs, null, sourceSpan);
     }
     toStmt() {
         return new ExpressionStatement(this, null);
@@ -1444,8 +1444,7 @@ class ExternalExpr extends Expression {
     isEquivalent(e) {
         return (e instanceof ExternalExpr &&
             this.value.name === e.value.name &&
-            this.value.moduleName === e.value.moduleName &&
-            this.value.runtime === e.value.runtime);
+            this.value.moduleName === e.value.moduleName);
     }
     isConstant() {
         return false;
@@ -1460,11 +1459,9 @@ class ExternalExpr extends Expression {
 class ExternalReference {
     moduleName;
     name;
-    runtime;
-    constructor(moduleName, name, runtime) {
+    constructor(moduleName, name) {
         this.moduleName = moduleName;
         this.name = name;
-        this.runtime = runtime;
     }
 }
 class ConditionalExpr extends Expression {
@@ -3536,10 +3533,10 @@ class AbstractEmitterVisitor {
     visitUnaryOperatorExpr(ast, ctx) {
         let opStr;
         switch (ast.operator) {
-            case exports.UnaryOperator.Plus:
+            case UnaryOperator.Plus:
                 opStr = '+';
                 break;
-            case exports.UnaryOperator.Minus:
+            case UnaryOperator.Minus:
                 opStr = '-';
                 break;
             default:
@@ -3556,58 +3553,58 @@ class AbstractEmitterVisitor {
     visitBinaryOperatorExpr(ast, ctx) {
         let opStr;
         switch (ast.operator) {
-            case exports.BinaryOperator.Equals:
+            case BinaryOperator.Equals:
                 opStr = '==';
                 break;
-            case exports.BinaryOperator.Identical:
+            case BinaryOperator.Identical:
                 opStr = '===';
                 break;
-            case exports.BinaryOperator.NotEquals:
+            case BinaryOperator.NotEquals:
                 opStr = '!=';
                 break;
-            case exports.BinaryOperator.NotIdentical:
+            case BinaryOperator.NotIdentical:
                 opStr = '!==';
                 break;
-            case exports.BinaryOperator.And:
+            case BinaryOperator.And:
                 opStr = '&&';
                 break;
-            case exports.BinaryOperator.BitwiseOr:
+            case BinaryOperator.BitwiseOr:
                 opStr = '|';
                 break;
-            case exports.BinaryOperator.BitwiseAnd:
+            case BinaryOperator.BitwiseAnd:
                 opStr = '&';
                 break;
-            case exports.BinaryOperator.Or:
+            case BinaryOperator.Or:
                 opStr = '||';
                 break;
-            case exports.BinaryOperator.Plus:
+            case BinaryOperator.Plus:
                 opStr = '+';
                 break;
-            case exports.BinaryOperator.Minus:
+            case BinaryOperator.Minus:
                 opStr = '-';
                 break;
-            case exports.BinaryOperator.Divide:
+            case BinaryOperator.Divide:
                 opStr = '/';
                 break;
-            case exports.BinaryOperator.Multiply:
+            case BinaryOperator.Multiply:
                 opStr = '*';
                 break;
-            case exports.BinaryOperator.Modulo:
+            case BinaryOperator.Modulo:
                 opStr = '%';
                 break;
-            case exports.BinaryOperator.Lower:
+            case BinaryOperator.Lower:
                 opStr = '<';
                 break;
-            case exports.BinaryOperator.LowerEquals:
+            case BinaryOperator.LowerEquals:
                 opStr = '<=';
                 break;
-            case exports.BinaryOperator.Bigger:
+            case BinaryOperator.Bigger:
                 opStr = '>';
                 break;
-            case exports.BinaryOperator.BiggerEquals:
+            case BinaryOperator.BiggerEquals:
                 opStr = '>=';
                 break;
-            case exports.BinaryOperator.NullishCoalesce:
+            case BinaryOperator.NullishCoalesce:
                 opStr = '??';
                 break;
             default:
@@ -3739,11 +3736,11 @@ function devOnlyGuardedExpression(expr) {
 }
 function guardedExpression(guard, expr) {
     const guardExpr = new ExternalExpr({ name: guard, moduleName: null });
-    const guardNotDefined = new BinaryOperatorExpr(exports.BinaryOperator.Identical, new TypeofExpr(guardExpr), literal$1('undefined'));
-    const guardUndefinedOrTrue = new BinaryOperatorExpr(exports.BinaryOperator.Or, guardNotDefined, guardExpr, 
+    const guardNotDefined = new BinaryOperatorExpr(BinaryOperator.Identical, new TypeofExpr(guardExpr), literal$1('undefined'));
+    const guardUndefinedOrTrue = new BinaryOperatorExpr(BinaryOperator.Or, guardNotDefined, guardExpr, 
     /* type */ undefined, 
     /* sourceSpan */ undefined, true);
-    return new BinaryOperatorExpr(exports.BinaryOperator.And, guardUndefinedOrTrue, expr);
+    return new BinaryOperatorExpr(BinaryOperator.And, guardUndefinedOrTrue, expr);
 }
 function wrapReference(value) {
     const wrapped = new WrappedNodeExpr(value);
@@ -3812,7 +3809,7 @@ function compileFactoryFunction(meta) {
     // delegated factory (which is used to create the current type) then this is only the type-to-
     // create parameter (t).
     const typeForCtor = !isDelegatedFactoryMetadata(meta)
-        ? new BinaryOperatorExpr(exports.BinaryOperator.Or, t, meta.type.value)
+        ? new BinaryOperatorExpr(BinaryOperator.Or, t, meta.type.value)
         : t;
     let ctorExpr = null;
     if (meta.deps !== null) {
@@ -3860,7 +3857,7 @@ function compileFactoryFunction(meta) {
         // This factory uses a base factory, so call `ɵɵgetInheritedFactory()` to compute it.
         const getInheritedFactoryCall = importExpr(Identifiers.getInheritedFactory).callFn([meta.type.value]);
         // Memoize the base factoryFn: `baseFactory || (baseFactory = ɵɵgetInheritedFactory(...))`
-        const baseFactory = new BinaryOperatorExpr(exports.BinaryOperator.Or, baseFactoryVar, baseFactoryVar.set(getInheritedFactoryCall));
+        const baseFactory = new BinaryOperatorExpr(BinaryOperator.Or, baseFactoryVar, baseFactoryVar.set(getInheritedFactoryCall));
         body.push(new ReturnStatement(baseFactory.callFn([typeForCtor])));
     }
     else {
@@ -11518,7 +11515,7 @@ function generateConditionalExpressions(job) {
                 }
                 if (tmp !== null) {
                     const useTmp = i === 0 ? tmp : new ReadTemporaryExpr(tmp.xref);
-                    conditionalCase.expr = new BinaryOperatorExpr(exports.BinaryOperator.Identical, useTmp, conditionalCase.expr);
+                    conditionalCase.expr = new BinaryOperatorExpr(BinaryOperator.Identical, useTmp, conditionalCase.expr);
                 }
                 else if (conditionalCase.alias !== null) {
                     const caseExpressionTemporaryXref = job.allocateXrefId();
@@ -11537,24 +11534,24 @@ function generateConditionalExpressions(job) {
 }
 
 const BINARY_OPERATORS$3 = new Map([
-    ['&&', exports.BinaryOperator.And],
-    ['>', exports.BinaryOperator.Bigger],
-    ['>=', exports.BinaryOperator.BiggerEquals],
-    ['|', exports.BinaryOperator.BitwiseOr],
-    ['&', exports.BinaryOperator.BitwiseAnd],
-    ['/', exports.BinaryOperator.Divide],
-    ['==', exports.BinaryOperator.Equals],
-    ['===', exports.BinaryOperator.Identical],
-    ['<', exports.BinaryOperator.Lower],
-    ['<=', exports.BinaryOperator.LowerEquals],
-    ['-', exports.BinaryOperator.Minus],
-    ['%', exports.BinaryOperator.Modulo],
-    ['*', exports.BinaryOperator.Multiply],
-    ['!=', exports.BinaryOperator.NotEquals],
-    ['!==', exports.BinaryOperator.NotIdentical],
-    ['??', exports.BinaryOperator.NullishCoalesce],
-    ['||', exports.BinaryOperator.Or],
-    ['+', exports.BinaryOperator.Plus],
+    ['&&', BinaryOperator.And],
+    ['>', BinaryOperator.Bigger],
+    ['>=', BinaryOperator.BiggerEquals],
+    ['|', BinaryOperator.BitwiseOr],
+    ['&', BinaryOperator.BitwiseAnd],
+    ['/', BinaryOperator.Divide],
+    ['==', BinaryOperator.Equals],
+    ['===', BinaryOperator.Identical],
+    ['<', BinaryOperator.Lower],
+    ['<=', BinaryOperator.LowerEquals],
+    ['-', BinaryOperator.Minus],
+    ['%', BinaryOperator.Modulo],
+    ['*', BinaryOperator.Multiply],
+    ['!=', BinaryOperator.NotEquals],
+    ['!==', BinaryOperator.NotIdentical],
+    ['??', BinaryOperator.NullishCoalesce],
+    ['||', BinaryOperator.Or],
+    ['+', BinaryOperator.Plus],
 ]);
 function namespaceForKey(namespacePrefixKey) {
     const NAMESPACES = new Map([
@@ -12330,7 +12327,7 @@ function ternaryTransform(e) {
     if (!(e instanceof SafeTernaryExpr)) {
         return e;
     }
-    return new ConditionalExpr(new BinaryOperatorExpr(exports.BinaryOperator.Equals, e.guard, NULL_EXPR), NULL_EXPR, e.expr);
+    return new ConditionalExpr(new BinaryOperatorExpr(BinaryOperator.Equals, e.guard, NULL_EXPR), NULL_EXPR, e.expr);
 }
 
 /**
@@ -21524,14 +21521,14 @@ function generateNullishCoalesceExpressions(job) {
         for (const op of unit.ops()) {
             transformExpressionsInOp(op, (expr) => {
                 if (!(expr instanceof BinaryOperatorExpr) ||
-                    expr.operator !== exports.BinaryOperator.NullishCoalesce) {
+                    expr.operator !== BinaryOperator.NullishCoalesce) {
                     return expr;
                 }
                 const assignment = new AssignTemporaryExpr(expr.lhs.clone(), job.allocateXrefId());
                 const read = new ReadTemporaryExpr(assignment.xref);
                 // TODO: When not in compatibility mode for TemplateDefinitionBuilder, we can just emit
                 // `t != null` instead of including an undefined check as well.
-                return new ConditionalExpr(new BinaryOperatorExpr(exports.BinaryOperator.And, new BinaryOperatorExpr(exports.BinaryOperator.NotIdentical, assignment, NULL_EXPR), new BinaryOperatorExpr(exports.BinaryOperator.NotIdentical, read, new LiteralExpr(undefined))), read.clone(), expr.rhs);
+                return new ConditionalExpr(new BinaryOperatorExpr(BinaryOperator.And, new BinaryOperatorExpr(BinaryOperator.NotIdentical, assignment, NULL_EXPR), new BinaryOperatorExpr(BinaryOperator.NotIdentical, read, new LiteralExpr(undefined))), read.clone(), expr.rhs);
             }, VisitorContextFlag.None);
         }
     }
@@ -24862,7 +24859,7 @@ function maybeGenerateRfBlock(flag, statements) {
         return [];
     }
     return [
-        ifStmt(new BinaryOperatorExpr(exports.BinaryOperator.BitwiseAnd, variable('rf'), literal$1(flag)), statements),
+        ifStmt(new BinaryOperatorExpr(BinaryOperator.BitwiseAnd, variable('rf'), literal$1(flag)), statements),
     ];
 }
 function emitHostBindingFunction(job) {
@@ -25483,9 +25480,9 @@ function convertAst(ast, job, baseSourceSpan) {
     else if (ast instanceof Unary) {
         switch (ast.operator) {
             case '+':
-                return new UnaryOperatorExpr(exports.UnaryOperator.Plus, convertAst(ast.expr, job, baseSourceSpan), undefined, convertSourceSpan(ast.span, baseSourceSpan));
+                return new UnaryOperatorExpr(UnaryOperator.Plus, convertAst(ast.expr, job, baseSourceSpan), undefined, convertSourceSpan(ast.span, baseSourceSpan));
             case '-':
-                return new UnaryOperatorExpr(exports.UnaryOperator.Minus, convertAst(ast.expr, job, baseSourceSpan), undefined, convertSourceSpan(ast.span, baseSourceSpan));
+                return new UnaryOperatorExpr(UnaryOperator.Minus, convertAst(ast.expr, job, baseSourceSpan), undefined, convertSourceSpan(ast.span, baseSourceSpan));
             default:
                 throw new Error(`AssertionError: unknown unary operator ${ast.operator}`);
         }
@@ -25879,15 +25876,16 @@ function convertSourceSpan(span, baseSourceSpan) {
  *    workaround, because it'll include an additional text node as the first child. We can work
  *    around it here, but in a discussion it was decided not to, because the user explicitly opted
  *    into preserving the whitespace and we would have to drop it from the generated code.
- *    The diagnostic mentioned point #1 will flag such cases to users.
+ *    The diagnostic mentioned point in #1 will flag such cases to users.
  *
  * @returns Tag name to be used for the control flow template.
  */
 function ingestControlFlowInsertionPoint(unit, xref, node) {
     let root = null;
     for (const child of node.children) {
-        // Skip over comment nodes.
-        if (child instanceof Comment$1) {
+        // Skip over comment nodes and @let declarations since
+        // it doesn't matter where they end up in the DOM.
+        if (child instanceof Comment$1 || child instanceof LetDeclaration$1) {
             continue;
         }
         // We can only infer the tag name/attributes if there's a single root node.
@@ -25898,6 +25896,9 @@ function ingestControlFlowInsertionPoint(unit, xref, node) {
         if (child instanceof Element$1 || (child instanceof Template && child.tagName !== null)) {
             root = child;
         }
+        else {
+            return null;
+        }
     }
     // If we've found a single root node, its tag name and attributes can be
     // copied to the surrounding template to be used for content projection.
@@ -30277,7 +30278,7 @@ function publishFacade(global) {
  * @description
  * Entry point for all public APIs of the compiler package.
  */
-new Version('19.0.0-rc.0');
+new Version('19.0.0-rc.2');
 
 const _I18N_ATTR = 'i18n';
 const _I18N_ATTR_PREFIX = 'i18n-';
@@ -31685,7 +31686,7 @@ class NodeJSPathManipulation {
 // G3-ESM-MARKER: G3 uses CommonJS, but externally everything in ESM.
 // CommonJS/ESM interop for determining the current file name and containing dir.
 const isCommonJS = typeof __filename !== 'undefined';
-const currentFileUrl = isCommonJS ? null : (typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.src || new URL('checker-2451e7c5.js', document.baseURI).href));
+const currentFileUrl = isCommonJS ? null : (typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.tagName.toUpperCase() === 'SCRIPT' && document.currentScript.src || new URL('checker-cd95ebda.js', document.baseURI).href));
 const currentFileName = isCommonJS ? __filename : url.fileURLToPath(currentFileUrl);
 /**
  * A wrapper around the Node.js file-system that supports readonly operations and path manipulation.
@@ -31951,6 +31952,11 @@ exports.ImportFlags = void 0;
      */
     ImportFlags[ImportFlags["AllowAmbientReferences"] = 16] = "AllowAmbientReferences";
 })(exports.ImportFlags || (exports.ImportFlags = {}));
+exports.ReferenceEmitKind = void 0;
+(function (ReferenceEmitKind) {
+    ReferenceEmitKind[ReferenceEmitKind["Success"] = 0] = "Success";
+    ReferenceEmitKind[ReferenceEmitKind["Failed"] = 1] = "Failed";
+})(exports.ReferenceEmitKind || (exports.ReferenceEmitKind = {}));
 /**
  * Verifies that a reference was emitted successfully, or raises a `FatalDiagnosticError` otherwise.
  * @param result The emit result that should have been successful.
@@ -31959,7 +31965,7 @@ exports.ImportFlags = void 0;
  *     'class'.
  */
 function assertSuccessfulReferenceEmit(result, origin, typeKind) {
-    if (result.kind === 0 /* ReferenceEmitKind.Success */) {
+    if (result.kind === exports.ReferenceEmitKind.Success) {
         return;
     }
     const message = makeDiagnosticChain(`Unable to import ${typeKind} ${nodeNameForError(result.ref.node)}.`, [makeDiagnosticChain(result.reason)]);
@@ -31986,7 +31992,7 @@ class ReferenceEmitter {
             }
         }
         return {
-            kind: 1 /* ReferenceEmitKind.Failed */,
+            kind: exports.ReferenceEmitKind.Failed,
             ref,
             context,
             reason: `Unable to write a reference to ${nodeNameForError(ref.node)}.`,
@@ -32012,7 +32018,7 @@ class LocalIdentifierStrategy {
         // invalid emission of a free-standing `foo` identifier, rather than `exports.foo`.
         if (!isDeclaration(ref.node) && refSf === context) {
             return {
-                kind: 0 /* ReferenceEmitKind.Success */,
+                kind: exports.ReferenceEmitKind.Success,
                 expression: new WrappedNodeExpr(ref.node),
                 importedFile: null,
             };
@@ -32022,7 +32028,7 @@ class LocalIdentifierStrategy {
             const identifier = identifierOfNode(ref.node);
             if (identifier !== null) {
                 return {
-                    kind: 0 /* ReferenceEmitKind.Success */,
+                    kind: exports.ReferenceEmitKind.Success,
                     expression: new WrappedNodeExpr(identifier),
                     importedFile: null,
                 };
@@ -32036,7 +32042,7 @@ class LocalIdentifierStrategy {
         const identifier = ref.getIdentityIn(context);
         if (identifier !== null) {
             return {
-                kind: 0 /* ReferenceEmitKind.Success */,
+                kind: exports.ReferenceEmitKind.Success,
                 expression: new WrappedNodeExpr(identifier),
                 importedFile: null,
             };
@@ -32089,7 +32095,7 @@ class AbsoluteModuleStrategy {
         const exports$1 = this.getExportsOfModule(specifier, resolutionContext);
         if (exports$1.module === null) {
             return {
-                kind: 1 /* ReferenceEmitKind.Failed */,
+                kind: exports.ReferenceEmitKind.Failed,
                 ref,
                 context,
                 reason: `The module '${specifier}' could not be found.`,
@@ -32097,7 +32103,7 @@ class AbsoluteModuleStrategy {
         }
         else if (exports$1.exportMap === null || !exports$1.exportMap.has(ref.node)) {
             return {
-                kind: 1 /* ReferenceEmitKind.Failed */,
+                kind: exports.ReferenceEmitKind.Failed,
                 ref,
                 context,
                 reason: `The symbol is not exported from ${exports$1.module.fileName} (module '${specifier}').`,
@@ -32105,7 +32111,7 @@ class AbsoluteModuleStrategy {
         }
         const symbolName = exports$1.exportMap.get(ref.node);
         return {
-            kind: 0 /* ReferenceEmitKind.Success */,
+            kind: exports.ReferenceEmitKind.Success,
             expression: new ExternalExpr(new ExternalReference(specifier, symbolName)),
             importedFile: exports$1.module,
         };
@@ -32176,7 +32182,7 @@ class LogicalProjectStrategy {
             // Note: this error is analogous to `TS6059: File is not under 'rootDir'` that TypeScript
             // reports.
             return {
-                kind: 1 /* ReferenceEmitKind.Failed */,
+                kind: exports.ReferenceEmitKind.Failed,
                 ref,
                 context,
                 reason: `The file ${destSf.fileName} is outside of the configured 'rootDir'.`,
@@ -32194,7 +32200,7 @@ class LogicalProjectStrategy {
         if (name === null) {
             // The target declaration isn't exported from the file it's declared in. This is an issue!
             return {
-                kind: 1 /* ReferenceEmitKind.Failed */,
+                kind: exports.ReferenceEmitKind.Failed,
                 ref,
                 context,
                 reason: `The symbol is not exported from ${destSf.fileName}.`,
@@ -32204,7 +32210,7 @@ class LogicalProjectStrategy {
         // path is now straightforward.
         const moduleName = LogicalProjectPath.relativePathBetween(originPath, destPath);
         return {
-            kind: 0 /* ReferenceEmitKind.Success */,
+            kind: exports.ReferenceEmitKind.Success,
             expression: new ExternalExpr({ moduleName, name }),
             importedFile: destSf,
         };
@@ -32228,14 +32234,14 @@ class RelativePathStrategy {
         const name = findExportedNameOfNode(ref.node, destSf, this.reflector);
         if (name === null) {
             return {
-                kind: 1 /* ReferenceEmitKind.Failed */,
+                kind: exports.ReferenceEmitKind.Failed,
                 ref,
                 context,
                 reason: `The symbol is not exported from ${destSf.fileName}.`,
             };
         }
         return {
-            kind: 0 /* ReferenceEmitKind.Success */,
+            kind: exports.ReferenceEmitKind.Success,
             expression: new ExternalExpr({ moduleName, name }),
             importedFile: destSf,
         };
@@ -32260,7 +32266,7 @@ class UnifiedModulesStrategy {
         }
         const moduleName = this.unifiedModulesHost.fileNameToModuleName(destSf.fileName, context.fileName);
         return {
-            kind: 0 /* ReferenceEmitKind.Success */,
+            kind: exports.ReferenceEmitKind.Success,
             expression: new ExternalExpr({ moduleName, name }),
             importedFile: destSf,
         };
@@ -33176,10 +33182,16 @@ class TypeScriptReflectionHost {
             : null;
     }
 }
+class TypeEntityToDeclarationError extends Error {
+}
+/**
+ * @throws {TypeEntityToDeclarationError} if the type cannot be converted
+ *   to a declaration.
+ */
 function reflectTypeEntityToDeclaration(type, checker) {
     let realSymbol = checker.getSymbolAtLocation(type);
     if (realSymbol === undefined) {
-        throw new Error(`Cannot resolve type entity ${type.getText()} to symbol`);
+        throw new TypeEntityToDeclarationError(`Cannot resolve type entity ${type.getText()} to symbol`);
     }
     while (realSymbol.flags & ts__default["default"].SymbolFlags.Alias) {
         realSymbol = checker.getAliasedSymbol(realSymbol);
@@ -33192,24 +33204,24 @@ function reflectTypeEntityToDeclaration(type, checker) {
         node = realSymbol.declarations[0];
     }
     else {
-        throw new Error(`Cannot resolve type entity symbol to declaration`);
+        throw new TypeEntityToDeclarationError(`Cannot resolve type entity symbol to declaration`);
     }
     if (ts__default["default"].isQualifiedName(type)) {
         if (!ts__default["default"].isIdentifier(type.left)) {
-            throw new Error(`Cannot handle qualified name with non-identifier lhs`);
+            throw new TypeEntityToDeclarationError(`Cannot handle qualified name with non-identifier lhs`);
         }
         const symbol = checker.getSymbolAtLocation(type.left);
         if (symbol === undefined ||
             symbol.declarations === undefined ||
             symbol.declarations.length !== 1) {
-            throw new Error(`Cannot resolve qualified type entity lhs to symbol`);
+            throw new TypeEntityToDeclarationError(`Cannot resolve qualified type entity lhs to symbol`);
         }
         const decl = symbol.declarations[0];
         if (ts__default["default"].isNamespaceImport(decl)) {
             const clause = decl.parent;
             const importDecl = clause.parent;
             if (!ts__default["default"].isStringLiteral(importDecl.moduleSpecifier)) {
-                throw new Error(`Module specifier is not a string`);
+                throw new TypeEntityToDeclarationError(`Module specifier is not a string`);
             }
             return { node, from: importDecl.moduleSpecifier.text };
         }
@@ -33217,7 +33229,7 @@ function reflectTypeEntityToDeclaration(type, checker) {
             return { node, from: null };
         }
         else {
-            throw new Error(`Unknown import type?`);
+            throw new TypeEntityToDeclarationError(`Unknown import type?`);
         }
     }
     else {
@@ -33953,18 +33965,43 @@ exports.MatchSource = void 0;
 
 function extractReferencesFromType(checker, def, bestGuessOwningModule) {
     if (!ts__default["default"].isTupleTypeNode(def)) {
-        return [];
+        return { result: [], isIncomplete: false };
     }
-    return def.elements.map((element) => {
+    const result = [];
+    let isIncomplete = false;
+    for (const element of def.elements) {
         if (!ts__default["default"].isTypeQueryNode(element)) {
             throw new Error(`Expected TypeQueryNode: ${nodeDebugInfo(element)}`);
         }
-        return extraReferenceFromTypeQuery(checker, element, def, bestGuessOwningModule);
-    });
+        const ref = extraReferenceFromTypeQuery(checker, element, def, bestGuessOwningModule);
+        // Note: Sometimes a reference inside the type tuple/array
+        // may not be resolvable/existent. We proceed with incomplete data.
+        if (ref === null) {
+            isIncomplete = true;
+        }
+        else {
+            result.push(ref);
+        }
+    }
+    return { result, isIncomplete };
 }
 function extraReferenceFromTypeQuery(checker, typeNode, origin, bestGuessOwningModule) {
     const type = typeNode.exprName;
-    const { node, from } = reflectTypeEntityToDeclaration(type, checker);
+    let node;
+    let from;
+    // Gracefully handle when the type entity could not be converted or
+    // resolved to its declaration node.
+    try {
+        const result = reflectTypeEntityToDeclaration(type, checker);
+        node = result.node;
+        from = result.from;
+    }
+    catch (e) {
+        if (e instanceof TypeEntityToDeclarationError) {
+            return null;
+        }
+        throw e;
+    }
     if (!isNamedClassDeclaration(node)) {
         throw new Error(`Expected named ClassDeclaration: ${nodeDebugInfo(node)}`);
     }
@@ -36094,28 +36131,28 @@ function createImportReference(asTypeReference, ref) {
 }
 
 const UNARY_OPERATORS$1 = new Map([
-    [exports.UnaryOperator.Minus, '-'],
-    [exports.UnaryOperator.Plus, '+'],
+    [UnaryOperator.Minus, '-'],
+    [UnaryOperator.Plus, '+'],
 ]);
 const BINARY_OPERATORS$1 = new Map([
-    [exports.BinaryOperator.And, '&&'],
-    [exports.BinaryOperator.Bigger, '>'],
-    [exports.BinaryOperator.BiggerEquals, '>='],
-    [exports.BinaryOperator.BitwiseAnd, '&'],
-    [exports.BinaryOperator.BitwiseOr, '|'],
-    [exports.BinaryOperator.Divide, '/'],
-    [exports.BinaryOperator.Equals, '=='],
-    [exports.BinaryOperator.Identical, '==='],
-    [exports.BinaryOperator.Lower, '<'],
-    [exports.BinaryOperator.LowerEquals, '<='],
-    [exports.BinaryOperator.Minus, '-'],
-    [exports.BinaryOperator.Modulo, '%'],
-    [exports.BinaryOperator.Multiply, '*'],
-    [exports.BinaryOperator.NotEquals, '!='],
-    [exports.BinaryOperator.NotIdentical, '!=='],
-    [exports.BinaryOperator.Or, '||'],
-    [exports.BinaryOperator.Plus, '+'],
-    [exports.BinaryOperator.NullishCoalesce, '??'],
+    [BinaryOperator.And, '&&'],
+    [BinaryOperator.Bigger, '>'],
+    [BinaryOperator.BiggerEquals, '>='],
+    [BinaryOperator.BitwiseAnd, '&'],
+    [BinaryOperator.BitwiseOr, '|'],
+    [BinaryOperator.Divide, '/'],
+    [BinaryOperator.Equals, '=='],
+    [BinaryOperator.Identical, '==='],
+    [BinaryOperator.Lower, '<'],
+    [BinaryOperator.LowerEquals, '<='],
+    [BinaryOperator.Minus, '-'],
+    [BinaryOperator.Modulo, '%'],
+    [BinaryOperator.Multiply, '*'],
+    [BinaryOperator.NotEquals, '!='],
+    [BinaryOperator.NotIdentical, '!=='],
+    [BinaryOperator.Or, '||'],
+    [BinaryOperator.Plus, '+'],
+    [BinaryOperator.NullishCoalesce, '??'],
 ]);
 class ExpressionTranslatorVisitor {
     factory;
@@ -36328,7 +36365,7 @@ class ExpressionTranslatorVisitor {
     }
     visitBinaryOperatorExpr(ast, context) {
         if (!BINARY_OPERATORS$1.has(ast.operator)) {
-            throw new Error(`Unknown binary operator: ${exports.BinaryOperator[ast.operator]}`);
+            throw new Error(`Unknown binary operator: ${BinaryOperator[ast.operator]}`);
         }
         return this.factory.createBinaryExpression(ast.lhs.visitExpression(this, context), BINARY_OPERATORS$1.get(ast.operator), ast.rhs.visitExpression(this, context));
     }
@@ -36363,7 +36400,7 @@ class ExpressionTranslatorVisitor {
     }
     visitUnaryOperatorExpr(ast, context) {
         if (!UNARY_OPERATORS$1.has(ast.operator)) {
-            throw new Error(`Unknown unary operator: ${exports.UnaryOperator[ast.operator]}`);
+            throw new Error(`Unknown unary operator: ${UnaryOperator[ast.operator]}`);
         }
         return this.factory.createUnaryExpression(UNARY_OPERATORS$1.get(ast.operator), ast.expr.visitExpression(this, context));
     }
@@ -38580,27 +38617,6 @@ class Mappings {
 		let charInHiresBoundary = false;
 
 		while (originalCharIndex < chunk.end) {
-			if (this.hires || first || sourcemapLocations.has(originalCharIndex)) {
-				const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
-
-				if (this.hires === 'boundary') {
-					// in hires "boundary", group segments per word boundary than per char
-					if (wordRegex.test(original[originalCharIndex])) {
-						// for first char in the boundary found, start the boundary by pushing a segment
-						if (!charInHiresBoundary) {
-							this.rawSegments.push(segment);
-							charInHiresBoundary = true;
-						}
-					} else {
-						// for non-word char, end the boundary by pushing a segment
-						this.rawSegments.push(segment);
-						charInHiresBoundary = false;
-					}
-				} else {
-					this.rawSegments.push(segment);
-				}
-			}
-
 			if (original[originalCharIndex] === '\n') {
 				loc.line += 1;
 				loc.column = 0;
@@ -38609,6 +38625,27 @@ class Mappings {
 				this.generatedCodeColumn = 0;
 				first = true;
 			} else {
+				if (this.hires || first || sourcemapLocations.has(originalCharIndex)) {
+					const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
+
+					if (this.hires === 'boundary') {
+						// in hires "boundary", group segments per word boundary than per char
+						if (wordRegex.test(original[originalCharIndex])) {
+							// for first char in the boundary found, start the boundary by pushing a segment
+							if (!charInHiresBoundary) {
+								this.rawSegments.push(segment);
+								charInHiresBoundary = true;
+							}
+						} else {
+							// for non-word char, end the boundary by pushing a segment
+							this.rawSegments.push(segment);
+							charInHiresBoundary = false;
+						}
+					} else {
+						this.rawSegments.push(segment);
+					}
+				}
+
 				loc.column += 1;
 				this.generatedCodeColumn += 1;
 				first = false;
@@ -39555,7 +39592,7 @@ class ReferenceEmitEnvironment {
         exports.ImportFlags.AllowTypeImports |
         exports.ImportFlags.AllowRelativeDtsImports) {
         const result = this.refEmitter.emit(ref, this.contextFile, flags);
-        return result.kind === 0 /* ReferenceEmitKind.Success */;
+        return result.kind === exports.ReferenceEmitKind.Success;
     }
     /**
      * Generate a `ts.TypeNode` that references the given node as a type.
@@ -44956,7 +44993,7 @@ class TemplateTypeCheckerImpl {
         this.perf = perf;
     }
     getTemplate(component, optimizeFor) {
-        const { data } = this.getLatestComponentState(component);
+        const { data } = this.getLatestComponentState(component, optimizeFor);
         if (data === null) {
             return null;
         }
@@ -45461,7 +45498,7 @@ class TemplateTypeCheckerImpl {
     }
     emit(kind, refTo, inContext) {
         const emittedRef = this.refEmitter.emit(refTo, inContext.getSourceFile());
-        if (emittedRef.kind === 1 /* ReferenceEmitKind.Failed */) {
+        if (emittedRef.kind === exports.ReferenceEmitKind.Failed) {
             return null;
         }
         const emitted = emittedRef.expression;
@@ -45708,16 +45745,13 @@ class SingleShimTypeCheckingHost extends SingleFileTypeCheckingHost {
 exports.AST = AST;
 exports.ASTWithSource = ASTWithSource;
 exports.AbsoluteModuleStrategy = AbsoluteModuleStrategy;
-exports.AbsoluteSourceSpan = AbsoluteSourceSpan;
 exports.AmbientImport = AmbientImport;
 exports.ArrowFunctionExpr = ArrowFunctionExpr;
 exports.Binary = Binary;
-exports.BindingPipe = BindingPipe;
 exports.BlockPlaceholder = BlockPlaceholder;
 exports.BoundAttribute = BoundAttribute;
 exports.BoundDeferredTrigger = BoundDeferredTrigger;
 exports.BoundEvent = BoundEvent;
-exports.BoundText = BoundText;
 exports.COMPILER_ERRORS_WITH_GUIDES = COMPILER_ERRORS_WITH_GUIDES;
 exports.CR = CR;
 exports.CUSTOM_ELEMENTS_SCHEMA = CUSTOM_ELEMENTS_SCHEMA;
@@ -45728,36 +45762,29 @@ exports.CompoundMetadataReader = CompoundMetadataReader;
 exports.Conditional = Conditional;
 exports.ConstantPool = ConstantPool;
 exports.Container = Container;
-exports.Content = Content;
 exports.CssSelector = CssSelector;
 exports.DEFAULT_INTERPOLATION_CONFIG = DEFAULT_INTERPOLATION_CONFIG;
 exports.DYNAMIC_TYPE = DYNAMIC_TYPE;
 exports.Declaration = Declaration;
 exports.DeclareFunctionStmt = DeclareFunctionStmt;
 exports.DefaultImportTracker = DefaultImportTracker;
-exports.DeferredBlock = DeferredBlock;
 exports.DefinitionMap = DefinitionMap;
 exports.DomElementSchemaRegistry = DomElementSchemaRegistry;
 exports.DynamicImportExpr = DynamicImportExpr;
 exports.DynamicValue = DynamicValue;
 exports.Element = Element;
 exports.Element$1 = Element$1;
-exports.EmptyExpr = EmptyExpr$1;
 exports.EnumValue = EnumValue;
 exports.ExternalExpr = ExternalExpr;
 exports.FatalDiagnosticError = FatalDiagnosticError;
 exports.FnParam = FnParam;
-exports.ForLoopBlock = ForLoopBlock;
 exports.FunctionExpr = FunctionExpr;
 exports.HtmlParser = HtmlParser;
 exports.I18nError = I18nError;
 exports.INPUT_INITIALIZER_FN = INPUT_INITIALIZER_FN;
 exports.Icu = Icu;
-exports.Icu$1 = Icu$1;
 exports.IcuPlaceholder = IcuPlaceholder;
 exports.Identifiers = Identifiers;
-exports.IfBlock = IfBlock;
-exports.IfBlockBranch = IfBlockBranch;
 exports.ImplicitReceiver = ImplicitReceiver;
 exports.ImportManager = ImportManager;
 exports.Interpolation = Interpolation$1;
@@ -45802,7 +45829,6 @@ exports.SafePropertyRead = SafePropertyRead;
 exports.SelectorMatcher = SelectorMatcher;
 exports.Serializer = Serializer;
 exports.StaticInterpreter = StaticInterpreter;
-exports.SwitchBlock = SwitchBlock;
 exports.SyntheticValue = SyntheticValue;
 exports.Tag = Tag;
 exports.TagPlaceholder = TagPlaceholder;
@@ -45811,11 +45837,9 @@ exports.TemplateTypeCheckerImpl = TemplateTypeCheckerImpl;
 exports.Text = Text;
 exports.Text$1 = Text$1;
 exports.Text$2 = Text$2;
-exports.Text$3 = Text$3;
 exports.TextAttribute = TextAttribute;
 exports.ThisReceiver = ThisReceiver;
 exports.Trait = Trait;
-exports.TransplantedType = TransplantedType;
 exports.TypeCheckShimGenerator = TypeCheckShimGenerator;
 exports.TypeScriptReflectionHost = TypeScriptReflectionHost;
 exports.UNSAFE_OBJECT_KEY_NAME_REGEXP = UNSAFE_OBJECT_KEY_NAME_REGEXP;
@@ -45844,7 +45868,6 @@ exports.conditionallyCreateDirectiveBindingLiteral = conditionallyCreateDirectiv
 exports.convertFromMaybeForwardRefExpression = convertFromMaybeForwardRefExpression;
 exports.copyFileShimData = copyFileShimData;
 exports.createComponentType = createComponentType;
-exports.createCssSelectorFromNode = createCssSelectorFromNode;
 exports.createDirectiveType = createDirectiveType;
 exports.createFactoryType = createFactoryType;
 exports.createHostDirectivesMappingArray = createHostDirectivesMappingArray;
@@ -45880,7 +45903,6 @@ exports.getSourceFileOrNull = getSourceFileOrNull;
 exports.getTemplateDiagnostics = getTemplateDiagnostics;
 exports.hasInjectableFields = hasInjectableFields;
 exports.identifierOfNode = identifierOfNode;
-exports.ifStmt = ifStmt;
 exports.importExpr = importExpr;
 exports.isAbstractClassDeclaration = isAbstractClassDeclaration;
 exports.isAliasImportDeclaration = isAliasImportDeclaration;