@angular/compiler 16.1.0-next.3 → 16.1.0

package/esm2022/src/template/pipeline/src/instruction.mjs

@@ -59,6 +59,12 @@ export function listener(name, handlerFn) {
         handlerFn,
     ]);
 }
+export function pipe(slot, name) {
+    return call(Identifiers.pipe, [
+        o.literal(slot),
+        o.literal(name),
+    ]);
+}
 export function advance(delta) {
     return call(Identifiers.advance, [
         o.literal(delta),
@@ -98,6 +104,30 @@ export function property(name, expression) {
         expression,
     ]);
 }
+const PIPE_BINDINGS = [
+    Identifiers.pipeBind1,
+    Identifiers.pipeBind2,
+    Identifiers.pipeBind3,
+    Identifiers.pipeBind4,
+];
+export 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 o.importExpr(instruction).callFn([
+        o.literal(slot),
+        o.literal(varOffset),
+        ...args,
+    ]);
+}
+export function pipeBindV(slot, varOffset, args) {
+    return o.importExpr(Identifiers.pipeBindV).callFn([
+        o.literal(slot),
+        o.literal(varOffset),
+        args,
+    ]);
+}
 export 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`);
@@ -114,7 +144,31 @@ export function textInterpolate(strings, expressions) {
         // idx points at the last string.
         interpolationArgs.push(o.literal(strings[idx]));
     }
-    return callInterpolation(TEXT_INTERPOLATE_CONFIG, [], interpolationArgs);
+    return callVariadicInstruction(TEXT_INTERPOLATE_CONFIG, [], interpolationArgs);
+}
+export 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(o.literal(strings[idx]), expressions[idx]);
+        }
+        // idx points at the last string.
+        interpolationArgs.push(o.literal(strings[idx]));
+    }
+    return callVariadicInstruction(PROPERTY_INTERPOLATE_CONFIG, [o.literal(name)], interpolationArgs);
+}
+export function pureFunction(varOffset, fn, args) {
+    return callVariadicInstructionExpr(PURE_FUNCTION_CONFIG, [
+        o.literal(varOffset),
+        fn,
+    ], args);
 }
 function call(instruction, args) {
     return ir.createStatementOp(o.importExpr(instruction).callFn(args).toStmt());
@@ -135,19 +189,66 @@ 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 o.importExpr(config.constant[n]).callFn([...baseArgs, ...interpolationArgs]);
     }
-    else {
+    else if (config.variable !== null) {
         // Variable calling pattern.
-        return call(config.variable, [...baseArgs, o.literalArr(interpolationArgs)]);
+        return o.importExpr(config.variable).callFn([...baseArgs, o.literalArr(interpolationArgs)]);
     }
+    else {
+        throw new Error(`AssertionError: unable to call variadic function`);
+    }
+}
+function callVariadicInstruction(config, baseArgs, interpolationArgs) {
+    return ir.createStatementOp(callVariadicInstructionExpr(config, baseArgs, interpolationArgs).toStmt());
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"instruction.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler/src/template/pipeline/src/instruction.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport * as o from '../../../output/output_ast';\nimport {Identifiers} from '../../../render3/r3_identifiers';\nimport * as ir from '../ir';\n\n// This file contains helpers for generating calls to Ivy instructions. In particular, each\n// instruction type is represented as a function, which may select a specific instruction variant\n// depending on the exact arguments.\n\nexport function element(\n    slot: number, tag: string, constIndex: number|null, localRefIndex: number|null): ir.CreateOp {\n  return elementOrContainerBase(Identifiers.element, slot, tag, constIndex, localRefIndex);\n}\n\nexport function elementStart(\n    slot: number, tag: string, constIndex: number|null, localRefIndex: number|null): ir.CreateOp {\n  return elementOrContainerBase(Identifiers.elementStart, slot, tag, constIndex, localRefIndex);\n}\n\nfunction elementOrContainerBase(\n    instruction: o.ExternalReference, slot: number, tag: string|null, constIndex: number|null,\n    localRefIndex: number|null): ir.CreateOp {\n  const args: o.Expression[] = [o.literal(slot)];\n  if (tag !== null) {\n    args.push(o.literal(tag));\n  }\n  if (localRefIndex !== null) {\n    args.push(\n        o.literal(constIndex),  // might be null, but that's okay.\n        o.literal(localRefIndex),\n    );\n  } else if (constIndex !== null) {\n    args.push(o.literal(constIndex));\n  }\n\n  return call(instruction, args);\n}\n\nexport function elementEnd(): ir.CreateOp {\n  return call(Identifiers.elementEnd, []);\n}\n\nexport function elementContainerStart(\n    slot: number, constIndex: number|null, localRefIndex: number|null): ir.CreateOp {\n  return elementOrContainerBase(\n      Identifiers.elementContainerStart, slot, /* tag */ null, constIndex, localRefIndex);\n}\n\nexport function elementContainer(\n    slot: number, constIndex: number|null, localRefIndex: number|null): ir.CreateOp {\n  return elementOrContainerBase(\n      Identifiers.elementContainer, slot, /* tag */ null, constIndex, localRefIndex);\n}\n\nexport function elementContainerEnd(): ir.CreateOp {\n  return call(Identifiers.elementContainerEnd, []);\n}\n\nexport function template(\n    slot: number, templateFnRef: o.Expression, decls: number, vars: number, tag: string,\n    constIndex: number): ir.CreateOp {\n  return call(Identifiers.templateCreate, [\n    o.literal(slot),\n    templateFnRef,\n    o.literal(decls),\n    o.literal(vars),\n    o.literal(tag),\n    o.literal(constIndex),\n  ]);\n}\n\nexport function listener(name: string, handlerFn: o.Expression): ir.CreateOp {\n  return call(Identifiers.listener, [\n    o.literal(name),\n    handlerFn,\n  ]);\n}\n\nexport function advance(delta: number): ir.UpdateOp {\n  return call(Identifiers.advance, [\n    o.literal(delta),\n  ]);\n}\n\nexport function reference(slot: number): o.Expression {\n  return o.importExpr(Identifiers.reference).callFn([\n    o.literal(slot),\n  ]);\n}\n\nexport function nextContext(steps: number): o.Expression {\n  return o.importExpr(Identifiers.nextContext).callFn(steps === 1 ? [] : [o.literal(steps)]);\n}\n\n\nexport function getCurrentView(): o.Expression {\n  return o.importExpr(Identifiers.getCurrentView).callFn([]);\n}\n\n\nexport function restoreView(savedView: o.Expression): o.Expression {\n  return o.importExpr(Identifiers.restoreView).callFn([\n    savedView,\n  ]);\n}\n\n\nexport function resetView(returnValue: o.Expression): o.Expression {\n  return o.importExpr(Identifiers.resetView).callFn([\n    returnValue,\n  ]);\n}\n\nexport function text(slot: number, initialValue: string): ir.CreateOp {\n  const args: o.Expression[] = [o.literal(slot)];\n  if (initialValue !== '') {\n    args.push(o.literal(initialValue));\n  }\n  return call(Identifiers.text, args);\n}\n\nexport function property(name: string, expression: o.Expression): ir.UpdateOp {\n  return call(Identifiers.property, [\n    o.literal(name),\n    expression,\n  ]);\n}\n\nexport function textInterpolate(strings: string[], expressions: o.Expression[]): ir.UpdateOp {\n  if (strings.length < 1 || expressions.length !== strings.length - 1) {\n    throw new Error(\n        `AssertionError: expected specific shape of args for strings/expressions in interpolation`);\n  }\n  const interpolationArgs: o.Expression[] = [];\n\n  if (expressions.length === 1 && strings[0] === '' && strings[1] === '') {\n    interpolationArgs.push(expressions[0]);\n  } else {\n    let idx: number;\n    for (idx = 0; idx < expressions.length; idx++) {\n      interpolationArgs.push(o.literal(strings[idx]), expressions[idx]);\n    }\n    // idx points at the last string.\n    interpolationArgs.push(o.literal(strings[idx]));\n  }\n\n  return callInterpolation(TEXT_INTERPOLATE_CONFIG, [], interpolationArgs);\n}\n\n\n\nfunction call<OpT extends ir.CreateOp|ir.UpdateOp>(\n    instruction: o.ExternalReference, args: o.Expression[]): OpT {\n  return ir.createStatementOp(o.importExpr(instruction).callFn(args).toStmt()) as OpT;\n}\n\n/**\n * Describes a specific flavor of instruction used to represent interpolations, which have some\n * number of variants for specific argument counts.\n */\ninterface InterpolationConfig {\n  constant: o.ExternalReference[];\n  variable: o.ExternalReference;\n}\n\n/**\n * `InterpolationConfig` for the `textInterpolate` instruction.\n */\nconst TEXT_INTERPOLATE_CONFIG: InterpolationConfig = {\n  constant: [\n    Identifiers.textInterpolate,\n    Identifiers.textInterpolate1,\n    Identifiers.textInterpolate2,\n    Identifiers.textInterpolate3,\n    Identifiers.textInterpolate4,\n    Identifiers.textInterpolate5,\n    Identifiers.textInterpolate6,\n    Identifiers.textInterpolate7,\n    Identifiers.textInterpolate8,\n  ],\n  variable: Identifiers.textInterpolateV,\n};\n\nfunction callInterpolation(\n    config: InterpolationConfig, baseArgs: o.Expression[],\n    interpolationArgs: o.Expression[]): ir.UpdateOp {\n  if (interpolationArgs.length % 2 === 0) {\n    throw new Error(`Expected odd number of interpolation arguments`);\n  }\n  const n = (interpolationArgs.length - 1) / 2;\n  if (n < config.constant.length) {\n    // Constant calling pattern.\n    return call(config.constant[n], [...baseArgs, ...interpolationArgs]);\n  } else {\n    // Variable calling pattern.\n    return call(config.variable, [...baseArgs, o.literalArr(interpolationArgs)]);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"instruction.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler/src/template/pipeline/src/instruction.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport * as o from '../../../output/output_ast';\nimport {Identifiers} from '../../../render3/r3_identifiers';\nimport * as ir from '../ir';\n\n// This file contains helpers for generating calls to Ivy instructions. In particular, each\n// instruction type is represented as a function, which may select a specific instruction variant\n// depending on the exact arguments.\n\nexport function element(\n    slot: number, tag: string, constIndex: number|null, localRefIndex: number|null): ir.CreateOp {\n  return elementOrContainerBase(Identifiers.element, slot, tag, constIndex, localRefIndex);\n}\n\nexport function elementStart(\n    slot: number, tag: string, constIndex: number|null, localRefIndex: number|null): ir.CreateOp {\n  return elementOrContainerBase(Identifiers.elementStart, slot, tag, constIndex, localRefIndex);\n}\n\nfunction elementOrContainerBase(\n    instruction: o.ExternalReference, slot: number, tag: string|null, constIndex: number|null,\n    localRefIndex: number|null): ir.CreateOp {\n  const args: o.Expression[] = [o.literal(slot)];\n  if (tag !== null) {\n    args.push(o.literal(tag));\n  }\n  if (localRefIndex !== null) {\n    args.push(\n        o.literal(constIndex),  // might be null, but that's okay.\n        o.literal(localRefIndex),\n    );\n  } else if (constIndex !== null) {\n    args.push(o.literal(constIndex));\n  }\n\n  return call(instruction, args);\n}\n\nexport function elementEnd(): ir.CreateOp {\n  return call(Identifiers.elementEnd, []);\n}\n\nexport function elementContainerStart(\n    slot: number, constIndex: number|null, localRefIndex: number|null): ir.CreateOp {\n  return elementOrContainerBase(\n      Identifiers.elementContainerStart, slot, /* tag */ null, constIndex, localRefIndex);\n}\n\nexport function elementContainer(\n    slot: number, constIndex: number|null, localRefIndex: number|null): ir.CreateOp {\n  return elementOrContainerBase(\n      Identifiers.elementContainer, slot, /* tag */ null, constIndex, localRefIndex);\n}\n\nexport function elementContainerEnd(): ir.CreateOp {\n  return call(Identifiers.elementContainerEnd, []);\n}\n\nexport function template(\n    slot: number, templateFnRef: o.Expression, decls: number, vars: number, tag: string,\n    constIndex: number): ir.CreateOp {\n  return call(Identifiers.templateCreate, [\n    o.literal(slot),\n    templateFnRef,\n    o.literal(decls),\n    o.literal(vars),\n    o.literal(tag),\n    o.literal(constIndex),\n  ]);\n}\n\nexport function listener(name: string, handlerFn: o.Expression): ir.CreateOp {\n  return call(Identifiers.listener, [\n    o.literal(name),\n    handlerFn,\n  ]);\n}\n\nexport function pipe(slot: number, name: string): ir.CreateOp {\n  return call(Identifiers.pipe, [\n    o.literal(slot),\n    o.literal(name),\n  ]);\n}\n\nexport function advance(delta: number): ir.UpdateOp {\n  return call(Identifiers.advance, [\n    o.literal(delta),\n  ]);\n}\n\nexport function reference(slot: number): o.Expression {\n  return o.importExpr(Identifiers.reference).callFn([\n    o.literal(slot),\n  ]);\n}\n\nexport function nextContext(steps: number): o.Expression {\n  return o.importExpr(Identifiers.nextContext).callFn(steps === 1 ? [] : [o.literal(steps)]);\n}\n\n\nexport function getCurrentView(): o.Expression {\n  return o.importExpr(Identifiers.getCurrentView).callFn([]);\n}\n\n\nexport function restoreView(savedView: o.Expression): o.Expression {\n  return o.importExpr(Identifiers.restoreView).callFn([\n    savedView,\n  ]);\n}\n\n\nexport function resetView(returnValue: o.Expression): o.Expression {\n  return o.importExpr(Identifiers.resetView).callFn([\n    returnValue,\n  ]);\n}\n\nexport function text(slot: number, initialValue: string): ir.CreateOp {\n  const args: o.Expression[] = [o.literal(slot)];\n  if (initialValue !== '') {\n    args.push(o.literal(initialValue));\n  }\n  return call(Identifiers.text, args);\n}\n\nexport function property(name: string, expression: o.Expression): ir.UpdateOp {\n  return call(Identifiers.property, [\n    o.literal(name),\n    expression,\n  ]);\n}\n\nconst PIPE_BINDINGS: o.ExternalReference[] = [\n  Identifiers.pipeBind1,\n  Identifiers.pipeBind2,\n  Identifiers.pipeBind3,\n  Identifiers.pipeBind4,\n];\n\nexport function pipeBind(slot: number, varOffset: number, args: o.Expression[]): o.Expression {\n  if (args.length < 1 || args.length > PIPE_BINDINGS.length) {\n    throw new Error(`pipeBind() argument count out of bounds`);\n  }\n\n  const instruction = PIPE_BINDINGS[args.length - 1];\n  return o.importExpr(instruction).callFn([\n    o.literal(slot),\n    o.literal(varOffset),\n    ...args,\n  ]);\n}\n\nexport function pipeBindV(slot: number, varOffset: number, args: o.Expression): o.Expression {\n  return o.importExpr(Identifiers.pipeBindV).callFn([\n    o.literal(slot),\n    o.literal(varOffset),\n    args,\n  ]);\n}\n\nexport function textInterpolate(strings: string[], expressions: o.Expression[]): ir.UpdateOp {\n  if (strings.length < 1 || expressions.length !== strings.length - 1) {\n    throw new Error(\n        `AssertionError: expected specific shape of args for strings/expressions in interpolation`);\n  }\n  const interpolationArgs: o.Expression[] = [];\n\n  if (expressions.length === 1 && strings[0] === '' && strings[1] === '') {\n    interpolationArgs.push(expressions[0]);\n  } else {\n    let idx: number;\n    for (idx = 0; idx < expressions.length; idx++) {\n      interpolationArgs.push(o.literal(strings[idx]), expressions[idx]);\n    }\n    // idx points at the last string.\n    interpolationArgs.push(o.literal(strings[idx]));\n  }\n\n  return callVariadicInstruction(TEXT_INTERPOLATE_CONFIG, [], interpolationArgs);\n}\n\n\nexport function propertyInterpolate(\n    name: string, strings: string[], expressions: o.Expression[]): ir.UpdateOp {\n  if (strings.length < 1 || expressions.length !== strings.length - 1) {\n    throw new Error(\n        `AssertionError: expected specific shape of args for strings/expressions in interpolation`);\n  }\n  const interpolationArgs: o.Expression[] = [];\n\n  if (expressions.length === 1 && strings[0] === '' && strings[1] === '') {\n    interpolationArgs.push(expressions[0]);\n  } else {\n    let idx: number;\n    for (idx = 0; idx < expressions.length; idx++) {\n      interpolationArgs.push(o.literal(strings[idx]), expressions[idx]);\n    }\n    // idx points at the last string.\n    interpolationArgs.push(o.literal(strings[idx]));\n  }\n\n  return callVariadicInstruction(PROPERTY_INTERPOLATE_CONFIG, [o.literal(name)], interpolationArgs);\n}\n\nexport function pureFunction(\n    varOffset: number, fn: o.Expression, args: o.Expression[]): o.Expression {\n  return callVariadicInstructionExpr(\n      PURE_FUNCTION_CONFIG,\n      [\n        o.literal(varOffset),\n        fn,\n      ],\n      args,\n  );\n}\n\nfunction call<OpT extends ir.CreateOp|ir.UpdateOp>(\n    instruction: o.ExternalReference, args: o.Expression[]): OpT {\n  return ir.createStatementOp(o.importExpr(instruction).callFn(args).toStmt()) as OpT;\n}\n\n/**\n * Describes a specific flavor of instruction used to represent variadic instructions, which have\n * some number of variants for specific argument counts.\n */\ninterface VariadicInstructionConfig {\n  constant: o.ExternalReference[];\n  variable: o.ExternalReference|null;\n  mapping: (argCount: number) => number;\n}\n\n/**\n * `InterpolationConfig` for the `textInterpolate` instruction.\n */\nconst TEXT_INTERPOLATE_CONFIG: VariadicInstructionConfig = {\n  constant: [\n    Identifiers.textInterpolate,\n    Identifiers.textInterpolate1,\n    Identifiers.textInterpolate2,\n    Identifiers.textInterpolate3,\n    Identifiers.textInterpolate4,\n    Identifiers.textInterpolate5,\n    Identifiers.textInterpolate6,\n    Identifiers.textInterpolate7,\n    Identifiers.textInterpolate8,\n  ],\n  variable: Identifiers.textInterpolateV,\n  mapping: n => {\n    if (n % 2 === 0) {\n      throw new Error(`Expected odd number of arguments`);\n    }\n    return (n - 1) / 2;\n  },\n};\n\n\n/**\n * `InterpolationConfig` for the `propertyInterpolate` instruction.\n */\nconst PROPERTY_INTERPOLATE_CONFIG: VariadicInstructionConfig = {\n  constant: [\n    Identifiers.propertyInterpolate,\n    Identifiers.propertyInterpolate1,\n    Identifiers.propertyInterpolate2,\n    Identifiers.propertyInterpolate3,\n    Identifiers.propertyInterpolate4,\n    Identifiers.propertyInterpolate5,\n    Identifiers.propertyInterpolate6,\n    Identifiers.propertyInterpolate7,\n    Identifiers.propertyInterpolate8,\n  ],\n  variable: Identifiers.propertyInterpolateV,\n  mapping: n => {\n    if (n % 2 === 0) {\n      throw new Error(`Expected odd number of arguments`);\n    }\n    return (n - 1) / 2;\n  },\n};\n\nconst PURE_FUNCTION_CONFIG: VariadicInstructionConfig = {\n  constant: [\n    Identifiers.pureFunction0,\n    Identifiers.pureFunction1,\n    Identifiers.pureFunction2,\n    Identifiers.pureFunction3,\n    Identifiers.pureFunction4,\n    Identifiers.pureFunction5,\n    Identifiers.pureFunction6,\n    Identifiers.pureFunction7,\n    Identifiers.pureFunction8,\n  ],\n  variable: Identifiers.pureFunctionV,\n  mapping: n => n,\n};\n\nfunction callVariadicInstructionExpr(\n    config: VariadicInstructionConfig, baseArgs: o.Expression[],\n    interpolationArgs: o.Expression[]): o.Expression {\n  const n = config.mapping(interpolationArgs.length);\n  if (n < config.constant.length) {\n    // Constant calling pattern.\n    return o.importExpr(config.constant[n]).callFn([...baseArgs, ...interpolationArgs]);\n  } else if (config.variable !== null) {\n    // Variable calling pattern.\n    return o.importExpr(config.variable).callFn([...baseArgs, o.literalArr(interpolationArgs)]);\n  } else {\n    throw new Error(`AssertionError: unable to call variadic function`);\n  }\n}\n\nfunction callVariadicInstruction(\n    config: VariadicInstructionConfig, baseArgs: o.Expression[],\n    interpolationArgs: o.Expression[]): ir.UpdateOp {\n  return ir.createStatementOp(\n      callVariadicInstructionExpr(config, baseArgs, interpolationArgs).toStmt());\n}\n"]}

package/esm2022/src/template/pipeline/src/phases/align_pipe_variadic_var_offset.mjs

@@ -0,0 +1,41 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import * as ir from '../../ir';
+import { varsUsedByIrExpression } from './var_counting';
+export function phaseAlignPipeVariadicVarOffset(cpl) {
+    for (const view of cpl.views.values()) {
+        for (const op of view.update) {
+            ir.visitExpressionsInOp(op, expr => {
+                if (!(expr instanceof ir.PipeBindingVariadicExpr)) {
+                    return expr;
+                }
+                if (!(expr.args instanceof ir.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);
+            });
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/template/pipeline/src/phases/next_context_merging.mjs

@@ -41,6 +41,9 @@ function mergeNextContextsInOps(ops) {
         let tryToMerge = true;
         for (let candidate = op.next; candidate.kind !== ir.OpKind.ListEnd && tryToMerge; candidate = candidate.next) {
             ir.visitExpressionsInOp(candidate, (expr, flags) => {
+                if (!ir.isIrExpression(expr)) {
+                    return expr;
+                }
                 if (!tryToMerge) {
                     // Either we've already merged, or failed to merge.
                     return;
@@ -66,4 +69,4 @@ function mergeNextContextsInOps(ops) {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/template/pipeline/src/phases/pipe_creation.mjs

@@ -0,0 +1,57 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import * as ir from '../../ir';
+export function phasePipeCreation(cpl) {
+    for (const view of cpl.views.values()) {
+        processPipeBindingsInView(view);
+    }
+}
+function processPipeBindingsInView(view) {
+    for (const updateOp of view.update) {
+        ir.visitExpressionsInOp(updateOp, (expr, flags) => {
+            if (!ir.isIrExpression(expr)) {
+                return;
+            }
+            if (expr.kind !== ir.ExpressionKind.PipeBinding) {
+                return;
+            }
+            if (flags & ir.VisitorContextFlag.InChildOperation) {
+                throw new Error(`AssertionError: pipe bindings should not appear in child expressions`);
+            }
+            if (!ir.hasDependsOnSlotContextTrait(updateOp)) {
+                throw new Error(`AssertionError: pipe binding associated with non-slot operation ${ir.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 !== ir.OpKind.ListEnd; op = op.next) {
+        if (!ir.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 === ir.OpKind.Pipe) {
+            op = op.next;
+        }
+        const pipe = ir.createPipeOp(binding.target, binding.name);
+        ir.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}`);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/template/pipeline/src/phases/pipe_variadic.mjs

@@ -0,0 +1,26 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import * as o from '../../../../output/output_ast';
+import * as ir from '../../ir';
+export function phasePipeVariadic(cpl) {
+    for (const view of cpl.views.values()) {
+        for (const op of view.update) {
+            ir.transformExpressionsInOp(op, expr => {
+                if (!(expr instanceof ir.PipeBindingExpr)) {
+                    return expr;
+                }
+                // Pipes are variadic if they have more than 4 arguments.
+                if (expr.args.length <= 4) {
+                    return expr;
+                }
+                return new ir.PipeBindingVariadicExpr(expr.target, expr.name, o.literalArr(expr.args), expr.args.length);
+            }, ir.VisitorContextFlag.None);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/template/pipeline/src/phases/pure_function_extraction.mjs

@@ -0,0 +1,54 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { GenericKeyFn } from '../../../../constant_pool';
+import * as o from '../../../../output/output_ast';
+import * as ir from '../../ir';
+export function phasePureFunctionExtraction(cpl) {
+    for (const view of cpl.views.values()) {
+        for (const op of view.ops()) {
+            ir.visitExpressionsInOp(op, expr => {
+                if (!(expr instanceof ir.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 ir.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 o.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 = ir.transformExpressionsInExpression(keyExpr, expr => {
+            if (!(expr instanceof ir.PureFunctionParameterExpr)) {
+                return expr;
+            }
+            return o.variable('_p' + expr.index);
+        }, ir.VisitorContextFlag.None);
+        return new o.DeclareFunctionStmt(declName, fnParams, [new o.ReturnStatement(returnExpr)]);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/template/pipeline/src/phases/pure_literal_structures.mjs

@@ -0,0 +1,58 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import * as o from '../../../../output/output_ast';
+import * as ir from '../../ir';
+export function phasePureLiteralStructures(cpl) {
+    for (const view of cpl.views.values()) {
+        for (const op of view.update) {
+            ir.transformExpressionsInOp(op, (expr, flags) => {
+                if (flags & ir.VisitorContextFlag.InChildOperation) {
+                    return expr;
+                }
+                if (expr instanceof o.LiteralArrayExpr) {
+                    return transformLiteralArray(expr);
+                }
+                else if (expr instanceof o.LiteralMapExpr) {
+                    return transformLiteralMap(expr);
+                }
+                return expr;
+            }, ir.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 ir.PureFunctionParameterExpr(idx));
+        }
+    }
+    return new ir.PureFunctionExpr(o.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 o.LiteralMapEntry(entry.key, new ir.PureFunctionParameterExpr(idx), entry.quoted));
+        }
+    }
+    return new ir.PureFunctionExpr(o.literalMap(derivedEntries), nonConstantArgs);
+}
+//# sourceMappingURL=data:application/json;base64,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