@angular/compiler 17.1.0-next.5 → 17.1.0

package/fesm2022/compiler.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v17.1.0-next.5
+ * @license Angular v17.1.0
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -409,6 +409,13 @@ var ChangeDetectionStrategy;
     ChangeDetectionStrategy[ChangeDetectionStrategy["OnPush"] = 0] = "OnPush";
     ChangeDetectionStrategy[ChangeDetectionStrategy["Default"] = 1] = "Default";
 })(ChangeDetectionStrategy || (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'
 };
@@ -472,6 +479,7 @@ var core = /*#__PURE__*/Object.freeze({
     emitDistinctChangesOnlyDefaultValue: emitDistinctChangesOnlyDefaultValue,
     get ViewEncapsulation () { return ViewEncapsulation; },
     get ChangeDetectionStrategy () { return ChangeDetectionStrategy; },
+    get InputFlags () { return InputFlags; },
     CUSTOM_ELEMENTS_SCHEMA: CUSTOM_ELEMENTS_SCHEMA,
     NO_ERRORS_SCHEMA: NO_ERRORS_SCHEMA,
     Type: Type$1,
@@ -890,12 +898,13 @@ var BinaryOperator;
     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";
 })(BinaryOperator || (BinaryOperator = {}));
 function nullSafeIsEquivalent(base, other) {
     if (base == null || other == null) {
@@ -968,6 +977,9 @@ class Expression {
     and(rhs, sourceSpan) {
         return new BinaryOperatorExpr(BinaryOperator.And, this, rhs, null, sourceSpan);
     }
+    bitwiseOr(rhs, sourceSpan, parens = true) {
+        return new BinaryOperatorExpr(BinaryOperator.BitwiseOr, this, rhs, null, sourceSpan, parens);
+    }
     bitwiseAnd(rhs, sourceSpan, parens = true) {
         return new BinaryOperatorExpr(BinaryOperator.BitwiseAnd, this, rhs, null, sourceSpan, parens);
     }
@@ -2628,6 +2640,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 }; }
@@ -3269,6 +3285,9 @@ class AbstractEmitterVisitor {
             case BinaryOperator.And:
                 opStr = '&&';
                 break;
+            case BinaryOperator.BitwiseOr:
+                opStr = '|';
+                break;
             case BinaryOperator.BitwiseAnd:
                 opStr = '&';
                 break;
@@ -4973,7 +4992,7 @@ function asLiteral(value) {
  * This will attempt to generate optimized data structures to minimize memory or
  * file size of fully compiled applications.
  */
-function conditionallyCreateDirectiveBindingLiteral(map, keepDeclared) {
+function conditionallyCreateDirectiveBindingLiteral(map, forInputs) {
     const keys = Object.getOwnPropertyNames(map);
     if (keys.length === 0) {
         return null;
@@ -4995,12 +5014,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);
@@ -5014,6 +5049,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.
  */
@@ -9270,16 +9316,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.
  */
@@ -9524,10 +9560,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,
@@ -10224,26 +10261,6 @@ class ConditionalCaseExpr extends ExpressionBase {
         }
     }
 }
-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();
@@ -11009,11 +11026,12 @@ function createProjectionOp(xref, selector, i18nPlaceholder, sourceSpan) {
 /**
  * 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,
@@ -11563,7 +11581,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;
@@ -11575,14 +11594,14 @@ 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) {
@@ -11628,7 +11647,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.
@@ -11675,7 +11694,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:
@@ -11865,6 +11885,7 @@ const BINARY_OPERATORS = new Map([
     ['&&', BinaryOperator.And],
     ['>', BinaryOperator.Bigger],
     ['>=', BinaryOperator.BiggerEquals],
+    ['|', BinaryOperator.BitwiseOr],
     ['&', BinaryOperator.BitwiseAnd],
     ['/', BinaryOperator.Divide],
     ['==', BinaryOperator.Equals],
@@ -11921,7 +11942,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);
             }
         }
@@ -12018,7 +12039,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).
@@ -12039,7 +12060,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');
@@ -12065,13 +12086,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];
 }
@@ -13126,7 +13144,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);
@@ -20566,6 +20584,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;
                 }
@@ -21030,14 +21049,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);
                 }
@@ -21416,9 +21435,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([
@@ -21562,10 +21579,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);
 }
@@ -22150,7 +22170,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:
@@ -22339,42 +22359,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(BinaryOperator.Identical, new LexicalReadExpr(repeaterOp.varNames.$index), literal(0));
-                    case DerivedRepeaterVarIdentity.Last:
-                        return new BinaryOperatorExpr(BinaryOperator.Identical, new LexicalReadExpr(repeaterOp.varNames.$index), new BinaryOperatorExpr(BinaryOperator.Minus, new LexicalReadExpr(repeaterOp.varNames.$count), literal(1)));
-                    case DerivedRepeaterVarIdentity.Even:
-                        return new BinaryOperatorExpr(BinaryOperator.Identical, new BinaryOperatorExpr(BinaryOperator.Modulo, new LexicalReadExpr(repeaterOp.varNames.$index), literal(2)), literal(0));
-                    case DerivedRepeaterVarIdentity.Odd:
-                        return new BinaryOperatorExpr(BinaryOperator.NotIdentical, new BinaryOperatorExpr(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
@@ -23959,7 +23943,6 @@ const phases = [
     { 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 },
@@ -24377,6 +24360,10 @@ function ingestIfBlock(unit, ifBlock) {
  * Ingest an `@switch` block into the given `ViewCompilation`.
  */
 function ingestSwitchBlock(unit, switchBlock) {
+    // Don't ingest empty switches since they won't render anything.
+    if (switchBlock.cases.length === 0) {
+        return;
+    }
     let firstXref = null;
     let firstSlotHandle = null;
     let conditions = [];
@@ -24533,22 +24520,43 @@ function ingestIcu(unit, icu) {
  */
 function ingestForBlock(unit, forBlock) {
     const repeaterView = unit.job.allocateView(unit.xref);
-    const createRepeaterAlias = (ident, repeaterVar) => {
-        repeaterView.aliases.add({
-            kind: SemanticVariableKind.Alias,
-            name: null,
-            identifier: ident,
-            expression: new DerivedRepeaterVarExpr(repeaterView.xref, repeaterVar),
-        });
-    };
     // Set all the context variables and aliases available in the repeater.
     repeaterView.contextVariables.set(forBlock.item.name, forBlock.item.value);
     repeaterView.contextVariables.set(forBlock.contextVariables.$index.name, forBlock.contextVariables.$index.value);
     repeaterView.contextVariables.set(forBlock.contextVariables.$count.name, forBlock.contextVariables.$count.value);
-    createRepeaterAlias(forBlock.contextVariables.$first.name, DerivedRepeaterVarIdentity.First);
-    createRepeaterAlias(forBlock.contextVariables.$last.name, DerivedRepeaterVarIdentity.Last);
-    createRepeaterAlias(forBlock.contextVariables.$even.name, DerivedRepeaterVarIdentity.Even);
-    createRepeaterAlias(forBlock.contextVariables.$odd.name, DerivedRepeaterVarIdentity.Odd);
+    // We copy TemplateDefinitionBuilder's scheme of creating names for `$count` and `$index` that are
+    // suffixed with special information, to disambiguate which level of nested loop the below aliases
+    // refer to.
+    // TODO: We should refactor Template Pipeline's variable phases to gracefully handle shadowing,
+    // and arbitrarily many levels of variables depending on each other.
+    const indexName = `ɵ${forBlock.contextVariables.$index.name}_${repeaterView.xref}`;
+    const countName = `ɵ${forBlock.contextVariables.$count.name}_${repeaterView.xref}`;
+    repeaterView.contextVariables.set(indexName, forBlock.contextVariables.$index.value);
+    repeaterView.contextVariables.set(countName, forBlock.contextVariables.$count.value);
+    repeaterView.aliases.add({
+        kind: SemanticVariableKind.Alias,
+        name: null,
+        identifier: forBlock.contextVariables.$first.name,
+        expression: new LexicalReadExpr(indexName).identical(literal(0))
+    });
+    repeaterView.aliases.add({
+        kind: SemanticVariableKind.Alias,
+        name: null,
+        identifier: forBlock.contextVariables.$last.name,
+        expression: new LexicalReadExpr(indexName).identical(new LexicalReadExpr(countName).minus(literal(1)))
+    });
+    repeaterView.aliases.add({
+        kind: SemanticVariableKind.Alias,
+        name: null,
+        identifier: forBlock.contextVariables.$even.name,
+        expression: new LexicalReadExpr(indexName).modulo(literal(2)).identical(literal(0))
+    });
+    repeaterView.aliases.add({
+        kind: SemanticVariableKind.Alias,
+        name: null,
+        identifier: forBlock.contextVariables.$odd.name,
+        expression: new LexicalReadExpr(indexName).modulo(literal(2)).notIdentical(literal(0))
+    });
     const sourceSpan = convertSourceSpan(forBlock.trackBy.span, forBlock.sourceSpan);
     const track = convertAst(forBlock.trackBy, unit.job, sourceSpan);
     ingestNodes(repeaterView, forBlock.children);
@@ -24837,7 +24845,7 @@ function ingestTemplateBindings(unit, op, template, templateKind) {
             output.type !== 1 /* e.ParsedEventType.Animation */) {
             // Animation bindings are excluded from the structural template's const array.
             const securityContext = domSchema.securityContext(NG_TEMPLATE_TAG_NAME$1, output.name, false);
-            unit.create.push(createExtractedAttributeOp(op.xref, BindingKind.Property, output.name, null, null, null, securityContext));
+            unit.create.push(createExtractedAttributeOp(op.xref, BindingKind.Property, null, output.name, null, null, null, securityContext));
         }
     }
     // TODO: Perhaps we could do this in a phase? (It likely wouldn't change the slot indices.)
@@ -24885,7 +24893,7 @@ function createTemplateBinding(view, xref, type, name, value, unit, securityCont
             // inner node of a structural template. We can't skip it entirely, because we still need it on
             // the ng-template's consts (e.g. for the purposes of directive matching). However, we should
             // not generate an update instruction for it.
-            return createExtractedAttributeOp(xref, BindingKind.Property, name, null, null, i18nMessage, securityContext);
+            return createExtractedAttributeOp(xref, BindingKind.Property, null, name, null, null, i18nMessage, securityContext);
         }
         if (!isTextBinding && (type === 1 /* e.BindingType.Attribute */ || type === 4 /* e.BindingType.Animation */)) {
             // Again, this binding doesn't really target the ng-template; it actually targets the element
@@ -27811,7 +27819,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;
@@ -27822,6 +27830,7 @@ class TemplateDefinitionBuilder {
         this.i18nUseExternalIds = i18nUseExternalIds;
         this.deferBlocks = deferBlocks;
         this.elementLocations = elementLocations;
+        this.allDeferrableDepsFn = allDeferrableDepsFn;
         this._constants = _constants;
         this._dataIndex = 0;
         this._bindingContext = 0;
@@ -28476,7 +28485,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
@@ -28687,6 +28696,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 => {
@@ -28761,7 +28773,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),
@@ -29150,7 +29162,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;
         }
     }
@@ -30123,6 +30135,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, StmtModifier.Final));
+    return variable(name);
+}
 /**
  * Compile a component for the render3 runtime as defined by the `R3ComponentMetadata`.
  */
@@ -30147,8 +30177,14 @@ function compileComponentFromMetadata(meta, constantPool, bindingParser) {
     if (!USE_TEMPLATE_PIPELINE) {
         // 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
@@ -30879,7 +30915,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);
     }
 }
 /**
@@ -30897,6 +30933,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.
          */
@@ -30953,6 +30993,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
@@ -31446,7 +31487,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;
@@ -31459,6 +31500,7 @@ class R3BoundTarget {
         this.usedPipes = usedPipes;
         this.eagerPipes = eagerPipes;
         this.deferredBlocks = deferredBlocks;
+        this.rootScope = rootScope;
     }
     getEntitiesInScope(node) {
         return this.scopedNodeEntities.get(node) ?? new Set();
@@ -31548,6 +31590,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.
@@ -31736,9 +31787,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,
@@ -31849,8 +31900,10 @@ function convertDirectiveFacadeToMetadata(facade) {
                         bindingPropertyName: ann.alias || field,
                         classPropertyName: field,
                         required: ann.required || false,
-                        // TODO(signals): Support JIT signal inputs via decorator transform.
-                        isSignal: 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,
                     };
                 }
@@ -31972,9 +32025,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 ?? ChangeDetectionStrategy.Default,
         encapsulation: decl.encapsulation ?? ViewEncapsulation.Emulated,
         interpolation,
@@ -32262,7 +32315,7 @@ function publishFacade(global) {
  * @description
  * Entry point for all public APIs of the compiler package.
  */
-const VERSION = new Version('17.1.0-next.5');
+const VERSION = new Version('17.1.0');
 
 class CompilerConfig {
     constructor({ defaultEncapsulation = ViewEncapsulation.Emulated, preserveWhitespaces, strictInjectionParameters } = {}) {
@@ -33757,7 +33810,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);
     }
@@ -33828,7 +33881,7 @@ const MINIMUM_PARTIAL_LINKER_VERSION$5 = '12.0.0';
 function compileDeclareClassMetadata(metadata) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$5));
-    definitionMap.set('version', literal('17.1.0-next.5'));
+    definitionMap.set('version', literal('17.1.0'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', metadata.type);
     definitionMap.set('decorators', metadata.decorators);
@@ -33924,7 +33977,7 @@ function createDirectiveDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     const minVersion = getMinimumVersionForPartialOutput(meta);
     definitionMap.set('minVersion', literal(minVersion));
-    definitionMap.set('version', literal('17.1.0-next.5'));
+    definitionMap.set('version', literal('17.1.0'));
     // e.g. `type: MyDirective`
     definitionMap.set('type', meta.type.value);
     if (meta.isStandalone) {
@@ -33982,8 +34035,8 @@ function getMinimumVersionForPartialOutput(meta) {
     // 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 hasTransformFunctions = Object.values(meta.inputs).some(input => input.transformFunction !== null);
-    if (hasTransformFunctions) {
+    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,
@@ -34308,7 +34361,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.1.0-next.5'));
+    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));
@@ -34343,7 +34396,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.1.0-next.5'));
+    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
@@ -34394,7 +34447,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.1.0-next.5'));
+    definitionMap.set('version', literal('17.1.0'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('providers', meta.providers);
@@ -34427,7 +34480,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.1.0-next.5'));
+    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.
@@ -34478,7 +34531,7 @@ function compileDeclarePipeFromMetadata(meta) {
 function createPipeDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION));
-    definitionMap.set('version', literal('17.1.0-next.5'));
+    definitionMap.set('version', literal('17.1.0'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     // e.g. `type: MyPipe`
     definitionMap.set('type', meta.type.value);