@angular/compiler 16.1.0-next.3 → 16.1.0-rc.0

package/fesm2022/compiler.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v16.1.0-next.3
+ * @license Angular v16.1.0-rc.0
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -2272,6 +2272,7 @@ class ConstantPool {
         this.statements = [];
         this.literals = new Map();
         this.literalFactories = new Map();
+        this.sharedConstants = new Map();
         this.nextNameIndex = 0;
     }
     getConstLiteral(literal, forceShared) {
@@ -2281,7 +2282,7 @@ class ConstantPool {
             // reference to a constant.
             return literal;
         }
-        const key = this.keyOf(literal);
+        const key = GenericKeyFn.INSTANCE.keyOf(literal);
         let fixup = this.literals.get(key);
         let newValue = false;
         if (!fixup) {
@@ -2326,11 +2327,20 @@ class ConstantPool {
         }
         return fixup;
     }
+    getSharedConstant(def, expr) {
+        const key = def.keyOf(expr);
+        if (!this.sharedConstants.has(key)) {
+            const id = this.freshName();
+            this.sharedConstants.set(key, variable(id));
+            this.statements.push(def.toSharedConstantDeclaration(id, expr));
+        }
+        return this.sharedConstants.get(key);
+    }
     getLiteralFactory(literal) {
         // Create a pure function that builds an array of a mix of constant and variable expressions
         if (literal instanceof LiteralArrayExpr) {
             const argumentsForKey = literal.entries.map(e => e.isConstant() ? e : UNKNOWN_VALUE_KEY);
-            const key = this.keyOf(literalArr(argumentsForKey));
+            const key = GenericKeyFn.INSTANCE.keyOf(literalArr(argumentsForKey));
             return this._getLiteralFactory(key, literal.entries, entries => literalArr(entries));
         }
         else {
@@ -2339,7 +2349,7 @@ class ConstantPool {
                 value: e.value.isConstant() ? e.value : UNKNOWN_VALUE_KEY,
                 quoted: e.quoted
             })));
-            const key = this.keyOf(expressionForKey);
+            const key = GenericKeyFn.INSTANCE.keyOf(expressionForKey);
             return this._getLiteralFactory(key, literal.entries.map(e => e.value), entries => literalMap(entries.map((value, index) => ({
                 key: literal.entries[index].key,
                 value,
@@ -2376,65 +2386,48 @@ class ConstantPool {
     freshName() {
         return this.uniqueName(CONSTANT_PREFIX);
     }
-    keyOf(expression) {
-        return expression.visitExpression(new KeyVisitor(), KEY_CONTEXT);
-    }
 }
-/**
- * Visitor used to determine if 2 expressions are equivalent and can be shared in the
- * `ConstantPool`.
- *
- * When the id (string) generated by the visitor is equal, expressions are considered equivalent.
- */
-class KeyVisitor {
-    constructor() {
-        this.visitWrappedNodeExpr = invalid$1;
-        this.visitWriteVarExpr = invalid$1;
-        this.visitWriteKeyExpr = invalid$1;
-        this.visitWritePropExpr = invalid$1;
-        this.visitInvokeFunctionExpr = invalid$1;
-        this.visitTaggedTemplateExpr = invalid$1;
-        this.visitInstantiateExpr = invalid$1;
-        this.visitConditionalExpr = invalid$1;
-        this.visitNotExpr = invalid$1;
-        this.visitAssertNotNullExpr = invalid$1;
-        this.visitCastExpr = invalid$1;
-        this.visitFunctionExpr = invalid$1;
-        this.visitUnaryOperatorExpr = invalid$1;
-        this.visitBinaryOperatorExpr = invalid$1;
-        this.visitReadPropExpr = invalid$1;
-        this.visitReadKeyExpr = invalid$1;
-        this.visitCommaExpr = invalid$1;
-        this.visitLocalizedString = invalid$1;
-    }
-    visitLiteralExpr(ast) {
-        return `${typeof ast.value === 'string' ? '"' + ast.value + '"' : ast.value}`;
-    }
-    visitLiteralArrayExpr(ast, context) {
-        return `[${ast.entries.map(entry => entry.visitExpression(this, context)).join(',')}]`;
-    }
-    visitLiteralMapExpr(ast, context) {
-        const mapKey = (entry) => {
-            const quote = entry.quoted ? '"' : '';
-            return `${quote}${entry.key}${quote}`;
-        };
-        const mapEntry = (entry) => `${mapKey(entry)}:${entry.value.visitExpression(this, context)}`;
-        return `{${ast.entries.map(mapEntry).join(',')}`;
-    }
-    visitExternalExpr(ast) {
-        return ast.value.moduleName ? `EX:${ast.value.moduleName}:${ast.value.name}` :
-            `EX:${ast.value.runtime.name}`;
-    }
-    visitReadVarExpr(node) {
-        return `VAR:${node.name}`;
-    }
-    visitTypeofExpr(node, context) {
-        return `TYPEOF:${node.expr.visitExpression(this, context)}`;
+class GenericKeyFn {
+    static { this.INSTANCE = new GenericKeyFn(); }
+    keyOf(expr) {
+        if (expr instanceof LiteralExpr && typeof expr.value === 'string') {
+            return `"${expr.value}"`;
+        }
+        else if (expr instanceof LiteralExpr) {
+            return String(expr.value);
+        }
+        else if (expr instanceof LiteralArrayExpr) {
+            const entries = [];
+            for (const entry of expr.entries) {
+                entries.push(this.keyOf(entry));
+            }
+            return `[${entries.join(',')}]`;
+        }
+        else if (expr instanceof LiteralMapExpr) {
+            const entries = [];
+            for (const entry of expr.entries) {
+                let key = entry.key;
+                if (entry.quoted) {
+                    key = `"${key}"`;
+                }
+                entries.push(key + ':' + this.keyOf(entry.value));
+            }
+            return `{${entries.join(',')}}`;
+        }
+        else if (expr instanceof ExternalExpr) {
+            return `import("${expr.value.moduleName}", ${expr.value.name})`;
+        }
+        else if (expr instanceof ReadVarExpr) {
+            return `read(${expr.name})`;
+        }
+        else if (expr instanceof TypeofExpr) {
+            return `typeof(${this.keyOf(expr.expr)})`;
+        }
+        else {
+            throw new Error(`${this.constructor.name} does not handle expressions of type ${expr.constructor.name}`);
+        }
     }
 }
-function invalid$1(arg) {
-    throw new Error(`Invalid state: Visitor ${this.constructor.name} doesn't handle ${arg.constructor.name}`);
-}
 function isVariable(e) {
     return e instanceof ReadVarExpr;
 }
@@ -7508,11 +7501,28 @@ class ShadowCss {
      * The hostSelector is the attribute added to the host itself.
      */
     shimCssText(cssText, selector, hostSelector = '') {
-        const commentsWithHash = extractCommentsWithHash(cssText);
-        cssText = stripComments(cssText);
+        // **NOTE**: Do not strip comments as this will cause component sourcemaps to break
+        // due to shift in lines.
+        // Collect comments and replace them with a placeholder, this is done to avoid complicating
+        // the rule parsing RegExp and keep it safer.
+        const comments = [];
+        cssText = cssText.replace(_commentRe, (m) => {
+            if (m.match(_commentWithHashRe)) {
+                comments.push(m);
+            }
+            else {
+                // Replace non hash comments with empty lines.
+                // This is done so that we do not leak any senstive data in comments.
+                const newLinesMatches = m.match(_newLinesRe);
+                comments.push((newLinesMatches?.join('') ?? '') + '\n');
+            }
+            return COMMENT_PLACEHOLDER;
+        });
         cssText = this._insertDirectives(cssText);
         const scopedCssText = this._scopeCssText(cssText, selector, hostSelector);
-        return [scopedCssText, ...commentsWithHash].join('\n');
+        // Add back comments at the original position.
+        let commentIdx = 0;
+        return scopedCssText.replace(_commentWithHashPlaceHolderRe, () => comments[commentIdx++]);
     }
     _insertDirectives(cssText) {
         cssText = this._insertPolyfillDirectivesInCssText(cssText);
@@ -7753,7 +7763,7 @@ class ShadowCss {
         return cssText.replace(_cssColonHostRe, (_, hostSelectors, otherSelectors) => {
             if (hostSelectors) {
                 const convertedSelectors = [];
-                const hostSelectorArray = hostSelectors.split(',').map(p => p.trim());
+                const hostSelectorArray = hostSelectors.split(',').map((p) => p.trim());
                 for (const hostSelector of hostSelectorArray) {
                     if (!hostSelector)
                         break;
@@ -7783,7 +7793,7 @@ class ShadowCss {
      * .foo<scopeName> .bar { ... }
      */
     _convertColonHostContext(cssText) {
-        return cssText.replace(_cssColonHostContextReGlobal, selectorText => {
+        return cssText.replace(_cssColonHostContextReGlobal, (selectorText) => {
             // We have captured a selector that contains a `:host-context` rule.
             // For backward compatibility `:host-context` may contain a comma separated list of selectors.
             // Each context selector group will contain a list of host-context selectors that must match
@@ -7795,10 +7805,10 @@ class ShadowCss {
             // Execute `_cssColonHostContextRe` over and over until we have extracted all the
             // `:host-context` selectors from this selector.
             let match;
-            while (match = _cssColonHostContextRe.exec(selectorText)) {
+            while ((match = _cssColonHostContextRe.exec(selectorText))) {
                 // `match` = [':host-context(<selectors>)<rest>', <selectors>, <rest>]
                 // The `<selectors>` could actually be a comma separated list: `:host-context(.one, .two)`.
-                const newContextSelectors = (match[1] ?? '').trim().split(',').map(m => m.trim()).filter(m => m !== '');
+                const newContextSelectors = (match[1] ?? '').trim().split(',').map((m) => m.trim()).filter((m) => m !== '');
                 // We must duplicate the current selector group for each of these new selectors.
                 // For example if the current groups are:
                 // ```
@@ -7821,7 +7831,7 @@ class ShadowCss {
                 repeatGroups(contextSelectorGroups, newContextSelectors.length);
                 for (let i = 0; i < newContextSelectors.length; i++) {
                     for (let j = 0; j < contextSelectorGroupsLength; j++) {
-                        contextSelectorGroups[j + (i * contextSelectorGroupsLength)].push(newContextSelectors[i]);
+                        contextSelectorGroups[j + i * contextSelectorGroupsLength].push(newContextSelectors[i]);
                     }
                 }
                 // Update the `selectorText` and see repeat to see if there are more `:host-context`s.
@@ -7831,7 +7841,7 @@ class ShadowCss {
             // selectors that `:host-context` can match. See `combineHostContextSelectors()` for more
             // info about how this is done.
             return contextSelectorGroups
-                .map(contextSelectors => combineHostContextSelectors(contextSelectors, selectorText))
+                .map((contextSelectors) => combineHostContextSelectors(contextSelectors, selectorText))
                 .join(', ');
         });
     }
@@ -7883,7 +7893,7 @@ class ShadowCss {
      * ```
      */
     _stripScopingSelectors(cssText) {
-        return processRules(cssText, rule => {
+        return processRules(cssText, (rule) => {
             const selector = rule.selector.replace(_shadowDeepSelectors, ' ')
                 .replace(_polyfillHostNoCombinatorRe, ' ');
             return new CssRule(selector, rule.content);
@@ -7891,7 +7901,7 @@ class ShadowCss {
     }
     _scopeSelector(selector, scopeSelector, hostSelector) {
         return selector.split(',')
-            .map(part => part.trim().split(_shadowDeepSelectors))
+            .map((part) => part.trim().split(_shadowDeepSelectors))
             .map((deepParts) => {
             const [shallowPart, ...otherParts] = deepParts;
             const applyScope = (shallowPart) => {
@@ -8074,17 +8084,14 @@ const _selectorReSuffix = '([>\\s~+[.,{:][\\s\\S]*)?$';
 const _polyfillHostRe = /-shadowcsshost/gim;
 const _colonHostRe = /:host/gim;
 const _colonHostContextRe = /:host-context/gim;
+const _newLinesRe = /\r?\n/g;
 const _commentRe = /\/\*[\s\S]*?\*\//g;
+const _commentWithHashRe = /\/\*\s*#\s*source(Mapping)?URL=/g;
+const COMMENT_PLACEHOLDER = '%COMMENT%';
+const _commentWithHashPlaceHolderRe = new RegExp(COMMENT_PLACEHOLDER, 'g');
 const _placeholderRe = /__ph-(\d+)__/g;
-function stripComments(input) {
-    return input.replace(_commentRe, '');
-}
-const _commentWithHashRe = /\/\*\s*#\s*source(Mapping)?URL=[\s\S]+?\*\//g;
-function extractCommentsWithHash(input) {
-    return input.match(_commentWithHashRe) || [];
-}
 const BLOCK_PLACEHOLDER = '%BLOCK%';
-const _ruleRe = /(\s*)([^;\{\}]+?)(\s*)((?:{%BLOCK%}?\s*;?)|(?:\s*;))/g;
+const _ruleRe = new RegExp(`(\\s*(?:${COMMENT_PLACEHOLDER}\\s*)*)([^;\\{\\}]+?)(\\s*)((?:{%BLOCK%}?\\s*;?)|(?:\\s*;))`, 'g');
 const CONTENT_PAIRS = new Map([['{', '}']]);
 const COMMA_IN_PLACEHOLDER = '%COMMA_IN_PLACEHOLDER%';
 const SEMI_IN_PLACEHOLDER = '%SEMI_IN_PLACEHOLDER%';
@@ -8293,7 +8300,6 @@ function unescapeQuotes(str, isQuoted) {
  *
  * And so on...
  *
- * @param hostMarker the string that selects the host element.
  * @param contextSelectors an array of context selectors that will be combined.
  * @param otherSelectors the rest of the selectors that are not context selectors.
  */
@@ -8538,10 +8544,18 @@ var OpKind;
      * An operation to bind an expression to a property of an element.
      */
     OpKind[OpKind["Property"] = 13] = "Property";
+    /**
+     * An operation to interpolate text into a property binding.
+     */
+    OpKind[OpKind["InterpolateProperty"] = 14] = "InterpolateProperty";
     /**
      * An operation to advance the runtime's implicit slot context during the update phase of a view.
      */
-    OpKind[OpKind["Advance"] = 14] = "Advance";
+    OpKind[OpKind["Advance"] = 15] = "Advance";
+    /**
+     * An operation to instantiate a pipe.
+     */
+    OpKind[OpKind["Pipe"] = 16] = "Pipe";
 })(OpKind || (OpKind = {}));
 /**
  * Distinguishes different kinds of IR expressions.
@@ -8580,6 +8594,22 @@ var ExpressionKind;
      * Runtime operation to reset the current view context after `RestoreView`.
      */
     ExpressionKind[ExpressionKind["ResetView"] = 7] = "ResetView";
+    /**
+     * Defines and calls a function with change-detected arguments.
+     */
+    ExpressionKind[ExpressionKind["PureFunctionExpr"] = 8] = "PureFunctionExpr";
+    /**
+     * Indicates a positional parameter to a pure function definition.
+     */
+    ExpressionKind[ExpressionKind["PureFunctionParameterExpr"] = 9] = "PureFunctionParameterExpr";
+    /**
+     * Binding to a pipe transformation.
+     */
+    ExpressionKind[ExpressionKind["PipeBinding"] = 10] = "PipeBinding";
+    /**
+     * Binding to a pipe transformation with a variable number of arguments.
+     */
+    ExpressionKind[ExpressionKind["PipeBindingVariadic"] = 11] = "PipeBindingVariadic";
 })(ExpressionKind || (ExpressionKind = {}));
 /**
  * Distinguishes between different kinds of `SemanticVariable`s.
@@ -8615,7 +8645,11 @@ const UsesSlotIndex = Symbol('UsesSlotIndex');
 /**
  * Marker symbol for `ConsumesVars` trait.
  */
-const ConsumesVarsTrait = Symbol('UsesVars');
+const ConsumesVarsTrait = Symbol('ConsumesVars');
+/**
+ * Marker symbol for `UsesVarOffset` trait.
+ */
+const UsesVarOffset = Symbol('UsesVarOffset');
 /**
  * Default values for most `ConsumesSlotOpTrait` fields (used with the spread operator to initialize
  * implementors of the trait).
@@ -8647,6 +8681,14 @@ const TRAIT_DEPENDS_ON_SLOT_CONTEXT = {
 const TRAIT_CONSUMES_VARS = {
     [ConsumesVarsTrait]: true,
 };
+/**
+ * Default values for `UsesVarOffset` fields (used with the spread operator to initialize
+ * implementors of this trait).
+ */
+const TRAIT_USES_VAR_OFFSET = {
+    [UsesVarOffset]: true,
+    varOffset: null,
+};
 /**
  * Test whether an operation implements `ConsumesSlotOpTrait`.
  */
@@ -8662,11 +8704,17 @@ function hasDependsOnSlotContextTrait(op) {
 function hasConsumesVarsTrait(value) {
     return value[ConsumesVarsTrait] === true;
 }
+/**
+ * Test whether an expression implements `UsesVarOffsetTrait`.
+ */
+function hasUsesVarOffsetTrait(expr) {
+    return expr[UsesVarOffset] === true;
+}
 function hasUsesSlotIndexTrait(value) {
     return value[UsesSlotIndex] === true;
 }
 
-var _a;
+var _a, _b, _c, _d, _e, _f, _g, _h, _j;
 /**
  * Check whether a given `o.Expression` is a logical IR expression type.
  */
@@ -8852,6 +8900,125 @@ class ReadVariableExpr extends ExpressionBase {
     }
     transformInternalExpressions() { }
 }
+class PureFunctionExpr extends ExpressionBase {
+    static { _b = ConsumesVarsTrait, _c = UsesVarOffset; }
+    constructor(expression, args) {
+        super();
+        this.kind = ExpressionKind.PureFunctionExpr;
+        this[_b] = true;
+        this[_c] = true;
+        this.varOffset = null;
+        /**
+         * Once extracted to the `ConstantPool`, a reference to the function which defines the computation
+         * of `body`.
+         */
+        this.fn = null;
+        this.body = expression;
+        this.args = args;
+    }
+    visitExpression(visitor, context) {
+        this.body?.visitExpression(visitor, context);
+        for (const arg of this.args) {
+            arg.visitExpression(visitor, context);
+        }
+    }
+    isEquivalent(other) {
+        if (!(other instanceof PureFunctionExpr) || other.args.length !== this.args.length) {
+            return false;
+        }
+        return other.body !== null && this.body !== null && other.body.isEquivalent(this.body) &&
+            other.args.every((arg, idx) => arg.isEquivalent(this.args[idx]));
+    }
+    isConstant() {
+        return false;
+    }
+    transformInternalExpressions(transform, flags) {
+        if (this.body !== null) {
+            // TODO: figure out if this is the right flag to pass here.
+            this.body = transformExpressionsInExpression(this.body, transform, flags | VisitorContextFlag.InChildOperation);
+        }
+        else if (this.fn !== null) {
+            this.fn = transformExpressionsInExpression(this.fn, transform, flags);
+        }
+        for (let i = 0; i < this.args.length; i++) {
+            this.args[i] = transformExpressionsInExpression(this.args[i], transform, flags);
+        }
+    }
+}
+class PureFunctionParameterExpr extends ExpressionBase {
+    constructor(index) {
+        super();
+        this.index = index;
+        this.kind = ExpressionKind.PureFunctionParameterExpr;
+    }
+    visitExpression() { }
+    isEquivalent(other) {
+        return other instanceof PureFunctionParameterExpr && other.index === this.index;
+    }
+    isConstant() {
+        return true;
+    }
+    transformInternalExpressions() { }
+}
+class PipeBindingExpr extends ExpressionBase {
+    static { _d = UsesSlotIndex, _e = ConsumesVarsTrait, _f = UsesVarOffset; }
+    constructor(target, name, args) {
+        super();
+        this.target = target;
+        this.name = name;
+        this.args = args;
+        this.kind = ExpressionKind.PipeBinding;
+        this[_d] = true;
+        this[_e] = true;
+        this[_f] = true;
+        this.slot = null;
+        this.varOffset = null;
+    }
+    visitExpression(visitor, context) {
+        for (const arg of this.args) {
+            arg.visitExpression(visitor, context);
+        }
+    }
+    isEquivalent() {
+        return false;
+    }
+    isConstant() {
+        return false;
+    }
+    transformInternalExpressions(transform, flags) {
+        for (let idx = 0; idx < this.args.length; idx++) {
+            this.args[idx] = transformExpressionsInExpression(this.args[idx], transform, flags);
+        }
+    }
+}
+class PipeBindingVariadicExpr extends ExpressionBase {
+    static { _g = UsesSlotIndex, _h = ConsumesVarsTrait, _j = UsesVarOffset; }
+    constructor(target, name, args, numArgs) {
+        super();
+        this.target = target;
+        this.name = name;
+        this.args = args;
+        this.numArgs = numArgs;
+        this.kind = ExpressionKind.PipeBindingVariadic;
+        this[_g] = true;
+        this[_h] = true;
+        this[_j] = true;
+        this.slot = null;
+        this.varOffset = null;
+    }
+    visitExpression(visitor, context) {
+        this.args.visitExpression(visitor, context);
+    }
+    isEquivalent() {
+        return false;
+    }
+    isConstant() {
+        return false;
+    }
+    transformInternalExpressions(transform, flags) {
+        this.args = transformExpressionsInExpression(this.args, transform, flags);
+    }
+}
 /**
  * Visits all `Expression`s in the AST of `op` with the `visitor` function.
  */
@@ -8877,6 +9044,11 @@ function transformExpressionsInOp(op, transform, flags) {
         case OpKind.Property:
             op.expression = transformExpressionsInExpression(op.expression, transform, flags);
             break;
+        case OpKind.InterpolateProperty:
+            for (let i = 0; i < op.expressions.length; i++) {
+                op.expressions[i] = transformExpressionsInExpression(op.expressions[i], transform, flags);
+            }
+            break;
         case OpKind.Statement:
             transformExpressionsInStatement(op.statement, transform, flags);
             break;
@@ -8901,6 +9073,7 @@ function transformExpressionsInOp(op, transform, flags) {
         case OpKind.ContainerEnd:
         case OpKind.Template:
         case OpKind.Text:
+        case OpKind.Pipe:
         case OpKind.Advance:
             // These operations contain no expressions.
             break;
@@ -8917,7 +9090,6 @@ function transformExpressionsInOp(op, transform, flags) {
 function transformExpressionsInExpression(expr, transform, flags) {
     if (expr instanceof ExpressionBase) {
         expr.transformInternalExpressions(transform, flags);
-        return transform(expr, flags);
     }
     else if (expr instanceof BinaryOperatorExpr) {
         expr.lhs = transformExpressionsInExpression(expr.lhs, transform, flags);
@@ -8930,12 +9102,39 @@ function transformExpressionsInExpression(expr, transform, flags) {
         expr.receiver = transformExpressionsInExpression(expr.receiver, transform, flags);
         expr.index = transformExpressionsInExpression(expr.index, transform, flags);
     }
+    else if (expr instanceof WritePropExpr) {
+        expr.receiver = transformExpressionsInExpression(expr.receiver, transform, flags);
+        expr.value = transformExpressionsInExpression(expr.value, transform, flags);
+    }
+    else if (expr instanceof WriteKeyExpr) {
+        expr.receiver = transformExpressionsInExpression(expr.receiver, transform, flags);
+        expr.index = transformExpressionsInExpression(expr.index, transform, flags);
+        expr.value = transformExpressionsInExpression(expr.value, transform, flags);
+    }
     else if (expr instanceof InvokeFunctionExpr) {
         expr.fn = transformExpressionsInExpression(expr.fn, transform, flags);
         for (let i = 0; i < expr.args.length; i++) {
             expr.args[i] = transformExpressionsInExpression(expr.args[i], transform, flags);
         }
     }
+    else if (expr instanceof LiteralArrayExpr) {
+        for (let i = 0; i < expr.entries.length; i++) {
+            expr.entries[i] = transformExpressionsInExpression(expr.entries[i], transform, flags);
+        }
+    }
+    else if (expr instanceof LiteralMapExpr) {
+        for (let i = 0; i < expr.entries.length; i++) {
+            expr.entries[i].value =
+                transformExpressionsInExpression(expr.entries[i].value, transform, flags);
+        }
+    }
+    else if (expr instanceof ConditionalExpr) {
+        expr.condition = transformExpressionsInExpression(expr.condition, transform, flags);
+        expr.trueCase = transformExpressionsInExpression(expr.trueCase, transform, flags);
+        if (expr.falseCase !== null) {
+            expr.falseCase = transformExpressionsInExpression(expr.falseCase, transform, flags);
+        }
+    }
     else if (expr instanceof ReadVarExpr || expr instanceof ExternalExpr ||
         expr instanceof LiteralExpr) {
         // No action for these types.
@@ -8943,7 +9142,7 @@ function transformExpressionsInExpression(expr, transform, flags) {
     else {
         throw new Error(`Unhandled expression kind: ${expr.constructor.name}`);
     }
-    return expr;
+    return transform(expr, flags);
 }
 /**
  * Transform all `Expression`s in the AST of `stmt` with the `transform` function.
@@ -9144,10 +9343,12 @@ class OpList {
      * Insert `op` before `before`.
      */
     static insertBefore(op, before) {
-        OpList.assertIsNotEnd(before);
+        OpList.assertIsOwned(before);
+        if (before.prev === null) {
+            throw new Error(`AssertionError: illegal operation on list start`);
+        }
         OpList.assertIsNotEnd(op);
         OpList.assertIsUnowned(op);
-        OpList.assertIsOwned(before);
         op.debugListId = before.debugListId;
         // Just in case.
         op.prev = null;
@@ -9287,6 +9488,15 @@ function createListenerOp(target, name, tag) {
         ...TRAIT_USES_SLOT_INDEX,
     };
 }
+function createPipeOp(xref, name) {
+    return {
+        kind: OpKind.Pipe,
+        xref,
+        name,
+        ...NEW_OP,
+        ...TRAIT_CONSUMES_SLOT,
+    };
+}
 
 /**
  * Create an `InterpolationTextOp`.
@@ -9316,6 +9526,21 @@ function createPropertyOp(xref, name, expression) {
         ...NEW_OP,
     };
 }
+/**
+ * Create a `InterpolateProperty`.
+ */
+function createInterpolatePropertyOp(xref, name, strings, expressions) {
+    return {
+        kind: OpKind.InterpolateProperty,
+        target: xref,
+        name,
+        strings,
+        expressions,
+        ...TRAIT_DEPENDS_ON_SLOT_CONTEXT,
+        ...TRAIT_CONSUMES_VARS,
+        ...NEW_OP,
+    };
+}
 /**
  * Create an `AdvanceOp`.
  */
@@ -9500,6 +9725,12 @@ function listener(name, handlerFn) {
         handlerFn,
     ]);
 }
+function pipe(slot, name) {
+    return call(Identifiers.pipe, [
+        literal(slot),
+        literal(name),
+    ]);
+}
 function advance(delta) {
     return call(Identifiers.advance, [
         literal(delta),
@@ -9539,6 +9770,30 @@ function property(name, expression) {
         expression,
     ]);
 }
+const PIPE_BINDINGS = [
+    Identifiers.pipeBind1,
+    Identifiers.pipeBind2,
+    Identifiers.pipeBind3,
+    Identifiers.pipeBind4,
+];
+function pipeBind(slot, varOffset, args) {
+    if (args.length < 1 || args.length > PIPE_BINDINGS.length) {
+        throw new Error(`pipeBind() argument count out of bounds`);
+    }
+    const instruction = PIPE_BINDINGS[args.length - 1];
+    return importExpr(instruction).callFn([
+        literal(slot),
+        literal(varOffset),
+        ...args,
+    ]);
+}
+function pipeBindV(slot, varOffset, args) {
+    return importExpr(Identifiers.pipeBindV).callFn([
+        literal(slot),
+        literal(varOffset),
+        args,
+    ]);
+}
 function textInterpolate(strings, expressions) {
     if (strings.length < 1 || expressions.length !== strings.length - 1) {
         throw new Error(`AssertionError: expected specific shape of args for strings/expressions in interpolation`);
@@ -9555,7 +9810,31 @@ function textInterpolate(strings, expressions) {
         // idx points at the last string.
         interpolationArgs.push(literal(strings[idx]));
     }
-    return callInterpolation(TEXT_INTERPOLATE_CONFIG, [], interpolationArgs);
+    return callVariadicInstruction(TEXT_INTERPOLATE_CONFIG, [], interpolationArgs);
+}
+function propertyInterpolate(name, strings, expressions) {
+    if (strings.length < 1 || expressions.length !== strings.length - 1) {
+        throw new Error(`AssertionError: expected specific shape of args for strings/expressions in interpolation`);
+    }
+    const interpolationArgs = [];
+    if (expressions.length === 1 && strings[0] === '' && strings[1] === '') {
+        interpolationArgs.push(expressions[0]);
+    }
+    else {
+        let idx;
+        for (idx = 0; idx < expressions.length; idx++) {
+            interpolationArgs.push(literal(strings[idx]), expressions[idx]);
+        }
+        // idx points at the last string.
+        interpolationArgs.push(literal(strings[idx]));
+    }
+    return callVariadicInstruction(PROPERTY_INTERPOLATE_CONFIG, [literal(name)], interpolationArgs);
+}
+function pureFunction(varOffset, fn, args) {
+    return callVariadicInstructionExpr(PURE_FUNCTION_CONFIG, [
+        literal(varOffset),
+        fn,
+    ], args);
 }
 function call(instruction, args) {
     return createStatementOp(importExpr(instruction).callFn(args).toStmt());
@@ -9576,21 +9855,68 @@ const TEXT_INTERPOLATE_CONFIG = {
         Identifiers.textInterpolate8,
     ],
     variable: Identifiers.textInterpolateV,
+    mapping: n => {
+        if (n % 2 === 0) {
+            throw new Error(`Expected odd number of arguments`);
+        }
+        return (n - 1) / 2;
+    },
 };
-function callInterpolation(config, baseArgs, interpolationArgs) {
-    if (interpolationArgs.length % 2 === 0) {
-        throw new Error(`Expected odd number of interpolation arguments`);
-    }
-    const n = (interpolationArgs.length - 1) / 2;
+/**
+ * `InterpolationConfig` for the `propertyInterpolate` instruction.
+ */
+const PROPERTY_INTERPOLATE_CONFIG = {
+    constant: [
+        Identifiers.propertyInterpolate,
+        Identifiers.propertyInterpolate1,
+        Identifiers.propertyInterpolate2,
+        Identifiers.propertyInterpolate3,
+        Identifiers.propertyInterpolate4,
+        Identifiers.propertyInterpolate5,
+        Identifiers.propertyInterpolate6,
+        Identifiers.propertyInterpolate7,
+        Identifiers.propertyInterpolate8,
+    ],
+    variable: Identifiers.propertyInterpolateV,
+    mapping: n => {
+        if (n % 2 === 0) {
+            throw new Error(`Expected odd number of arguments`);
+        }
+        return (n - 1) / 2;
+    },
+};
+const PURE_FUNCTION_CONFIG = {
+    constant: [
+        Identifiers.pureFunction0,
+        Identifiers.pureFunction1,
+        Identifiers.pureFunction2,
+        Identifiers.pureFunction3,
+        Identifiers.pureFunction4,
+        Identifiers.pureFunction5,
+        Identifiers.pureFunction6,
+        Identifiers.pureFunction7,
+        Identifiers.pureFunction8,
+    ],
+    variable: Identifiers.pureFunctionV,
+    mapping: n => n,
+};
+function callVariadicInstructionExpr(config, baseArgs, interpolationArgs) {
+    const n = config.mapping(interpolationArgs.length);
     if (n < config.constant.length) {
         // Constant calling pattern.
-        return call(config.constant[n], [...baseArgs, ...interpolationArgs]);
+        return importExpr(config.constant[n]).callFn([...baseArgs, ...interpolationArgs]);
     }
-    else {
+    else if (config.variable !== null) {
         // Variable calling pattern.
-        return call(config.variable, [...baseArgs, literalArr(interpolationArgs)]);
+        return importExpr(config.variable).callFn([...baseArgs, literalArr(interpolationArgs)]);
+    }
+    else {
+        throw new Error(`AssertionError: unable to call variadic function`);
     }
 }
+function callVariadicInstruction(config, baseArgs, interpolationArgs) {
+    return createStatementOp(callVariadicInstructionExpr(config, baseArgs, interpolationArgs).toStmt());
+}
 
 /**
  * Compiles semantic operations across all views and generates output `o.Statement`s with actual
@@ -9635,6 +9961,9 @@ function reifyCreateOperations(view, ops) {
                 const childView = view.tpl.views.get(op.xref);
                 OpList.replace(op, template(op.slot, variable(childView.fnName), childView.decls, childView.vars, op.tag, op.attributes));
                 break;
+            case OpKind.Pipe:
+                OpList.replace(op, pipe(op.slot, op.name));
+                break;
             case OpKind.Listener:
                 const listenerFn = reifyListenerHandler(view, op.handlerFnName, op.handlerOps);
                 OpList.replace(op, listener(op.name, listenerFn));
@@ -9663,6 +9992,9 @@ function reifyUpdateOperations(_view, ops) {
             case OpKind.Property:
                 OpList.replace(op, property(op.name, op.expression));
                 break;
+            case OpKind.InterpolateProperty:
+                OpList.replace(op, propertyInterpolate(op.name, op.strings, op.expressions));
+                break;
             case OpKind.InterpolateText:
                 OpList.replace(op, textInterpolate(op.strings, op.expressions));
                 break;
@@ -9681,6 +10013,9 @@ function reifyUpdateOperations(_view, ops) {
     }
 }
 function reifyIrExpression(expr) {
+    if (!isIrExpression(expr)) {
+        return expr;
+    }
     switch (expr.kind) {
         case ExpressionKind.NextContext:
             return nextContext(expr.steps);
@@ -9702,6 +10037,17 @@ function reifyIrExpression(expr) {
                 throw new Error(`Read of unnamed variable ${expr.xref}`);
             }
             return variable(expr.name);
+        case ExpressionKind.PureFunctionExpr:
+            if (expr.fn === null) {
+                throw new Error(`AssertionError: expected PureFunctions to have been extracted`);
+            }
+            return pureFunction(expr.varOffset, expr.fn, expr.args);
+        case ExpressionKind.PureFunctionParameterExpr:
+            throw new Error(`AssertionError: expected PureFunctionParameterExpr to have been extracted`);
+        case ExpressionKind.PipeBinding:
+            return pipeBind(expr.slot, expr.varOffset, expr.args);
+        case ExpressionKind.PipeBindingVariadic:
+            return pipeBindV(expr.slot, expr.varOffset, expr.args);
         default:
             throw new Error(`AssertionError: Unsupported reification of ir.Expression kind: ${ExpressionKind[expr.kind]}`);
     }
@@ -9805,6 +10151,9 @@ function phaseSlotAllocation(cpl) {
             }
             // Process all `ir.Expression`s within this view, and look for `usesSlotIndexExprTrait`.
             visitExpressionsInOp(op, expr => {
+                if (!isIrExpression(expr)) {
+                    return;
+                }
                 if (!hasUsesSlotIndexTrait(expr) || expr.slot !== null) {
                     return;
                 }
@@ -9835,6 +10184,13 @@ function phaseVarCounting(cpl) {
                 varCount += varsUsedByOp(op);
             }
             visitExpressionsInOp(op, expr => {
+                if (!isIrExpression(expr)) {
+                    return;
+                }
+                // Some expressions require knowledge of the number of variable slots consumed.
+                if (hasUsesVarOffsetTrait(expr)) {
+                    expr.varOffset = varCount;
+                }
                 if (hasConsumesVarsTrait(expr)) {
                     varCount += varsUsedByIrExpression(expr);
                 }
@@ -9866,12 +10222,25 @@ function varsUsedByOp(op) {
         case OpKind.InterpolateText:
             // `ir.InterpolateTextOp`s use a variable slot for each dynamic expression.
             return op.expressions.length;
+        case OpKind.InterpolateProperty:
+            // `ir.InterpolatePropertyOp`s use a variable slot for each dynamic expression, plus one for
+            // the result.
+            return 1 + op.expressions.length;
         default:
             throw new Error(`Unhandled op: ${OpKind[op.kind]}`);
     }
 }
 function varsUsedByIrExpression(expr) {
-    return 0;
+    switch (expr.kind) {
+        case ExpressionKind.PureFunctionExpr:
+            return 1 + expr.args.length;
+        case ExpressionKind.PipeBinding:
+            return 1 + expr.args.length;
+        case ExpressionKind.PipeBindingVariadic:
+            return 1 + expr.numArgs;
+        default:
+            throw new Error(`AssertionError: unhandled ConsumesVarsTrait expression ${expr.constructor.name}`);
+    }
 }
 
 /**
@@ -10455,6 +10824,9 @@ function collectOpInfo(op) {
     let fences = Fence.None;
     const variablesUsed = new Set();
     visitExpressionsInOp(op, expr => {
+        if (!isIrExpression(expr)) {
+            return;
+        }
         switch (expr.kind) {
             case ExpressionKind.ReadVariable:
                 variablesUsed.add(expr.xref);
@@ -10471,6 +10843,9 @@ function collectOpInfo(op) {
  */
 function countVariableUsages(op, varUsages, varRemoteUsage) {
     visitExpressionsInOp(op, (expr, flags) => {
+        if (!isIrExpression(expr)) {
+            return;
+        }
         if (expr.kind !== ExpressionKind.ReadVariable) {
             return;
         }
@@ -10490,6 +10865,9 @@ function countVariableUsages(op, varUsages, varRemoteUsage) {
  */
 function uncountVariableUsages(op, varUsages) {
     visitExpressionsInOp(op, expr => {
+        if (!isIrExpression(expr)) {
+            return;
+        }
         if (expr.kind !== ExpressionKind.ReadVariable) {
             return;
         }
@@ -10539,6 +10917,9 @@ function tryInlineVariableInitializer(id, initializer, target, declFences) {
     let inlined = false;
     let inliningAllowed = true;
     transformExpressionsInOp(target, (expr, flags) => {
+        if (!isIrExpression(expr)) {
+            return expr;
+        }
         if (inlined || !inliningAllowed) {
             // Either the inlining has already succeeded, or we've passed a fence that disallows inlining
             // at this point, so don't try.
@@ -10693,6 +11074,9 @@ function mergeNextContextsInOps(ops) {
         let tryToMerge = true;
         for (let candidate = op.next; candidate.kind !== OpKind.ListEnd && tryToMerge; candidate = candidate.next) {
             visitExpressionsInOp(candidate, (expr, flags) => {
+                if (!isIrExpression(expr)) {
+                    return expr;
+                }
                 if (!tryToMerge) {
                     // Either we've already merged, or failed to merge.
                     return;
@@ -10777,11 +11161,205 @@ function phaseSaveRestoreView(cpl) {
     }
 }
 
+function phasePureFunctionExtraction(cpl) {
+    for (const view of cpl.views.values()) {
+        for (const op of view.ops()) {
+            visitExpressionsInOp(op, expr => {
+                if (!(expr instanceof PureFunctionExpr) || expr.body === null) {
+                    return;
+                }
+                const constantDef = new PureFunctionConstant(expr.args.length);
+                expr.fn = cpl.pool.getSharedConstant(constantDef, expr.body);
+                expr.body = null;
+            });
+        }
+    }
+}
+class PureFunctionConstant extends GenericKeyFn {
+    constructor(numArgs) {
+        super();
+        this.numArgs = numArgs;
+    }
+    keyOf(expr) {
+        if (expr instanceof PureFunctionParameterExpr) {
+            return `param(${expr.index})`;
+        }
+        else {
+            return super.keyOf(expr);
+        }
+    }
+    toSharedConstantDeclaration(declName, keyExpr) {
+        const fnParams = [];
+        for (let idx = 0; idx < this.numArgs; idx++) {
+            fnParams.push(new FnParam('_p' + idx));
+        }
+        // We will never visit `ir.PureFunctionParameterExpr`s that don't belong to us, because this
+        // transform runs inside another visitor which will visit nested pure functions before this one.
+        const returnExpr = transformExpressionsInExpression(keyExpr, expr => {
+            if (!(expr instanceof PureFunctionParameterExpr)) {
+                return expr;
+            }
+            return variable('_p' + expr.index);
+        }, VisitorContextFlag.None);
+        return new DeclareFunctionStmt(declName, fnParams, [new ReturnStatement(returnExpr)]);
+    }
+}
+
+function phasePipeCreation(cpl) {
+    for (const view of cpl.views.values()) {
+        processPipeBindingsInView(view);
+    }
+}
+function processPipeBindingsInView(view) {
+    for (const updateOp of view.update) {
+        visitExpressionsInOp(updateOp, (expr, flags) => {
+            if (!isIrExpression(expr)) {
+                return;
+            }
+            if (expr.kind !== ExpressionKind.PipeBinding) {
+                return;
+            }
+            if (flags & VisitorContextFlag.InChildOperation) {
+                throw new Error(`AssertionError: pipe bindings should not appear in child expressions`);
+            }
+            if (!hasDependsOnSlotContextTrait(updateOp)) {
+                throw new Error(`AssertionError: pipe binding associated with non-slot operation ${OpKind[updateOp.kind]}`);
+            }
+            addPipeToCreationBlock(view, updateOp.target, expr);
+        });
+    }
+}
+function addPipeToCreationBlock(view, afterTargetXref, binding) {
+    // Find the appropriate point to insert the Pipe creation operation.
+    // We're looking for `afterTargetXref` (and also want to insert after any other pipe operations
+    // which might be beyond it).
+    for (let op = view.create.head.next; op.kind !== OpKind.ListEnd; op = op.next) {
+        if (!hasConsumesSlotTrait(op)) {
+            continue;
+        }
+        if (op.xref !== afterTargetXref) {
+            continue;
+        }
+        // We've found a tentative insertion point; however, we also want to skip past any _other_ pipe
+        // operations present.
+        while (op.next.kind === OpKind.Pipe) {
+            op = op.next;
+        }
+        const pipe = createPipeOp(binding.target, binding.name);
+        OpList.insertBefore(pipe, op.next);
+        // This completes adding the pipe to the creation block.
+        return;
+    }
+    // At this point, we've failed to add the pipe to the creation block.
+    throw new Error(`AssertionError: unable to find insertion point for pipe ${binding.name}`);
+}
+
+function phasePipeVariadic(cpl) {
+    for (const view of cpl.views.values()) {
+        for (const op of view.update) {
+            transformExpressionsInOp(op, expr => {
+                if (!(expr instanceof PipeBindingExpr)) {
+                    return expr;
+                }
+                // Pipes are variadic if they have more than 4 arguments.
+                if (expr.args.length <= 4) {
+                    return expr;
+                }
+                return new PipeBindingVariadicExpr(expr.target, expr.name, literalArr(expr.args), expr.args.length);
+            }, VisitorContextFlag.None);
+        }
+    }
+}
+
+function phasePureLiteralStructures(cpl) {
+    for (const view of cpl.views.values()) {
+        for (const op of view.update) {
+            transformExpressionsInOp(op, (expr, flags) => {
+                if (flags & VisitorContextFlag.InChildOperation) {
+                    return expr;
+                }
+                if (expr instanceof LiteralArrayExpr) {
+                    return transformLiteralArray(expr);
+                }
+                else if (expr instanceof LiteralMapExpr) {
+                    return transformLiteralMap(expr);
+                }
+                return expr;
+            }, VisitorContextFlag.None);
+        }
+    }
+}
+function transformLiteralArray(expr) {
+    const derivedEntries = [];
+    const nonConstantArgs = [];
+    for (const entry of expr.entries) {
+        if (entry.isConstant()) {
+            derivedEntries.push(entry);
+        }
+        else {
+            const idx = nonConstantArgs.length;
+            nonConstantArgs.push(entry);
+            derivedEntries.push(new PureFunctionParameterExpr(idx));
+        }
+    }
+    return new PureFunctionExpr(literalArr(derivedEntries), nonConstantArgs);
+}
+function transformLiteralMap(expr) {
+    let derivedEntries = [];
+    const nonConstantArgs = [];
+    for (const entry of expr.entries) {
+        if (entry.value.isConstant()) {
+            derivedEntries.push(entry);
+        }
+        else {
+            const idx = nonConstantArgs.length;
+            nonConstantArgs.push(entry.value);
+            derivedEntries.push(new LiteralMapEntry(entry.key, new PureFunctionParameterExpr(idx), entry.quoted));
+        }
+    }
+    return new PureFunctionExpr(literalMap(derivedEntries), nonConstantArgs);
+}
+
+function phaseAlignPipeVariadicVarOffset(cpl) {
+    for (const view of cpl.views.values()) {
+        for (const op of view.update) {
+            visitExpressionsInOp(op, expr => {
+                if (!(expr instanceof PipeBindingVariadicExpr)) {
+                    return expr;
+                }
+                if (!(expr.args instanceof PureFunctionExpr)) {
+                    return expr;
+                }
+                if (expr.varOffset === null || expr.args.varOffset === null) {
+                    throw new Error(`Must run after variable counting`);
+                }
+                // The structure of this variadic pipe expression is:
+                // PipeBindingVariadic(#, Y, PureFunction(X, ...ARGS))
+                // Where X and Y are the slot offsets for the variables used by these operations, and Y > X.
+                // In `TemplateDefinitionBuilder` the PipeBindingVariadic variable slots are allocated
+                // before the PureFunction slots, which is unusually out-of-order.
+                //
+                // To maintain identical output for the tests in question, we adjust the variable offsets of
+                // these two calls to emulate TDB's behavior. This is not perfect, because the ARGS of the
+                // PureFunction call may also allocate slots which by TDB's ordering would come after X, and
+                // we don't account for that. Still, this should be enough to pass the existing pipe tests.
+                // Put the PipeBindingVariadic vars where the PureFunction vars were previously allocated.
+                expr.varOffset = expr.args.varOffset;
+                // Put the PureFunction vars following the PipeBindingVariadic vars.
+                expr.args.varOffset = expr.varOffset + varsUsedByIrExpression(expr);
+            });
+        }
+    }
+}
+
 /**
  * Run all transformation phases in the correct order against a `ComponentCompilation`. After this
  * processing, the compilation should be in a state where it can be emitted via `emitTemplateFn`.s
  */
 function transformTemplate(cpl) {
+    phasePipeCreation(cpl);
+    phasePipeVariadic(cpl);
+    phasePureLiteralStructures(cpl);
     phaseGenerateVariables(cpl);
     phaseSaveRestoreView(cpl);
     phaseResolveNames(cpl);
@@ -10796,6 +11374,8 @@ function transformTemplate(cpl) {
     phaseMergeNextContext(cpl);
     phaseNgContainer(cpl);
     phaseEmptyElements(cpl);
+    phasePureFunctionExtraction(cpl);
+    phaseAlignPipeVariadicVarOffset(cpl);
     phaseReify(cpl);
     phaseChaining(cpl);
 }
@@ -10866,8 +11446,9 @@ function maybeGenerateRfBlock(flag, statements) {
  * embedded views or host bindings.
  */
 class ComponentCompilation {
-    constructor(componentName) {
+    constructor(componentName, pool) {
         this.componentName = componentName;
+        this.pool = pool;
         /**
          * Tracks the next `ir.XrefId` which can be assigned as template structures are ingested.
          */
@@ -10999,8 +11580,8 @@ const BINARY_OPERATORS = new Map([
  * Process a template AST and convert it into a `ComponentCompilation` in the intermediate
  * representation.
  */
-function ingest(componentName, template) {
-    const cpl = new ComponentCompilation(componentName);
+function ingest(componentName, template, constantPool) {
+    const cpl = new ComponentCompilation(componentName, constantPool);
     ingestNodes(cpl.root, template);
     return cpl;
 }
@@ -11095,6 +11676,12 @@ function convertAst(ast, cpl) {
             return new ReadPropExpr(convertAst(ast.receiver, cpl), ast.name);
         }
     }
+    else if (ast instanceof PropertyWrite) {
+        return new WritePropExpr(convertAst(ast.receiver, cpl), ast.name, convertAst(ast.value, cpl));
+    }
+    else if (ast instanceof KeyedWrite) {
+        return new WriteKeyExpr(convertAst(ast.receiver, cpl), convertAst(ast.key, cpl), convertAst(ast.value, cpl));
+    }
     else if (ast instanceof Call) {
         if (ast.receiver instanceof ImplicitReceiver) {
             throw new Error(`Unexpected ImplicitReceiver`);
@@ -11122,6 +11709,25 @@ function convertAst(ast, cpl) {
     else if (ast instanceof Chain) {
         throw new Error(`AssertionError: Chain in unknown context`);
     }
+    else if (ast instanceof LiteralMap) {
+        const entries = ast.keys.map((key, idx) => {
+            const value = ast.values[idx];
+            return new LiteralMapEntry(key.key, convertAst(value, cpl), key.quoted);
+        });
+        return new LiteralMapExpr(entries);
+    }
+    else if (ast instanceof LiteralArray) {
+        return new LiteralArrayExpr(ast.expressions.map(expr => convertAst(expr, cpl)));
+    }
+    else if (ast instanceof Conditional) {
+        return new ConditionalExpr(convertAst(ast.condition, cpl), convertAst(ast.trueExp, cpl), convertAst(ast.falseExp, cpl));
+    }
+    else if (ast instanceof BindingPipe) {
+        return new PipeBindingExpr(cpl.allocateXrefId(), ast.name, [
+            convertAst(ast.exp, cpl),
+            ...ast.args.map(arg => convertAst(arg, cpl)),
+        ]);
+    }
     else {
         throw new Error(`Unhandled expression type: ${ast.constructor.name}`);
     }
@@ -11154,19 +11760,16 @@ function ingestAttributes(op, element) {
  */
 function ingestBindings(view, op, element) {
     if (element instanceof Template) {
-        // TODO: Are ng-template inputs handled differently from element inputs?
-        // <ng-template dir [foo]="...">
-        // <item-cmp *ngFor="let item of items" [item]="item">
-        for (const input of [...element.templateAttrs, ...element.inputs]) {
-            if (!(input instanceof BoundAttribute)) {
+        for (const attr of [...element.templateAttrs, ...element.inputs]) {
+            if (!(attr instanceof BoundAttribute)) {
                 continue;
             }
-            view.update.push(createPropertyOp(op.xref, input.name, convertAst(input.value, view.tpl)));
+            ingestPropertyBinding(view, op.xref, attr.name, attr.value);
         }
     }
     else {
         for (const input of element.inputs) {
-            view.update.push(createPropertyOp(op.xref, input.name, convertAst(input.value, view.tpl)));
+            ingestPropertyBinding(view, op.xref, input.name, input.value);
         }
         for (const output of element.outputs) {
             const listenerOp = createListenerOp(op.xref, output.name, op.tag);
@@ -11197,6 +11800,17 @@ function ingestBindings(view, op, element) {
         }
     }
 }
+function ingestPropertyBinding(view, xref, name, value) {
+    if (value instanceof ASTWithSource) {
+        value = value.ast;
+    }
+    if (value instanceof Interpolation) {
+        view.update.push(createInterpolatePropertyOp(xref, name, value.strings, value.expressions.map(expr => convertAst(expr, view.tpl))));
+    }
+    else {
+        view.update.push(createPropertyOp(xref, name, convertAst(value, view.tpl)));
+    }
+}
 /**
  * Process all of the local references on an element-like structure in the template AST and convert
  * them to their IR representation.
@@ -21579,7 +22193,7 @@ function compileComponentFromMetadata(meta, constantPool, bindingParser) {
     else {
         // This path compiles the template using the prototype template pipeline. First the template is
         // ingested into IR:
-        const tpl = ingest(meta.name, meta.template.nodes);
+        const tpl = ingest(meta.name, meta.template.nodes, constantPool);
         // Then the IR is transformed to prepare it for cod egeneration.
         transformTemplate(tpl);
         // Finally we emit the template function:
@@ -22670,7 +23284,7 @@ function inputsMappingToInputMetadata(inputs) {
             result[key] = {
                 bindingPropertyName: value[0],
                 classPropertyName: value[1],
-                transformFunction: value[2] || null,
+                transformFunction: value[2] ? new WrappedNodeExpr(value[2]) : null,
                 required: false,
             };
         }
@@ -22745,7 +23359,7 @@ function publishFacade(global) {
  * @description
  * Entry point for all public APIs of the compiler package.
  */
-const VERSION = new Version('16.1.0-next.3');
+const VERSION = new Version('16.1.0-rc.0');
 
 class CompilerConfig {
     constructor({ defaultEncapsulation = ViewEncapsulation.Emulated, useJit = true, missingTranslation = null, preserveWhitespaces, strictInjectionParameters } = {}) {
@@ -24673,7 +25287,7 @@ const MINIMUM_PARTIAL_LINKER_VERSION$6 = '12.0.0';
 function compileDeclareClassMetadata(metadata) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$6));
-    definitionMap.set('version', literal('16.1.0-next.3'));
+    definitionMap.set('version', literal('16.1.0-rc.0'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', metadata.type);
     definitionMap.set('decorators', metadata.decorators);
@@ -24776,7 +25390,7 @@ function compileDeclareDirectiveFromMetadata(meta) {
 function createDirectiveDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$5));
-    definitionMap.set('version', literal('16.1.0-next.3'));
+    definitionMap.set('version', literal('16.1.0-rc.0'));
     // e.g. `type: MyDirective`
     definitionMap.set('type', meta.type.value);
     if (meta.isStandalone) {
@@ -25004,7 +25618,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('16.1.0-next.3'));
+    definitionMap.set('version', literal('16.1.0-rc.0'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('deps', compileDependencies(meta.deps));
@@ -25039,7 +25653,7 @@ function compileDeclareInjectableFromMetadata(meta) {
 function createInjectableDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$3));
-    definitionMap.set('version', literal('16.1.0-next.3'));
+    definitionMap.set('version', literal('16.1.0-rc.0'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     // Only generate providedIn property if it has a non-null value
@@ -25090,7 +25704,7 @@ function compileDeclareInjectorFromMetadata(meta) {
 function createInjectorDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$2));
-    definitionMap.set('version', literal('16.1.0-next.3'));
+    definitionMap.set('version', literal('16.1.0-rc.0'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('providers', meta.providers);
@@ -25120,7 +25734,7 @@ function compileDeclareNgModuleFromMetadata(meta) {
 function createNgModuleDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$1));
-    definitionMap.set('version', literal('16.1.0-next.3'));
+    definitionMap.set('version', literal('16.1.0-rc.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.
@@ -25171,7 +25785,7 @@ function compileDeclarePipeFromMetadata(meta) {
 function createPipeDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION));
-    definitionMap.set('version', literal('16.1.0-next.3'));
+    definitionMap.set('version', literal('16.1.0-rc.0'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     // e.g. `type: MyPipe`
     definitionMap.set('type', meta.type.value);