@angular-eslint/bundled-angular-compiler 17.2.1-alpha.4 → 17.2.1-alpha.5

package/dist/index.js

@@ -1,7 +1,7 @@
 'use strict';
 
 /**
- * @license Angular v17.0.8
+ * @license Angular v17.1.0
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -411,6 +411,13 @@ exports.ChangeDetectionStrategy = void 0;
     ChangeDetectionStrategy[ChangeDetectionStrategy["OnPush"] = 0] = "OnPush";
     ChangeDetectionStrategy[ChangeDetectionStrategy["Default"] = 1] = "Default";
 })(exports.ChangeDetectionStrategy || (exports.ChangeDetectionStrategy = {}));
+/** Flags describing an input for a directive. */
+var InputFlags;
+(function (InputFlags) {
+    InputFlags[InputFlags["None"] = 0] = "None";
+    InputFlags[InputFlags["SignalBased"] = 1] = "SignalBased";
+    InputFlags[InputFlags["HasDecoratorInputTransform"] = 2] = "HasDecoratorInputTransform";
+})(InputFlags || (InputFlags = {}));
 const CUSTOM_ELEMENTS_SCHEMA = {
     name: 'custom-elements'
 };
@@ -474,6 +481,7 @@ var core = /*#__PURE__*/Object.freeze({
     emitDistinctChangesOnlyDefaultValue: emitDistinctChangesOnlyDefaultValue,
     get ViewEncapsulation () { return exports.ViewEncapsulation; },
     get ChangeDetectionStrategy () { return exports.ChangeDetectionStrategy; },
+    get InputFlags () { return InputFlags; },
     CUSTOM_ELEMENTS_SCHEMA: CUSTOM_ELEMENTS_SCHEMA,
     NO_ERRORS_SCHEMA: NO_ERRORS_SCHEMA,
     Type: Type$1,
@@ -892,12 +900,13 @@ exports.BinaryOperator = void 0;
     BinaryOperator[BinaryOperator["Modulo"] = 8] = "Modulo";
     BinaryOperator[BinaryOperator["And"] = 9] = "And";
     BinaryOperator[BinaryOperator["Or"] = 10] = "Or";
-    BinaryOperator[BinaryOperator["BitwiseAnd"] = 11] = "BitwiseAnd";
-    BinaryOperator[BinaryOperator["Lower"] = 12] = "Lower";
-    BinaryOperator[BinaryOperator["LowerEquals"] = 13] = "LowerEquals";
-    BinaryOperator[BinaryOperator["Bigger"] = 14] = "Bigger";
-    BinaryOperator[BinaryOperator["BiggerEquals"] = 15] = "BiggerEquals";
-    BinaryOperator[BinaryOperator["NullishCoalesce"] = 16] = "NullishCoalesce";
+    BinaryOperator[BinaryOperator["BitwiseOr"] = 11] = "BitwiseOr";
+    BinaryOperator[BinaryOperator["BitwiseAnd"] = 12] = "BitwiseAnd";
+    BinaryOperator[BinaryOperator["Lower"] = 13] = "Lower";
+    BinaryOperator[BinaryOperator["LowerEquals"] = 14] = "LowerEquals";
+    BinaryOperator[BinaryOperator["Bigger"] = 15] = "Bigger";
+    BinaryOperator[BinaryOperator["BiggerEquals"] = 16] = "BiggerEquals";
+    BinaryOperator[BinaryOperator["NullishCoalesce"] = 17] = "NullishCoalesce";
 })(exports.BinaryOperator || (exports.BinaryOperator = {}));
 function nullSafeIsEquivalent(base, other) {
     if (base == null || other == null) {
@@ -970,6 +979,9 @@ class Expression {
     and(rhs, sourceSpan) {
         return new BinaryOperatorExpr(exports.BinaryOperator.And, this, rhs, null, sourceSpan);
     }
+    bitwiseOr(rhs, sourceSpan, parens = true) {
+        return new BinaryOperatorExpr(exports.BinaryOperator.BitwiseOr, this, rhs, null, sourceSpan, parens);
+    }
     bitwiseAnd(rhs, sourceSpan, parens = true) {
         return new BinaryOperatorExpr(exports.BinaryOperator.BitwiseAnd, this, rhs, null, sourceSpan, parens);
     }
@@ -2630,6 +2642,10 @@ class Identifiers {
         name: 'ɵɵgetInheritedFactory',
         moduleName: CORE,
     }; }
+    static { this.InputFlags = {
+        name: 'ɵɵInputFlags',
+        moduleName: CORE,
+    }; }
     // sanitization-related functions
     static { this.sanitizeHtml = { name: 'ɵɵsanitizeHtml', moduleName: CORE }; }
     static { this.sanitizeStyle = { name: 'ɵɵsanitizeStyle', moduleName: CORE }; }
@@ -2640,6 +2656,9 @@ class Identifiers {
     static { this.trustConstantHtml = { name: 'ɵɵtrustConstantHtml', moduleName: CORE }; }
     static { this.trustConstantResourceUrl = { name: 'ɵɵtrustConstantResourceUrl', moduleName: CORE }; }
     static { this.validateIframeAttribute = { name: 'ɵɵvalidateIframeAttribute', moduleName: CORE }; }
+    // type-checking
+    static { this.InputSignalBrandWriteType = { name: 'ɵINPUT_SIGNAL_BRAND_WRITE_TYPE', moduleName: CORE }; }
+    static { this.UnwrapDirectiveSignalInputs = { name: 'ɵUnwrapDirectiveSignalInputs', moduleName: CORE }; }
 }
 
 const DASH_CASE_REGEXP = /-+([a-z0-9])/g;
@@ -3257,6 +3276,9 @@ class AbstractEmitterVisitor {
             case exports.BinaryOperator.And:
                 opStr = '&&';
                 break;
+            case exports.BinaryOperator.BitwiseOr:
+                opStr = '|';
+                break;
             case exports.BinaryOperator.BitwiseAnd:
                 opStr = '&';
                 break;
@@ -4955,7 +4977,13 @@ function asLiteral(value) {
     }
     return literal(value, INFERRED_TYPE);
 }
-function conditionallyCreateDirectiveBindingLiteral(map, keepDeclared) {
+/**
+ * Serializes inputs and outputs for `defineDirective` and `defineComponent`.
+ *
+ * This will attempt to generate optimized data structures to minimize memory or
+ * file size of fully compiled applications.
+ */
+function conditionallyCreateDirectiveBindingLiteral(map, forInputs) {
     const keys = Object.getOwnPropertyNames(map);
     if (keys.length === 0) {
         return null;
@@ -4977,12 +5005,28 @@ function conditionallyCreateDirectiveBindingLiteral(map, keepDeclared) {
             minifiedName = key;
             declaredName = value.classPropertyName;
             publicName = value.bindingPropertyName;
-            if (keepDeclared && (publicName !== declaredName || value.transformFunction != null)) {
-                const expressionKeys = [asLiteral(publicName), asLiteral(declaredName)];
-                if (value.transformFunction != null) {
-                    expressionKeys.push(value.transformFunction);
+            const differentDeclaringName = publicName !== declaredName;
+            const hasDecoratorInputTransform = value.transformFunction !== null;
+            // Build up input flags
+            let flags = null;
+            if (value.isSignal) {
+                flags = bitwiseOrInputFlagsExpr(InputFlags.SignalBased, flags);
+            }
+            if (hasDecoratorInputTransform) {
+                flags = bitwiseOrInputFlagsExpr(InputFlags.HasDecoratorInputTransform, flags);
+            }
+            // Inputs, compared to outputs, will track their declared name (for `ngOnChanges`), support
+            // decorator input transform functions, or store flag information if there is any.
+            if (forInputs && (differentDeclaringName || hasDecoratorInputTransform || flags !== null)) {
+                const flagsExpr = flags ?? importExpr(Identifiers.InputFlags).prop(InputFlags[InputFlags.None]);
+                const result = [flagsExpr, asLiteral(publicName)];
+                if (differentDeclaringName || hasDecoratorInputTransform) {
+                    result.push(asLiteral(declaredName));
+                    if (hasDecoratorInputTransform) {
+                        result.push(value.transformFunction);
+                    }
                 }
-                expressionValue = literalArr(expressionKeys);
+                expressionValue = literalArr(result);
             }
             else {
                 expressionValue = asLiteral(publicName);
@@ -4996,6 +5040,17 @@ function conditionallyCreateDirectiveBindingLiteral(map, keepDeclared) {
         };
     }));
 }
+/** Gets an output AST expression referencing the given flag. */
+function getInputFlagExpr(flag) {
+    return importExpr(Identifiers.InputFlags).prop(InputFlags[flag]);
+}
+/** Combines a given input flag with an existing flag expression, if present. */
+function bitwiseOrInputFlagsExpr(flag, expr) {
+    if (expr === null) {
+        return getInputFlagExpr(flag);
+    }
+    return getInputFlagExpr(flag).bitwiseOr(expr);
+}
 /**
  *  Remove trailing null nodes as they are implied.
  */
@@ -5281,10 +5336,10 @@ function createFactoryFunction(type) {
 }
 
 const UNUSABLE_INTERPOLATION_REGEXPS = [
-    /^\s*$/,
-    /[<>]/,
-    /^[{}]$/,
-    /&(#|[a-z])/i,
+    /^\s*$/, // empty
+    /[<>]/, // html tag
+    /^[{}]$/, // i18n expansion
+    /&(#|[a-z])/i, // character reference,
     /^\/\//, // comment
 ];
 function assertInterpolationSymbols(identifier, value) {
@@ -9209,16 +9264,6 @@ var DeferTriggerKind;
     DeferTriggerKind[DeferTriggerKind["Interaction"] = 4] = "Interaction";
     DeferTriggerKind[DeferTriggerKind["Viewport"] = 5] = "Viewport";
 })(DeferTriggerKind || (DeferTriggerKind = {}));
-/**
- * Repeaters implicitly define these derived variables, and child nodes may read them.
- */
-var DerivedRepeaterVarIdentity;
-(function (DerivedRepeaterVarIdentity) {
-    DerivedRepeaterVarIdentity[DerivedRepeaterVarIdentity["First"] = 0] = "First";
-    DerivedRepeaterVarIdentity[DerivedRepeaterVarIdentity["Last"] = 1] = "Last";
-    DerivedRepeaterVarIdentity[DerivedRepeaterVarIdentity["Even"] = 2] = "Even";
-    DerivedRepeaterVarIdentity[DerivedRepeaterVarIdentity["Odd"] = 3] = "Odd";
-})(DerivedRepeaterVarIdentity || (DerivedRepeaterVarIdentity = {}));
 /**
  * Kinds of i18n contexts. They can be created because of root i18n blocks, or ICUs.
  */
@@ -9419,10 +9464,11 @@ function createClassMapOp(xref, expression, sourceSpan) {
 /**
  * Create an `AttributeOp`.
  */
-function createAttributeOp(target, name, expression, securityContext, isTextAttribute, isStructuralTemplateAttribute, templateKind, i18nMessage, sourceSpan) {
+function createAttributeOp(target, namespace, name, expression, securityContext, isTextAttribute, isStructuralTemplateAttribute, templateKind, i18nMessage, sourceSpan) {
     return {
         kind: OpKind.Attribute,
         target,
+        namespace,
         name,
         expression,
         securityContext,
@@ -10044,26 +10090,6 @@ class SlotLiteralExpr extends ExpressionBase {
     }
     transformInternalExpressions() { }
 }
-class DerivedRepeaterVarExpr extends ExpressionBase {
-    constructor(xref, identity) {
-        super();
-        this.xref = xref;
-        this.identity = identity;
-        this.kind = ExpressionKind.DerivedRepeaterVar;
-    }
-    transformInternalExpressions(transform, flags) { }
-    visitExpression(visitor, context) { }
-    isEquivalent(e) {
-        return e instanceof DerivedRepeaterVarExpr && e.identity === this.identity &&
-            e.xref === this.xref;
-    }
-    isConstant() {
-        return false;
-    }
-    clone() {
-        return new DerivedRepeaterVarExpr(this.xref, this.identity);
-    }
-}
 class ConstCollectedExpr extends ExpressionBase {
     constructor(expr) {
         super();
@@ -10318,6 +10344,16 @@ function transformExpressionsInExpression(expr, transform, flags) {
         expr.template.expressions =
             expr.template.expressions.map(e => transformExpressionsInExpression(e, transform, flags));
     }
+    else if (expr instanceof ArrowFunctionExpr) {
+        if (Array.isArray(expr.body)) {
+            for (let i = 0; i < expr.body.length; i++) {
+                transformExpressionsInStatement(expr.body[i], transform, flags);
+            }
+        }
+        else {
+            expr.body = transformExpressionsInExpression(expr.body, transform, flags);
+        }
+    }
     else if (expr instanceof WrappedNodeExpr) ;
     else if (expr instanceof ReadVarExpr || expr instanceof ExternalExpr ||
         expr instanceof LiteralExpr) ;
@@ -10677,11 +10713,12 @@ function createProjectionDefOp(def) {
 /**
  * Create an `ExtractedAttributeOp`.
  */
-function createExtractedAttributeOp(target, bindingKind, name, expression, i18nContext, i18nMessage, securityContext) {
+function createExtractedAttributeOp(target, bindingKind, namespace, name, expression, i18nContext, i18nMessage, securityContext) {
     return {
         kind: OpKind.ExtractedAttribute,
         target,
         bindingKind,
+        namespace,
         name,
         expression,
         i18nContext,
@@ -10712,7 +10749,7 @@ function createI18nMessageOp(xref, i18nContext, i18nBlock, message, messagePlace
 /**
  * Create an `I18nStartOp`.
  */
-function createI18nStartOp(xref, message, root) {
+function createI18nStartOp(xref, message, root, sourceSpan) {
     return {
         kind: OpKind.I18nStart,
         xref,
@@ -10722,6 +10759,7 @@ function createI18nStartOp(xref, message, root) {
         messageIndex: null,
         subTemplateIndex: null,
         context: null,
+        sourceSpan,
         ...NEW_OP,
         ...TRAIT_CONSUMES_SLOT,
     };
@@ -10729,10 +10767,11 @@ function createI18nStartOp(xref, message, root) {
 /**
  * Create an `I18nEndOp`.
  */
-function createI18nEndOp(xref) {
+function createI18nEndOp(xref, sourceSpan) {
     return {
         kind: OpKind.I18nEnd,
         xref,
+        sourceSpan,
         ...NEW_OP,
     };
 }
@@ -11113,6 +11152,13 @@ function createOpXrefMap(unit) {
             continue;
         }
         map.set(op.xref, op);
+        // TODO(dylhunn): `@for` loops with `@empty` blocks need to be special-cased here,
+        // because the slot consumer trait currently only supports one slot per consumer and we
+        // need two. This should be revisited when making the refactors mentioned in:
+        // https://github.com/angular/angular/pull/53620#discussion_r1430918822
+        if (op.kind === OpKind.RepeaterCreate && op.emptyView !== null) {
+            map.set(op.emptyView, op);
+        }
     }
     return map;
 }
@@ -11145,7 +11191,8 @@ function extractAttributes(job) {
                         }
                         OpList.insertBefore(
                         // Deliberaly null i18nMessage value
-                        createExtractedAttributeOp(op.target, bindingKind, op.name, /* expression */ null, /* i18nContext */ null, 
+                        createExtractedAttributeOp(op.target, bindingKind, null, op.name, /* expression */ null, 
+                        /* i18nContext */ null, 
                         /* i18nMessage */ null, op.securityContext), lookupElement$2(elements, op.target));
                     }
                     break;
@@ -11157,17 +11204,22 @@ function extractAttributes(job) {
                     // mode.
                     if (unit.job.compatibility === CompatibilityMode.TemplateDefinitionBuilder &&
                         op.expression instanceof EmptyExpr) {
-                        OpList.insertBefore(createExtractedAttributeOp(op.target, BindingKind.Property, op.name, /* expression */ null, 
+                        OpList.insertBefore(createExtractedAttributeOp(op.target, BindingKind.Property, null, op.name, /* expression */ null, 
                         /* i18nContext */ null, 
                         /* i18nMessage */ null, SecurityContext.STYLE), lookupElement$2(elements, op.target));
                     }
                     break;
                 case OpKind.Listener:
                     if (!op.isAnimationListener) {
-                        const extractedAttributeOp = createExtractedAttributeOp(op.target, BindingKind.Property, op.name, /* expression */ null, 
+                        const extractedAttributeOp = createExtractedAttributeOp(op.target, BindingKind.Property, null, op.name, /* expression */ null, 
                         /* i18nContext */ null, 
                         /* i18nMessage */ null, SecurityContext.NONE);
                         if (job.kind === CompilationJobKind.Host) {
+                            if (job.compatibility) {
+                                // TemplateDefinitionBuilder does not extract listener bindings to the const array
+                                // (which is honestly pretty inconsistent).
+                                break;
+                            }
                             // This attribute will apply to the enclosing host binding compilation unit, so order
                             // doesn't matter.
                             unit.create.push(extractedAttributeOp);
@@ -11205,7 +11257,7 @@ function extractAttributeOp(unit, op, elements) {
         extractable &&= op.isTextAttribute;
     }
     if (extractable) {
-        const extractedAttributeOp = createExtractedAttributeOp(op.target, op.isStructuralTemplateAttribute ? BindingKind.Template : BindingKind.Attribute, op.name, op.expression, op.i18nContext, op.i18nMessage, op.securityContext);
+        const extractedAttributeOp = createExtractedAttributeOp(op.target, op.isStructuralTemplateAttribute ? BindingKind.Template : BindingKind.Attribute, op.namespace, op.name, op.expression, op.i18nContext, op.i18nMessage, op.securityContext);
         if (unit.job.kind === CompilationJobKind.Host) {
             // This attribute will apply to the enclosing host binding compilation unit, so order doesn't
             // matter.
@@ -11252,7 +11304,8 @@ function specializeBindings(job) {
                         target.nonBindable = true;
                     }
                     else {
-                        OpList.replace(op, createAttributeOp(op.target, op.name, op.expression, op.securityContext, op.isTextAttribute, op.isStructuralTemplateAttribute, op.templateKind, op.i18nMessage, op.sourceSpan));
+                        const [namespace, name] = splitNsName(op.name);
+                        OpList.replace(op, createAttributeOp(op.target, namespace, name, op.expression, op.securityContext, op.isTextAttribute, op.isStructuralTemplateAttribute, op.templateKind, op.i18nMessage, op.sourceSpan));
                     }
                     break;
                 case BindingKind.Property:
@@ -11442,6 +11495,7 @@ new Map([
     ['&&', exports.BinaryOperator.And],
     ['>', exports.BinaryOperator.Bigger],
     ['>=', exports.BinaryOperator.BiggerEquals],
+    ['|', exports.BinaryOperator.BitwiseOr],
     ['&', exports.BinaryOperator.BitwiseAnd],
     ['/', exports.BinaryOperator.Divide],
     ['==', exports.BinaryOperator.Equals],
@@ -11476,7 +11530,7 @@ function collectElementConsts(job) {
             if (op.kind === OpKind.ExtractedAttribute) {
                 const attributes = allElementAttributes.get(op.target) || new ElementAttributes(job.compatibility);
                 allElementAttributes.set(op.target, attributes);
-                attributes.add(op.bindingKind, op.name, op.expression, op.trustedValueFn);
+                attributes.add(op.bindingKind, op.name, op.expression, op.namespace, op.trustedValueFn);
                 OpList.remove(op);
             }
         }
@@ -11485,15 +11539,26 @@ function collectElementConsts(job) {
     if (job instanceof ComponentCompilationJob) {
         for (const unit of job.units) {
             for (const op of unit.create) {
-                if (isElementOrContainerOp(op)) {
+                // TODO: Simplify and combine these cases.
+                if (op.kind == OpKind.Projection) {
                     const attributes = allElementAttributes.get(op.xref);
                     if (attributes !== undefined) {
                         const attrArray = serializeAttributes(attributes);
                         if (attrArray.entries.length > 0) {
-                            op.attributes = job.addConst(attrArray);
+                            op.attributes = attrArray;
                         }
                     }
                 }
+                else if (isElementOrContainerOp(op)) {
+                    op.attributes = getConstIndex(job, allElementAttributes, op.xref);
+                    // TODO(dylhunn): `@for` loops with `@empty` blocks need to be special-cased here,
+                    // because the slot consumer trait currently only supports one slot per consumer and we
+                    // need two. This should be revisited when making the refactors mentioned in:
+                    // https://github.com/angular/angular/pull/53620#discussion_r1430918822
+                    if (op.kind === OpKind.RepeaterCreate && op.emptyView !== null) {
+                        op.emptyAttributes = getConstIndex(job, allElementAttributes, op.emptyView);
+                    }
+                }
             }
         }
     }
@@ -11511,6 +11576,16 @@ function collectElementConsts(job) {
         }
     }
 }
+function getConstIndex(job, allElementAttributes, xref) {
+    const attributes = allElementAttributes.get(xref);
+    if (attributes !== undefined) {
+        const attrArray = serializeAttributes(attributes);
+        if (attrArray.entries.length > 0) {
+            return job.addConst(attrArray);
+        }
+    }
+    return null;
+}
 /**
  * Shared instance of an empty array to avoid unnecessary array allocations.
  */
@@ -11552,7 +11627,7 @@ class ElementAttributes {
         nameToValue.add(name);
         return false;
     }
-    add(kind, name, value, trustedValueFn) {
+    add(kind, name, value, namespace, trustedValueFn) {
         // TemplateDefinitionBuilder puts duplicate attribute, class, and style values into the consts
         // array. This seems inefficient, we can probably keep just the first one or the last value
         // (whichever actually gets applied when multiple values are listed for the same attribute).
@@ -11573,7 +11648,7 @@ class ElementAttributes {
             // attribute. Is this sane?
         }
         const array = this.arrayFor(kind);
-        array.push(...getAttributeNameLiterals$1(name));
+        array.push(...getAttributeNameLiterals$1(namespace, name));
         if (kind === BindingKind.Attribute || kind === BindingKind.StyleProperty) {
             if (value === null) {
                 throw Error('Attribute, i18n attribute, & style element attributes must have a value');
@@ -11599,13 +11674,10 @@ class ElementAttributes {
 /**
  * Gets an array of literal expressions representing the attribute's namespaced name.
  */
-function getAttributeNameLiterals$1(name) {
-    const [attributeNamespace, attributeName] = splitNsName(name, false);
-    const nameLiteral = literal(attributeName);
-    if (attributeNamespace) {
-        return [
-            literal(0 /* core.AttributeMarker.NamespaceURI */), literal(attributeNamespace), nameLiteral
-        ];
+function getAttributeNameLiterals$1(namespace, name) {
+    const nameLiteral = literal(name);
+    if (namespace) {
+        return [literal(0 /* core.AttributeMarker.NamespaceURI */), literal(namespace), nameLiteral];
     }
     return [nameLiteral];
 }
@@ -12655,7 +12727,7 @@ function parseHostStyleProperties(job) {
         if (op.name.startsWith(STYLE_DOT)) {
             op.bindingKind = BindingKind.StyleProperty;
             op.name = op.name.substring(STYLE_DOT.length);
-            if (isCssCustomProperty$1(op.name)) {
+            if (!isCssCustomProperty$1(op.name)) {
                 op.name = hyphenate$1(op.name);
             }
             const { property, suffix } = parseProperty$1(op.name);
@@ -20089,6 +20161,7 @@ function parse(value) {
                 break;
             case 58 /* Char.Colon */:
                 if (!currentProp && parenDepth === 0 && quote === 0 /* Char.QuoteNone */) {
+                    // TODO: Do not hyphenate CSS custom property names like: `--intentionallyCamelCase`
                     currentProp = hyphenate(value.substring(propStart, i - 1).trim());
                     valueStart = i;
                 }
@@ -20163,7 +20236,7 @@ function addNamesToView(unit, baseName, state, compatibility) {
                 op.handlerFnName = sanitizeIdentifier(op.handlerFnName);
                 break;
             case OpKind.Variable:
-                varNames.set(op.xref, getVariableName(op.variable, state));
+                varNames.set(op.xref, getVariableName(unit, op.variable, state));
                 break;
             case OpKind.RepeaterCreate:
                 if (!(unit instanceof ViewCompilationUnit)) {
@@ -20218,15 +20291,23 @@ function addNamesToView(unit, baseName, state, compatibility) {
         });
     }
 }
-function getVariableName(variable, state) {
+function getVariableName(unit, variable, state) {
     if (variable.name === null) {
         switch (variable.kind) {
             case SemanticVariableKind.Context:
                 variable.name = `ctx_r${state.index++}`;
                 break;
             case SemanticVariableKind.Identifier:
-                // TODO: Prefix increment and `_r` for compatiblity only.
-                variable.name = `${variable.identifier}_r${++state.index}`;
+                if (unit.job.compatibility === CompatibilityMode.TemplateDefinitionBuilder) {
+                    // TODO: Prefix increment and `_r` are for compatiblity with the old naming scheme.
+                    // This has the potential to cause collisions when `ctx` is the identifier, so we need a
+                    // special check for that as well.
+                    const compatPrefix = variable.identifier === 'ctx' ? 'i' : '';
+                    variable.name = `${variable.identifier}_${compatPrefix}r${++state.index}`;
+                }
+                else {
+                    variable.name = `${variable.identifier}_i${state.index++}`;
+                }
                 break;
             default:
                 // TODO: Prefix increment for compatibility only.
@@ -20423,17 +20504,27 @@ const CREATE_ORDERING = [
  * op kinds.
  */
 const UPDATE_ORDERING = [
-    { test: kindWithInterpolationTest(OpKind.HostProperty, true) },
-    { test: kindWithInterpolationTest(OpKind.HostProperty, false) },
     { test: kindTest(OpKind.StyleMap), transform: keepLast },
     { test: kindTest(OpKind.ClassMap), transform: keepLast },
     { test: kindTest(OpKind.StyleProp) },
     { test: kindTest(OpKind.ClassProp) },
-    { test: kindWithInterpolationTest(OpKind.Property, true) },
     { test: kindWithInterpolationTest(OpKind.Attribute, true) },
+    { test: kindWithInterpolationTest(OpKind.Property, true) },
     { test: kindWithInterpolationTest(OpKind.Property, false) },
     { test: kindWithInterpolationTest(OpKind.Attribute, false) },
 ];
+/**
+ * Host bindings have their own update ordering.
+ */
+const UPDATE_HOST_ORDERING = [
+    { test: kindWithInterpolationTest(OpKind.HostProperty, true) },
+    { test: kindWithInterpolationTest(OpKind.HostProperty, false) },
+    { test: kindTest(OpKind.Attribute) },
+    { test: kindTest(OpKind.StyleMap), transform: keepLast },
+    { test: kindTest(OpKind.ClassMap), transform: keepLast },
+    { test: kindTest(OpKind.StyleProp) },
+    { test: kindTest(OpKind.ClassProp) },
+];
 /**
  * The set of all op kinds we handle in the reordering phase.
  */
@@ -20454,7 +20545,8 @@ function orderOps(job) {
         // Create mode:
         orderWithin(unit.create, CREATE_ORDERING);
         // Update mode:
-        orderWithin(unit.update, UPDATE_ORDERING);
+        const ordering = unit.job.kind === CompilationJobKind.Host ? UPDATE_HOST_ORDERING : UPDATE_ORDERING;
+        orderWithin(unit.update, ordering);
     }
 }
 /**
@@ -20534,14 +20626,14 @@ function parseExtractedStyles(job) {
                 if (op.name === 'style') {
                     const parsedStyles = parse(op.expression.value);
                     for (let i = 0; i < parsedStyles.length - 1; i += 2) {
-                        OpList.insertBefore(createExtractedAttributeOp(op.target, BindingKind.StyleProperty, parsedStyles[i], literal(parsedStyles[i + 1]), null, null, SecurityContext.STYLE), op);
+                        OpList.insertBefore(createExtractedAttributeOp(op.target, BindingKind.StyleProperty, null, parsedStyles[i], literal(parsedStyles[i + 1]), null, null, SecurityContext.STYLE), op);
                     }
                     OpList.remove(op);
                 }
                 else if (op.name === 'class') {
                     const parsedClasses = op.expression.value.trim().split(/\s+/g);
                     for (const parsedClass of parsedClasses) {
-                        OpList.insertBefore(createExtractedAttributeOp(op.target, BindingKind.ClassName, parsedClass, null, null, null, SecurityContext.NONE), op);
+                        OpList.insertBefore(createExtractedAttributeOp(op.target, BindingKind.ClassName, null, parsedClass, null, null, null, SecurityContext.NONE), op);
                     }
                     OpList.remove(op);
                 }
@@ -20565,15 +20657,6 @@ function removeContentSelectors(job) {
                         OpList.remove(op);
                     }
                     break;
-                case OpKind.Projection:
-                    // op.attributes is an array of [attr1-name, attr1-value, attr2-name, attr2-value, ...],
-                    // find the "select" attribute and remove its name and corresponding value.
-                    for (let i = op.attributes.length - 2; i >= 0; i -= 2) {
-                        if (isSelectAttribute(op.attributes[i])) {
-                            op.attributes.splice(i, 2);
-                        }
-                    }
-                    break;
             }
         }
     }
@@ -20745,8 +20828,10 @@ function wrapTemplateWithI18n(unit, parentI18n) {
     // Only add i18n ops if they have not already been propagated to this template.
     if (unit.create.head.next?.kind !== OpKind.I18nStart) {
         const id = unit.job.allocateXrefId();
-        OpList.insertAfter(createI18nStartOp(id, parentI18n.message, parentI18n.root), unit.create.head);
-        OpList.insertBefore(createI18nEndOp(id), unit.create.tail);
+        OpList.insertAfter(
+        // Nested ng-template i18n start/end ops should not recieve source spans.
+        createI18nStartOp(id, parentI18n.message, parentI18n.root, null), unit.create.head);
+        OpList.insertBefore(createI18nEndOp(id, null), unit.create.tail);
     }
 }
 
@@ -20927,9 +21012,7 @@ function namespaceMath() {
     return call(Identifiers.namespaceMathML, [], null);
 }
 function advance(delta, sourceSpan) {
-    return call(Identifiers.advance, [
-        literal(delta),
-    ], sourceSpan);
+    return call(Identifiers.advance, delta > 1 ? [literal(delta)] : [], sourceSpan);
 }
 function reference(slot) {
     return importExpr(Identifiers.reference).callFn([
@@ -21007,22 +21090,22 @@ function projectionDef(def) {
 }
 function projection(slot, projectionSlotIndex, attributes, sourceSpan) {
     const args = [literal(slot)];
-    if (projectionSlotIndex !== 0 || attributes.length > 0) {
+    if (projectionSlotIndex !== 0 || attributes !== null) {
         args.push(literal(projectionSlotIndex));
-        if (attributes.length > 0) {
-            args.push(literalArr(attributes.map(attr => literal(attr))));
+        if (attributes !== null) {
+            args.push(attributes);
         }
     }
     return call(Identifiers.projection, args, sourceSpan);
 }
-function i18nStart(slot, constIndex, subTemplateIndex) {
+function i18nStart(slot, constIndex, subTemplateIndex, sourceSpan) {
     const args = [literal(slot), literal(constIndex)];
     if (subTemplateIndex !== null) {
         args.push(literal(subTemplateIndex));
     }
-    return call(Identifiers.i18nStart, args, null);
+    return call(Identifiers.i18nStart, args, sourceSpan);
 }
-function repeaterCreate(slot, viewFnName, decls, vars, tag, constIndex, trackByFn, trackByUsesComponentInstance, emptyViewFnName, emptyDecls, emptyVars, sourceSpan) {
+function repeaterCreate(slot, viewFnName, decls, vars, tag, constIndex, trackByFn, trackByUsesComponentInstance, emptyViewFnName, emptyDecls, emptyVars, emptyTag, emptyConstIndex, sourceSpan) {
     const args = [
         literal(slot),
         variable(viewFnName),
@@ -21036,6 +21119,12 @@ function repeaterCreate(slot, viewFnName, decls, vars, tag, constIndex, trackByF
         args.push(literal(trackByUsesComponentInstance));
         if (emptyViewFnName !== null) {
             args.push(variable(emptyViewFnName), literal(emptyDecls), literal(emptyVars));
+            if (emptyTag !== null || emptyConstIndex !== null) {
+                args.push(literal(emptyTag));
+            }
+            if (emptyConstIndex !== null) {
+                args.push(literal(emptyConstIndex));
+            }
         }
     }
     return call(Identifiers.repeaterCreate, args, sourceSpan);
@@ -21046,15 +21135,15 @@ function repeater(collection, sourceSpan) {
 function deferWhen(prefetch, expr, sourceSpan) {
     return call(prefetch ? Identifiers.deferPrefetchWhen : Identifiers.deferWhen, [expr], sourceSpan);
 }
-function i18n(slot, constIndex, subTemplateIndex) {
+function i18n(slot, constIndex, subTemplateIndex, sourceSpan) {
     const args = [literal(slot), literal(constIndex)];
     if (subTemplateIndex) {
         args.push(literal(subTemplateIndex));
     }
-    return call(Identifiers.i18n, args, null);
+    return call(Identifiers.i18n, args, sourceSpan);
 }
-function i18nEnd() {
-    return call(Identifiers.i18nEnd, [], null);
+function i18nEnd(endSourceSpan) {
+    return call(Identifiers.i18nEnd, [], endSourceSpan);
 }
 function i18nAttributes(slot, i18nAttributesConfig) {
     const args = [literal(slot), literal(i18nAttributesConfig)];
@@ -21067,10 +21156,13 @@ function property(name, expression, sanitizer, sourceSpan) {
     }
     return call(Identifiers.property, args, sourceSpan);
 }
-function attribute(name, expression, sanitizer) {
+function attribute(name, expression, sanitizer, namespace) {
     const args = [literal(name), expression];
-    if (sanitizer !== null) {
-        args.push(sanitizer);
+    if (sanitizer !== null || namespace !== null) {
+        args.push(sanitizer ?? literal(null));
+    }
+    if (namespace !== null) {
+        args.push(literal(namespace));
     }
     return call(Identifiers.attribute, args, null);
 }
@@ -21440,13 +21532,13 @@ function reifyCreateOperations(unit, ops) {
                 OpList.replace(op, elementContainerEnd());
                 break;
             case OpKind.I18nStart:
-                OpList.replace(op, i18nStart(op.handle.slot, op.messageIndex, op.subTemplateIndex));
+                OpList.replace(op, i18nStart(op.handle.slot, op.messageIndex, op.subTemplateIndex, op.sourceSpan));
                 break;
             case OpKind.I18nEnd:
-                OpList.replace(op, i18nEnd());
+                OpList.replace(op, i18nEnd(op.sourceSpan));
                 break;
             case OpKind.I18n:
-                OpList.replace(op, i18n(op.handle.slot, op.messageIndex, op.subTemplateIndex));
+                OpList.replace(op, i18n(op.handle.slot, op.messageIndex, op.subTemplateIndex, op.sourceSpan));
                 break;
             case OpKind.I18nAttributes:
                 if (op.i18nAttributesConfig === null) {
@@ -21564,7 +21656,7 @@ function reifyCreateOperations(unit, ops) {
                     emptyDecls = emptyView.decls;
                     emptyVars = emptyView.vars;
                 }
-                OpList.replace(op, repeaterCreate(op.handle.slot, repeaterView.fnName, op.decls, op.vars, op.tag, op.attributes, op.trackByFn, op.usesComponentInstance, emptyViewFnName, emptyDecls, emptyVars, op.wholeSourceSpan));
+                OpList.replace(op, repeaterCreate(op.handle.slot, repeaterView.fnName, op.decls, op.vars, op.tag, op.attributes, op.trackByFn, op.usesComponentInstance, emptyViewFnName, emptyDecls, emptyVars, op.emptyTag, op.emptyAttributes, op.wholeSourceSpan));
                 break;
             case OpKind.Statement:
                 // Pass statement operations directly through.
@@ -21630,7 +21722,7 @@ function reifyUpdateOperations(_unit, ops) {
                     OpList.replace(op, attributeInterpolate(op.name, op.expression.strings, op.expression.expressions, op.sanitizer, op.sourceSpan));
                 }
                 else {
-                    OpList.replace(op, attribute(op.name, op.expression, op.sanitizer));
+                    OpList.replace(op, attribute(op.name, op.expression, op.sanitizer, op.namespace));
                 }
                 break;
             case OpKind.HostProperty:
@@ -21819,42 +21911,6 @@ function removeUnusedI18nAttributesOps(job) {
     }
 }
 
-/**
- * Inside the body of a repeater, certain context variables (such as `$first`) are ambiently
- * available. This phase finds those variable usages, and replaces them with the appropriate
- * expression.
- */
-function generateRepeaterDerivedVars(job) {
-    const repeaters = new Map();
-    for (const unit of job.units) {
-        for (const op of unit.ops()) {
-            if (op.kind === OpKind.RepeaterCreate) {
-                repeaters.set(op.xref, op);
-            }
-        }
-    }
-    for (const unit of job.units) {
-        for (const op of unit.ops()) {
-            transformExpressionsInOp(op, expr => {
-                if (!(expr instanceof DerivedRepeaterVarExpr)) {
-                    return expr;
-                }
-                const repeaterOp = repeaters.get(expr.xref);
-                switch (expr.identity) {
-                    case DerivedRepeaterVarIdentity.First:
-                        return new BinaryOperatorExpr(exports.BinaryOperator.Identical, new LexicalReadExpr(repeaterOp.varNames.$index), literal(0));
-                    case DerivedRepeaterVarIdentity.Last:
-                        return new BinaryOperatorExpr(exports.BinaryOperator.Identical, new LexicalReadExpr(repeaterOp.varNames.$index), new BinaryOperatorExpr(exports.BinaryOperator.Minus, new LexicalReadExpr(repeaterOp.varNames.$count), literal(1)));
-                    case DerivedRepeaterVarIdentity.Even:
-                        return new BinaryOperatorExpr(exports.BinaryOperator.Identical, new BinaryOperatorExpr(exports.BinaryOperator.Modulo, new LexicalReadExpr(repeaterOp.varNames.$index), literal(2)), literal(0));
-                    case DerivedRepeaterVarIdentity.Odd:
-                        return new BinaryOperatorExpr(exports.BinaryOperator.NotIdentical, new BinaryOperatorExpr(exports.BinaryOperator.Modulo, new LexicalReadExpr(repeaterOp.varNames.$index), literal(2)), literal(0));
-                }
-            }, VisitorContextFlag.None);
-        }
-    }
-}
-
 /**
  * Resolves `ir.ContextExpr` expressions (which represent embedded view or component contexts) to
  * either the `ctx` parameter to component functions (for the current view context) or to variables
@@ -22697,6 +22753,9 @@ function generateTrackFns(job) {
             // Find all component context reads.
             let usesComponentContext = false;
             op.track = transformExpressionsInExpression(op.track, expr => {
+                if (expr instanceof PipeBindingExpr || expr instanceof PipeBindingVariadicExpr) {
+                    throw new Error(`Illegal State: Pipes are not allowed in this context`);
+                }
                 if (expr instanceof TrackContextExpr) {
                     usesComponentContext = true;
                     return variable('this');
@@ -23383,12 +23442,13 @@ function wrapI18nIcus(job) {
                 case OpKind.IcuStart:
                     if (currentI18nOp === null) {
                         addedI18nId = job.allocateXrefId();
-                        OpList.insertBefore(createI18nStartOp(addedI18nId, op.message), op);
+                        // ICU i18n start/end ops should not recieve source spans.
+                        OpList.insertBefore(createI18nStartOp(addedI18nId, op.message, undefined, null), op);
                     }
                     break;
                 case OpKind.IcuEnd:
                     if (addedI18nId !== null) {
-                        OpList.insertAfter(createI18nEndOp(addedI18nId), op);
+                        OpList.insertAfter(createI18nEndOp(addedI18nId, null), op);
                         addedI18nId = null;
                     }
                     break;
@@ -23435,7 +23495,6 @@ function wrapI18nIcus(job) {
     { kind: CompilationJobKind.Tmpl, fn: saveAndRestoreView },
     { kind: CompilationJobKind.Both, fn: deleteAnyCasts },
     { kind: CompilationJobKind.Both, fn: resolveDollarEvent },
-    { kind: CompilationJobKind.Tmpl, fn: generateRepeaterDerivedVars },
     { kind: CompilationJobKind.Tmpl, fn: generateTrackVariables },
     { kind: CompilationJobKind.Both, fn: resolveNames },
     { kind: CompilationJobKind.Tmpl, fn: resolveDeferTargetNames },
@@ -24972,8 +25031,8 @@ const TIME_PATTERN = /^\d+\.?\d*(ms|s)?$/;
 const SEPARATOR_PATTERN = /^\s$/;
 /** Pairs of characters that form syntax that is comma-delimited. */
 const COMMA_DELIMITED_SYNTAX = new Map([
-    [$LBRACE, $RBRACE],
-    [$LBRACKET, $RBRACKET],
+    [$LBRACE, $RBRACE], // Object literals
+    [$LBRACKET, $RBRACKET], // Array literals
     [$LPAREN, $RPAREN], // Function calls
 ]);
 /** Possible types of `on` triggers. */
@@ -26243,7 +26302,7 @@ class TemplateData {
     }
 }
 class TemplateDefinitionBuilder {
-    constructor(constantPool, parentBindingScope, level = 0, contextName, i18nContext, templateIndex, templateName, _namespace, relativeContextFilePath, i18nUseExternalIds, deferBlocks, elementLocations, _constants = createComponentDefConsts()) {
+    constructor(constantPool, parentBindingScope, level = 0, contextName, i18nContext, templateIndex, templateName, _namespace, relativeContextFilePath, i18nUseExternalIds, deferBlocks, elementLocations, allDeferrableDepsFn, _constants = createComponentDefConsts()) {
         this.constantPool = constantPool;
         this.level = level;
         this.contextName = contextName;
@@ -26254,6 +26313,7 @@ class TemplateDefinitionBuilder {
         this.i18nUseExternalIds = i18nUseExternalIds;
         this.deferBlocks = deferBlocks;
         this.elementLocations = elementLocations;
+        this.allDeferrableDepsFn = allDeferrableDepsFn;
         this._constants = _constants;
         this._dataIndex = 0;
         this._bindingContext = 0;
@@ -26908,7 +26968,7 @@ class TemplateDefinitionBuilder {
         const contextName = `${this.contextName}${contextNameSuffix}_${index}`;
         const name = `${contextName}_Template`;
         // Create the template function
-        const visitor = new TemplateDefinitionBuilder(this.constantPool, this._bindingScope, this.level + 1, contextName, this.i18n, index, name, this._namespace, this.fileBasedI18nSuffix, this.i18nUseExternalIds, this.deferBlocks, this.elementLocations, this._constants);
+        const visitor = new TemplateDefinitionBuilder(this.constantPool, this._bindingScope, this.level + 1, contextName, this.i18n, index, name, this._namespace, this.fileBasedI18nSuffix, this.i18nUseExternalIds, this.deferBlocks, this.elementLocations, this.allDeferrableDepsFn, this._constants);
         // Nested templates must not be visited until after their parent templates have completed
         // processing, so they are queued here until after the initial pass. Otherwise, we wouldn't
         // be able to support bindings in nested templates to local refs that occur after the
@@ -27119,6 +27179,9 @@ class TemplateDefinitionBuilder {
         this.updateInstructionWithAdvance(containerIndex, block.branches[0].sourceSpan, Identifiers.conditional, paramsCallback);
     }
     visitSwitchBlock(block) {
+        if (block.cases.length === 0) {
+            return;
+        }
         // We have to process the block in two steps: once here and again in the update instruction
         // callback in order to generate the correct expressions when pipes or pure functions are used.
         const caseData = block.cases.map(currentCase => {
@@ -27193,7 +27256,7 @@ class TemplateDefinitionBuilder {
         this.creationInstruction(deferred.sourceSpan, Identifiers.defer, trimTrailingNulls([
             literal(deferredIndex),
             literal(primaryTemplateIndex),
-            this.createDeferredDepsFunction(depsFnName, metadata),
+            this.allDeferrableDepsFn ?? this.createDeferredDepsFunction(depsFnName, metadata),
             literal(loadingIndex),
             literal(placeholderIndex),
             literal(errorIndex),
@@ -27348,7 +27411,12 @@ class TemplateDefinitionBuilder {
         });
         const { expression: trackByExpression, usesComponentInstance: trackByUsesComponentInstance } = this.createTrackByFunction(block);
         let emptyData = null;
+        let emptyTagName = null;
+        let emptyAttrsExprs;
         if (block.empty !== null) {
+            const emptyInferred = this.inferProjectionDataFromInsertionPoint(block.empty);
+            emptyTagName = emptyInferred.tagName;
+            emptyAttrsExprs = emptyInferred.attrsExprs;
             emptyData = this.prepareEmbeddedTemplateFn(block.empty.children, '_ForEmpty', undefined, block.empty.i18n);
             // Allocate an extra slot for the empty block tracking.
             this.allocateBindingSlots(null);
@@ -27366,13 +27434,13 @@ class TemplateDefinitionBuilder {
                 trackByExpression,
             ];
             if (emptyData !== null) {
-                params.push(literal(trackByUsesComponentInstance), variable(emptyData.name), literal(emptyData.getConstCount()), literal(emptyData.getVarCount()));
+                params.push(literal(trackByUsesComponentInstance), variable(emptyData.name), literal(emptyData.getConstCount()), literal(emptyData.getVarCount()), literal(emptyTagName), this.addAttrsToConsts(emptyAttrsExprs || null));
             }
             else if (trackByUsesComponentInstance) {
                 // If the tracking function doesn't use the component instance, we can omit the flag.
                 params.push(literal(trackByUsesComponentInstance));
             }
-            return params;
+            return trimTrailingNulls(params);
         });
         // Note: the expression needs to be processed *after* the template,
         // otherwise pipes injecting some symbols won't work (see #52102).
@@ -27577,7 +27645,7 @@ class TemplateDefinitionBuilder {
             if (delta < 1) {
                 throw new Error('advance instruction can only go forwards');
             }
-            this.instructionFn(this._updateCodeFns, span, Identifiers.advance, [literal(delta)]);
+            this.instructionFn(this._updateCodeFns, span, Identifiers.advance, delta > 1 ? [literal(delta)] : []);
             this._currentIndex = nodeIndex;
         }
     }
@@ -28550,6 +28618,24 @@ function compileDirectiveFromMetadata(meta, constantPool, bindingParser) {
     const type = createDirectiveType(meta);
     return { expression, type, statements: [] };
 }
+/**
+ * Creates an AST for a function that contains dynamic imports representing
+ * deferrable dependencies.
+ */
+function createDeferredDepsFunction(constantPool, name, deps) {
+    // This defer block has deps for which we need to generate dynamic imports.
+    const dependencyExp = [];
+    for (const [symbolName, importPath] of deps) {
+        // Callback function, e.g. `m () => m.MyCmp;`.
+        const innerFn = arrowFn([new FnParam('m', DYNAMIC_TYPE)], variable('m').prop(symbolName));
+        // Dynamic import, e.g. `import('./a').then(...)`.
+        const importExpr = (new DynamicImportExpr(importPath)).prop('then').callFn([innerFn]);
+        dependencyExp.push(importExpr);
+    }
+    const depsFnExpr = arrowFn([], literalArr(dependencyExp));
+    constantPool.statements.push(depsFnExpr.toDeclStmt(name, exports.StmtModifier.Final));
+    return variable(name);
+}
 /**
  * Compile a component for the render3 runtime as defined by the `R3ComponentMetadata`.
  */
@@ -28574,8 +28660,14 @@ function compileComponentFromMetadata(meta, constantPool, bindingParser) {
     {
         // This is the main path currently used in compilation, which compiles the template with the
         // legacy `TemplateDefinitionBuilder`.
+        let allDeferrableDepsFn = null;
+        if (meta.deferBlocks.size > 0 && meta.deferrableTypes.size > 0 &&
+            meta.deferBlockDepsEmitMode === 1 /* DeferBlockDepsEmitMode.PerComponent */) {
+            const fnName = `${templateTypeName}_DeferFn`;
+            allDeferrableDepsFn = createDeferredDepsFunction(constantPool, fnName, meta.deferrableTypes);
+        }
         const template = meta.template;
-        const templateBuilder = new TemplateDefinitionBuilder(constantPool, BindingScope.createRootScope(), 0, templateTypeName, null, null, templateName, Identifiers.namespaceHTML, meta.relativeContextFilePath, meta.i18nUseExternalIds, meta.deferBlocks, new Map());
+        const templateBuilder = new TemplateDefinitionBuilder(constantPool, BindingScope.createRootScope(), 0, templateTypeName, null, null, templateName, Identifiers.namespaceHTML, meta.relativeContextFilePath, meta.i18nUseExternalIds, meta.deferBlocks, new Map(), allDeferrableDepsFn);
         const templateFunctionExpression = templateBuilder.buildTemplateFunction(template.nodes, []);
         // We need to provide this so that dynamically generated components know what
         // projected content blocks to pass through to the component when it is
@@ -28788,14 +28880,16 @@ function createBaseDirectiveTypeParams(meta) {
 function getInputsTypeExpression(meta) {
     return literalMap(Object.keys(meta.inputs).map(key => {
         const value = meta.inputs[key];
-        return {
-            key,
-            value: literalMap([
-                { key: 'alias', value: literal(value.bindingPropertyName), quoted: true },
-                { key: 'required', value: literal(value.required), quoted: true }
-            ]),
-            quoted: true
-        };
+        const values = [
+            { key: 'alias', value: literal(value.bindingPropertyName), quoted: true },
+            { key: 'required', value: literal(value.required), quoted: true },
+        ];
+        // TODO(legacy-partial-output-inputs): Consider always emitting this information,
+        // or leaving it as is.
+        if (value.isSignal) {
+            values.push({ key: 'isSignal', value: literal(value.isSignal), quoted: true });
+        }
+        return { key, value: literalMap(values), quoted: true };
     }));
 }
 /**
@@ -29144,6 +29238,18 @@ function compileStyles(styles, selector, hostSelector) {
         return shadowCss.shimCssText(style, selector, hostSelector);
     });
 }
+/**
+ * Encapsulates a CSS stylesheet with emulated view encapsulation.
+ * This allows a stylesheet to be used with an Angular component that
+ * is using the `ViewEncapsulation.Emulated` mode.
+ *
+ * @param style The content of a CSS stylesheet.
+ * @returns The encapsulated content for the style.
+ */
+function encapsulateStyle(style) {
+    const shadowCss = new ShadowCss();
+    return shadowCss.shimCssText(style, CONTENT_ATTR, HOST_ATTR);
+}
 function createHostDirectivesType(meta) {
     if (!meta.hostDirectives?.length) {
         return NONE_TYPE;
@@ -29239,7 +29345,7 @@ class R3TargetBinder {
         // Finally, run the TemplateBinder to bind references, variables, and other entities within the
         // template. This extracts all the metadata that doesn't depend on directive matching.
         const { expressions, symbols, nestingLevel, usedPipes, eagerPipes, deferBlocks } = TemplateBinder.applyWithScope(target.template, scope);
-        return new R3BoundTarget(target, directives, eagerDirectives, bindings, references, expressions, symbols, nestingLevel, scopedNodeEntities, usedPipes, eagerPipes, deferBlocks);
+        return new R3BoundTarget(target, directives, eagerDirectives, bindings, references, expressions, symbols, nestingLevel, scopedNodeEntities, usedPipes, eagerPipes, deferBlocks, scope);
     }
 }
 /**
@@ -29257,6 +29363,10 @@ class Scope {
          * Named members of the `Scope`, such as `Reference`s or `Variable`s.
          */
         this.namedEntities = new Map();
+        /**
+         * Set of elements that belong to this scope.
+         */
+        this.elementsInScope = new Set();
         /**
          * Child `Scope`s for immediately nested `ScopedNode`s.
          */
@@ -29313,6 +29423,7 @@ class Scope {
         element.references.forEach(node => this.visitReference(node));
         // Recurse into the `Element`'s children.
         element.children.forEach(node => node.visit(this));
+        this.elementsInScope.add(element);
     }
     visitTemplate(template) {
         // References on a <ng-template> are defined in the outer scope, so capture them before
@@ -29806,7 +29917,7 @@ class TemplateBinder extends RecursiveAstVisitor {
  * See `BoundTarget` for documentation on the individual methods.
  */
 class R3BoundTarget {
-    constructor(target, directives, eagerDirectives, bindings, references, exprTargets, symbols, nestingLevel, scopedNodeEntities, usedPipes, eagerPipes, deferredBlocks) {
+    constructor(target, directives, eagerDirectives, bindings, references, exprTargets, symbols, nestingLevel, scopedNodeEntities, usedPipes, eagerPipes, deferredBlocks, rootScope) {
         this.target = target;
         this.directives = directives;
         this.eagerDirectives = eagerDirectives;
@@ -29819,6 +29930,7 @@ class R3BoundTarget {
         this.usedPipes = usedPipes;
         this.eagerPipes = eagerPipes;
         this.deferredBlocks = deferredBlocks;
+        this.rootScope = rootScope;
     }
     getEntitiesInScope(node) {
         return this.scopedNodeEntities.get(node) ?? new Set();
@@ -29908,6 +30020,15 @@ class R3BoundTarget {
         }
         return null;
     }
+    isDeferred(element) {
+        for (const deferBlock of this.deferredBlocks) {
+            const scope = this.rootScope.childScopes.get(deferBlock);
+            if (scope && scope.elementsInScope.has(element)) {
+                return true;
+            }
+        }
+        return false;
+    }
     /**
      * Finds an entity with a specific name in a scope.
      * @param rootNode Root node of the scope.
@@ -30053,7 +30174,7 @@ class CompilerFacadeImpl {
             type: wrapReference(facade.type),
             bootstrap: facade.bootstrap.map(wrapReference),
             declarations: facade.declarations.map(wrapReference),
-            publicDeclarationTypes: null,
+            publicDeclarationTypes: null, // only needed for types in AOT
             imports: facade.imports.map(wrapReference),
             includeImportTypes: true,
             exports: facade.exports.map(wrapReference),
@@ -30096,9 +30217,9 @@ class CompilerFacadeImpl {
             declarations: facade.declarations.map(convertDeclarationFacadeToMetadata),
             declarationListEmitMode: 0 /* DeclarationListEmitMode.Direct */,
             deferBlocks,
-            // TODO: leaving empty in JIT mode for now,
-            // to be implemented as one of the next steps.
+            deferrableTypes: new Map(),
             deferrableDeclToImportDecl: new Map(),
+            deferBlockDepsEmitMode: 0 /* DeferBlockDepsEmitMode.PerBlock */,
             styles: [...facade.styles, ...template.styles],
             encapsulation: facade.encapsulation,
             interpolation,
@@ -30209,6 +30330,10 @@ function convertDirectiveFacadeToMetadata(facade) {
                         bindingPropertyName: ann.alias || field,
                         classPropertyName: field,
                         required: ann.required || false,
+                        // For JIT, decorators are used to declare signal inputs. That is because of
+                        // a technical limitation where it's not possible to statically reflect class
+                        // members of a directive/component at runtime before instantiating the class.
+                        isSignal: !!ann.isSignal,
                         transformFunction: ann.transform != null ? new WrappedNodeExpr(ann.transform) : null,
                     };
                 }
@@ -30240,7 +30365,7 @@ function convertDeclareDirectiveFacadeToMetadata(declaration, typeSourceSpan) {
         type: wrapReference(declaration.type),
         typeSourceSpan,
         selector: declaration.selector ?? null,
-        inputs: declaration.inputs ? inputsMappingToInputMetadata(declaration.inputs) : {},
+        inputs: declaration.inputs ? inputsPartialMetadataToInputMetadata(declaration.inputs) : {},
         outputs: declaration.outputs ?? {},
         host: convertHostDeclarationToMetadata(declaration.host),
         queries: (declaration.queries ?? []).map(convertQueryDeclarationToMetadata),
@@ -30330,9 +30455,9 @@ function convertDeclareComponentFacadeToMetadata(decl, typeSourceSpan, sourceMap
             null,
         animations: decl.animations !== undefined ? new WrappedNodeExpr(decl.animations) : null,
         deferBlocks,
-        // TODO: leaving empty in JIT mode for now,
-        // to be implemented as one of the next steps.
+        deferrableTypes: new Map(),
         deferrableDeclToImportDecl: new Map(),
+        deferBlockDepsEmitMode: 0 /* DeferBlockDepsEmitMode.PerBlock */,
         changeDetection: decl.changeDetection ?? exports.ChangeDetectionStrategy.Default,
         encapsulation: decl.encapsulation ?? exports.ViewEncapsulation.Emulated,
         interpolation,
@@ -30503,28 +30628,51 @@ function isInput(value) {
 function isOutput(value) {
     return value.ngMetadataName === 'Output';
 }
-function inputsMappingToInputMetadata(inputs) {
-    return Object.keys(inputs).reduce((result, key) => {
-        const value = inputs[key];
-        if (typeof value === 'string') {
-            result[key] = {
-                bindingPropertyName: value,
-                classPropertyName: value,
-                transformFunction: null,
-                required: false,
-            };
+function inputsPartialMetadataToInputMetadata(inputs) {
+    return Object.keys(inputs).reduce((result, minifiedClassName) => {
+        const value = inputs[minifiedClassName];
+        // Handle legacy partial input output.
+        if (typeof value === 'string' || Array.isArray(value)) {
+            result[minifiedClassName] = parseLegacyInputPartialOutput(value);
         }
         else {
-            result[key] = {
-                bindingPropertyName: value[0],
-                classPropertyName: value[1],
-                transformFunction: value[2] ? new WrappedNodeExpr(value[2]) : null,
-                required: false,
+            result[minifiedClassName] = {
+                bindingPropertyName: value.publicName,
+                classPropertyName: minifiedClassName,
+                transformFunction: value.transformFunction !== null ?
+                    new WrappedNodeExpr(value.transformFunction) :
+                    null,
+                required: value.isRequired,
+                isSignal: value.isSignal,
             };
         }
         return result;
     }, {});
 }
+/**
+ * Parses the legacy input partial output. For more details see `partial/directive.ts`.
+ * TODO(legacy-partial-output-inputs): Remove in v18.
+ */
+function parseLegacyInputPartialOutput(value) {
+    if (typeof value === 'string') {
+        return {
+            bindingPropertyName: value,
+            classPropertyName: value,
+            transformFunction: null,
+            required: false,
+            // legacy partial output does not capture signal inputs.
+            isSignal: false,
+        };
+    }
+    return {
+        bindingPropertyName: value[0],
+        classPropertyName: value[1],
+        transformFunction: value[2] ? new WrappedNodeExpr(value[2]) : null,
+        required: false,
+        // legacy partial output does not capture signal inputs.
+        isSignal: false,
+    };
+}
 function parseInputsArray(values) {
     return values.reduce((results, value) => {
         if (typeof value === 'string') {
@@ -30533,6 +30681,8 @@ function parseInputsArray(values) {
                 bindingPropertyName,
                 classPropertyName,
                 required: false,
+                // Signal inputs not supported for the inputs array.
+                isSignal: false,
                 transformFunction: null,
             };
         }
@@ -30541,6 +30691,8 @@ function parseInputsArray(values) {
                 bindingPropertyName: value.alias || value.name,
                 classPropertyName: value.name,
                 required: value.required || false,
+                // Signal inputs not supported for the inputs array.
+                isSignal: false,
                 transformFunction: value.transform != null ? new WrappedNodeExpr(value.transform) : null,
             };
         }
@@ -30593,7 +30745,7 @@ function publishFacade(global) {
  * @description
  * Entry point for all public APIs of the compiler package.
  */
-const VERSION = new Version('17.0.8');
+const VERSION = new Version('17.1.0');
 
 class CompilerConfig {
     constructor({ defaultEncapsulation = exports.ViewEncapsulation.Emulated, preserveWhitespaces, strictInjectionParameters } = {}) {
@@ -32088,7 +32240,7 @@ function compileClassMetadata(metadata) {
  * check to tree-shake away this code in production mode.
  */
 function compileComponentClassMetadata(metadata, deferrableTypes) {
-    if (deferrableTypes.size === 0) {
+    if (deferrableTypes === null || deferrableTypes.size === 0) {
         // If there are no deferrable symbols - just generate a regular `setClassMetadata` call.
         return compileClassMetadata(metadata);
     }
@@ -32155,11 +32307,11 @@ function compileClassDebugInfo(debugInfo) {
  *
  * Do not include any prerelease in these versions as they are ignored.
  */
-const MINIMUM_PARTIAL_LINKER_VERSION$6 = '12.0.0';
+const MINIMUM_PARTIAL_LINKER_VERSION$5 = '12.0.0';
 function compileDeclareClassMetadata(metadata) {
     const definitionMap = new DefinitionMap();
-    definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$6));
-    definitionMap.set('version', literal('17.0.8'));
+    definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$5));
+    definitionMap.set('version', literal('17.1.0'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', metadata.type);
     definitionMap.set('decorators', metadata.decorators);
@@ -32238,14 +32390,6 @@ function compileDependency(dep) {
     return depMeta.toLiteralMap();
 }
 
-/**
- * Every time we make a breaking change to the declaration interface or partial-linker behavior, we
- * must update this constant to prevent old partial-linkers from incorrectly processing the
- * declaration.
- *
- * Do not include any prerelease in these versions as they are ignored.
- */
-const MINIMUM_PARTIAL_LINKER_VERSION$5 = '16.1.0';
 /**
  * Compile a directive declaration defined by the `R3DirectiveMetadata`.
  */
@@ -32261,13 +32405,9 @@ function compileDeclareDirectiveFromMetadata(meta) {
  */
 function createDirectiveDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
-    const hasTransformFunctions = Object.values(meta.inputs).some(input => input.transformFunction !== null);
-    // Note: in order to allow consuming Angular libraries that have been compiled with 16.1+ in
-    // Angular 16.0, we only force a minimum version of 16.1 if input transform feature as introduced
-    // in 16.1 is actually used.
-    const minVersion = hasTransformFunctions ? MINIMUM_PARTIAL_LINKER_VERSION$5 : '14.0.0';
+    const minVersion = getMinimumVersionForPartialOutput(meta);
     definitionMap.set('minVersion', literal(minVersion));
-    definitionMap.set('version', literal('17.0.8'));
+    definitionMap.set('version', literal('17.1.0'));
     // e.g. `type: MyDirective`
     definitionMap.set('type', meta.type.value);
     if (meta.isStandalone) {
@@ -32280,7 +32420,8 @@ function createDirectiveDefinitionMap(meta) {
     if (meta.selector !== null) {
         definitionMap.set('selector', literal(meta.selector));
     }
-    definitionMap.set('inputs', conditionallyCreateDirectiveBindingLiteral(meta.inputs, true));
+    definitionMap.set('inputs', needsNewInputPartialOutput(meta) ? createInputsPartialMetadata(meta.inputs) :
+        legacyInputsPartialMetadata(meta.inputs));
     definitionMap.set('outputs', conditionallyCreateDirectiveBindingLiteral(meta.outputs));
     definitionMap.set('host', compileHostMetadata(meta.host));
     definitionMap.set('providers', meta.providers);
@@ -32305,6 +32446,44 @@ function createDirectiveDefinitionMap(meta) {
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     return definitionMap;
 }
+/**
+ * Determines the minimum linker version for the partial output
+ * generated for this directive.
+ *
+ * Every time we make a breaking change to the declaration interface or partial-linker
+ * behavior, we must update the minimum versions to prevent old partial-linkers from
+ * incorrectly processing the declaration.
+ *
+ * NOTE: Do not include any prerelease in these versions as they are ignored.
+ */
+function getMinimumVersionForPartialOutput(meta) {
+    // We are starting with the oldest minimum version that can work for common
+    // directive partial compilation output. As we discover usages of new features
+    // that require a newer partial output emit, we bump the `minVersion`. Our goal
+    // is to keep libraries as much compatible with older linker versions as possible.
+    let minVersion = '14.0.0';
+    // Note: in order to allow consuming Angular libraries that have been compiled with 16.1+ in
+    // Angular 16.0, we only force a minimum version of 16.1 if input transform feature as introduced
+    // in 16.1 is actually used.
+    const hasDecoratorTransformFunctions = Object.values(meta.inputs).some(input => input.transformFunction !== null);
+    if (hasDecoratorTransformFunctions) {
+        minVersion = '16.1.0';
+    }
+    // If there are input flags and we need the new emit, use the actual minimum version,
+    // where this was introduced. i.e. in 17.1.0
+    // TODO(legacy-partial-output-inputs): Remove in v18.
+    if (needsNewInputPartialOutput(meta)) {
+        minVersion = '17.1.0';
+    }
+    return minVersion;
+}
+/**
+ * Gets whether the given directive needs the new input partial output structure
+ * that can hold additional metadata like `isRequired`, `isSignal` etc.
+ */
+function needsNewInputPartialOutput(meta) {
+    return Object.values(meta.inputs).some(input => input.isSignal);
+}
 /**
  * Compiles the metadata of a single query into its partial declaration form as declared
  * by `R3DeclareQueryMetadata`.
@@ -32375,6 +32554,74 @@ function createHostDirectives(hostDirectives) {
     // otherwise we can save some bytes by using a plain array, e.g. `[{directive: HostDir}]`.
     return literalArr(expressions);
 }
+/**
+ * Generates partial output metadata for inputs of a directive.
+ *
+ * The generated structure is expected to match `R3DeclareDirectiveFacade['inputs']`.
+ */
+function createInputsPartialMetadata(inputs) {
+    const keys = Object.getOwnPropertyNames(inputs);
+    if (keys.length === 0) {
+        return null;
+    }
+    return literalMap(keys.map(declaredName => {
+        const value = inputs[declaredName];
+        return {
+            key: declaredName,
+            // put quotes around keys that contain potentially unsafe characters
+            quoted: UNSAFE_OBJECT_KEY_NAME_REGEXP.test(declaredName),
+            value: literalMap([
+                { key: 'classPropertyName', quoted: false, value: asLiteral(value.classPropertyName) },
+                { key: 'publicName', quoted: false, value: asLiteral(value.bindingPropertyName) },
+                { key: 'isSignal', quoted: false, value: asLiteral(value.isSignal) },
+                { key: 'isRequired', quoted: false, value: asLiteral(value.required) },
+                { key: 'transformFunction', quoted: false, value: value.transformFunction ?? NULL_EXPR },
+            ])
+        };
+    }));
+}
+/**
+ * Pre v18 legacy partial output for inputs.
+ *
+ * Previously, inputs did not capture metadata like `isSignal` in the partial compilation output.
+ * To enable capturing such metadata, we restructured how input metadata is communicated in the
+ * partial output. This would make libraries incompatible with older Angular FW versions where the
+ * linker would not know how to handle this new "format". For this reason, if we know this metadata
+ * does not need to be captured- we fall back to the old format. This is what this function
+ * generates.
+ *
+ * See:
+ * https://github.com/angular/angular/blob/d4b423690210872b5c32a322a6090beda30b05a3/packages/core/src/compiler/compiler_facade_interface.ts#L197-L199
+ */
+function legacyInputsPartialMetadata(inputs) {
+    // TODO(legacy-partial-output-inputs): Remove function in v18.
+    const keys = Object.getOwnPropertyNames(inputs);
+    if (keys.length === 0) {
+        return null;
+    }
+    return literalMap(keys.map(declaredName => {
+        const value = inputs[declaredName];
+        const publicName = value.bindingPropertyName;
+        const differentDeclaringName = publicName !== declaredName;
+        let result;
+        if (differentDeclaringName || value.transformFunction !== null) {
+            const values = [asLiteral(publicName), asLiteral(declaredName)];
+            if (value.transformFunction !== null) {
+                values.push(value.transformFunction);
+            }
+            result = literalArr(values);
+        }
+        else {
+            result = asLiteral(publicName);
+        }
+        return {
+            key: declaredName,
+            // put quotes around keys that contain potentially unsafe characters
+            quoted: UNSAFE_OBJECT_KEY_NAME_REGEXP.test(declaredName),
+            value: result,
+        };
+    }));
+}
 
 /**
  * Compile a component declaration defined by the `R3ComponentMetadata`.
@@ -32541,7 +32788,7 @@ const MINIMUM_PARTIAL_LINKER_VERSION$4 = '12.0.0';
 function compileDeclareFactoryFunction(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$4));
-    definitionMap.set('version', literal('17.0.8'));
+    definitionMap.set('version', literal('17.1.0'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('deps', compileDependencies(meta.deps));
@@ -32576,7 +32823,7 @@ function compileDeclareInjectableFromMetadata(meta) {
 function createInjectableDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$3));
-    definitionMap.set('version', literal('17.0.8'));
+    definitionMap.set('version', literal('17.1.0'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     // Only generate providedIn property if it has a non-null value
@@ -32627,7 +32874,7 @@ function compileDeclareInjectorFromMetadata(meta) {
 function createInjectorDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$2));
-    definitionMap.set('version', literal('17.0.8'));
+    definitionMap.set('version', literal('17.1.0'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('providers', meta.providers);
@@ -32660,7 +32907,7 @@ function createNgModuleDefinitionMap(meta) {
         throw new Error('Invalid path! Local compilation mode should not get into the partial compilation path');
     }
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$1));
-    definitionMap.set('version', literal('17.0.8'));
+    definitionMap.set('version', literal('17.1.0'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     // We only generate the keys in the metadata if the arrays contain values.
@@ -32711,7 +32958,7 @@ function compileDeclarePipeFromMetadata(meta) {
 function createPipeDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION));
-    definitionMap.set('version', literal('17.0.8'));
+    definitionMap.set('version', literal('17.1.0'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     // e.g. `type: MyPipe`
     definitionMap.set('type', meta.type.value);
@@ -32924,6 +33171,7 @@ exports.createInjectableType = createInjectableType;
 exports.createMayBeForwardRefExpression = createMayBeForwardRefExpression;
 exports.devOnlyGuardedExpression = devOnlyGuardedExpression;
 exports.emitDistinctChangesOnlyDefaultValue = emitDistinctChangesOnlyDefaultValue;
+exports.encapsulateStyle = encapsulateStyle;
 exports.getHtmlTagDefinition = getHtmlTagDefinition;
 exports.getNsPrefix = getNsPrefix;
 exports.getSafePropertyAccessString = getSafePropertyAccessString;