@angular/compiler 16.0.0-next.7 → 16.0.0-rc.0

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

@@ -0,0 +1,194 @@
+/**
+ * @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 e from '../../../expression_parser/ast';
+import * as o from '../../../output/output_ast';
+import * as t from '../../../render3/r3_ast';
+import * as ir from '../ir';
+import { ComponentCompilation } from './compilation';
+/**
+ * Process a template AST and convert it into a `ComponentCompilation` in the intermediate
+ * representation.
+ */
+export function ingest(componentName, template) {
+    const cpl = new ComponentCompilation(componentName);
+    ingestNodes(cpl.root, template);
+    return cpl;
+}
+/**
+ * Ingest the nodes of a template AST into the given `ViewCompilation`.
+ */
+function ingestNodes(view, template) {
+    for (const node of template) {
+        if (node instanceof t.Element) {
+            ingestElement(view, node);
+        }
+        else if (node instanceof t.Template) {
+            ingestTemplate(view, node);
+        }
+        else if (node instanceof t.Text) {
+            ingestText(view, node);
+        }
+        else if (node instanceof t.BoundText) {
+            ingestBoundText(view, node);
+        }
+        else {
+            throw new Error(`Unsupported template node: ${node.constructor.name}`);
+        }
+    }
+}
+/**
+ * Ingest an element AST from the template into the given `ViewCompilation`.
+ */
+function ingestElement(view, element) {
+    const staticAttributes = {};
+    for (const attr of element.attributes) {
+        staticAttributes[attr.name] = attr.value;
+    }
+    const id = view.tpl.allocateXrefId();
+    const startOp = ir.createElementStartOp(element.name, id);
+    view.create.push(startOp);
+    ingestAttributes(startOp, element);
+    ingestBindings(view, startOp, element);
+    ingestReferences(startOp, element);
+    ingestNodes(view, element.children);
+    view.create.push(ir.createElementEndOp(id));
+}
+/**
+ * Ingest an `ng-template` node from the AST into the given `ViewCompilation`.
+ */
+function ingestTemplate(view, tmpl) {
+    const childView = view.tpl.allocateView(view.xref);
+    // TODO: validate the fallback tag name here.
+    const tplOp = ir.createTemplateOp(childView.xref, tmpl.tagName ?? 'ng-template');
+    view.create.push(tplOp);
+    ingestAttributes(tplOp, tmpl);
+    ingestBindings(view, tplOp, tmpl);
+    ingestReferences(tplOp, tmpl);
+    ingestNodes(childView, tmpl.children);
+    for (const { name, value } of tmpl.variables) {
+        childView.contextVariables.set(name, value);
+    }
+}
+/**
+ * Ingest a literal text node from the AST into the given `ViewCompilation`.
+ */
+function ingestText(view, text) {
+    view.create.push(ir.createTextOp(view.tpl.allocateXrefId(), text.value));
+}
+/**
+ * Ingest an interpolated text node from the AST into the given `ViewCompilation`.
+ */
+function ingestBoundText(view, text) {
+    let value = text.value;
+    if (value instanceof e.ASTWithSource) {
+        value = value.ast;
+    }
+    if (!(value instanceof e.Interpolation)) {
+        throw new Error(`AssertionError: expected Interpolation for BoundText node, got ${value.constructor.name}`);
+    }
+    const textXref = view.tpl.allocateXrefId();
+    view.create.push(ir.createTextOp(textXref, ''));
+    view.update.push(ir.createInterpolateTextOp(textXref, value.strings, value.expressions.map(expr => convertAst(expr))));
+}
+/**
+ * Convert a template AST expression into an output AST expression.
+ */
+function convertAst(ast) {
+    if (ast instanceof e.ASTWithSource) {
+        return convertAst(ast.ast);
+    }
+    else if (ast instanceof e.PropertyRead) {
+        if (ast.receiver instanceof e.ImplicitReceiver) {
+            return new ir.LexicalReadExpr(ast.name);
+        }
+        else {
+            return new o.ReadPropExpr(convertAst(ast.receiver), ast.name);
+        }
+    }
+    else if (ast instanceof e.Call) {
+        if (ast.receiver instanceof e.ImplicitReceiver) {
+            throw new Error(`Unexpected ImplicitReceiver`);
+        }
+        else {
+            return new o.InvokeFunctionExpr(convertAst(ast.receiver), ast.args.map(arg => convertAst(arg)));
+        }
+    }
+    else {
+        throw new Error(`Unhandled expression type: ${ast.constructor.name}`);
+    }
+}
+/**
+ * Process all of the attributes on an element-like structure in the template AST and convert them
+ * to their IR representation.
+ */
+function ingestAttributes(op, element) {
+    ir.assertIsElementAttributes(op.attributes);
+    for (const attr of element.attributes) {
+        op.attributes.add(ir.ElementAttributeKind.Attribute, attr.name, o.literal(attr.value));
+    }
+    for (const input of element.inputs) {
+        op.attributes.add(ir.ElementAttributeKind.Binding, input.name, null);
+    }
+    for (const output of element.outputs) {
+        op.attributes.add(ir.ElementAttributeKind.Binding, output.name, null);
+    }
+    if (element instanceof t.Template) {
+        for (const attr of element.templateAttrs) {
+            // TODO: what do we do about the value here?
+            op.attributes.add(ir.ElementAttributeKind.Template, attr.name, null);
+        }
+    }
+}
+/**
+ * Process all of the bindings on an element-like structure in the template AST and convert them
+ * to their IR representation.
+ */
+function ingestBindings(view, op, element) {
+    if (element instanceof t.Template) {
+        for (const attr of element.templateAttrs) {
+            if (typeof attr.value === 'string') {
+                throw new Error(`TODO: unhandled static attribute bindings (is this a thing?)`);
+            }
+            else {
+                view.update.push(ir.createPropertyOp(op.xref, attr.name, convertAst(attr.value)));
+            }
+        }
+    }
+    else {
+        for (const input of element.inputs) {
+            view.update.push(ir.createPropertyOp(op.xref, input.name, convertAst(input.value)));
+        }
+        for (const output of element.outputs) {
+            const listenerOp = ir.createListenerOp(op.xref, output.name);
+            listenerOp.handlerOps.push(ir.createStatementOp(new o.ReturnStatement(convertAst(output.handler))));
+            view.create.push(listenerOp);
+        }
+    }
+}
+/**
+ * Process all of the local references on an element-like structure in the template AST and convert
+ * them to their IR representation.
+ */
+function ingestReferences(op, element) {
+    assertIsArray(op.localRefs);
+    for (const { name, value } of element.references) {
+        op.localRefs.push({
+            name,
+            target: value,
+        });
+    }
+}
+/**
+ * Assert that the given value is an array.
+ */
+function assertIsArray(value) {
+    if (!Array.isArray(value)) {
+        throw new Error(`AssertionError: expected an array`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ingest.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler/src/template/pipeline/src/ingest.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 e from '../../../expression_parser/ast';\nimport * as o from '../../../output/output_ast';\nimport * as t from '../../../render3/r3_ast';\nimport * as ir from '../ir';\n\nimport {ComponentCompilation, ViewCompilation} from './compilation';\n\n/**\n * Process a template AST and convert it into a `ComponentCompilation` in the intermediate\n * representation.\n */\nexport function ingest(componentName: string, template: t.Node[]): ComponentCompilation {\n  const cpl = new ComponentCompilation(componentName);\n  ingestNodes(cpl.root, template);\n  return cpl;\n}\n\n/**\n * Ingest the nodes of a template AST into the given `ViewCompilation`.\n */\nfunction ingestNodes(view: ViewCompilation, template: t.Node[]): void {\n  for (const node of template) {\n    if (node instanceof t.Element) {\n      ingestElement(view, node);\n    } else if (node instanceof t.Template) {\n      ingestTemplate(view, node);\n    } else if (node instanceof t.Text) {\n      ingestText(view, node);\n    } else if (node instanceof t.BoundText) {\n      ingestBoundText(view, node);\n    } else {\n      throw new Error(`Unsupported template node: ${node.constructor.name}`);\n    }\n  }\n}\n\n/**\n * Ingest an element AST from the template into the given `ViewCompilation`.\n */\nfunction ingestElement(view: ViewCompilation, element: t.Element): void {\n  const staticAttributes: Record<string, string> = {};\n  for (const attr of element.attributes) {\n    staticAttributes[attr.name] = attr.value;\n  }\n  const id = view.tpl.allocateXrefId();\n\n  const startOp = ir.createElementStartOp(element.name, id);\n  view.create.push(startOp);\n\n  ingestAttributes(startOp, element);\n  ingestBindings(view, startOp, element);\n  ingestReferences(startOp, element);\n\n  ingestNodes(view, element.children);\n  view.create.push(ir.createElementEndOp(id));\n}\n\n/**\n * Ingest an `ng-template` node from the AST into the given `ViewCompilation`.\n */\nfunction ingestTemplate(view: ViewCompilation, tmpl: t.Template): void {\n  const childView = view.tpl.allocateView(view.xref);\n\n  // TODO: validate the fallback tag name here.\n  const tplOp = ir.createTemplateOp(childView.xref, tmpl.tagName ?? 'ng-template');\n  view.create.push(tplOp);\n\n  ingestAttributes(tplOp, tmpl);\n  ingestBindings(view, tplOp, tmpl);\n  ingestReferences(tplOp, tmpl);\n\n  ingestNodes(childView, tmpl.children);\n\n  for (const {name, value} of tmpl.variables) {\n    childView.contextVariables.set(name, value);\n  }\n}\n\n/**\n * Ingest a literal text node from the AST into the given `ViewCompilation`.\n */\nfunction ingestText(view: ViewCompilation, text: t.Text): void {\n  view.create.push(ir.createTextOp(view.tpl.allocateXrefId(), text.value));\n}\n\n/**\n * Ingest an interpolated text node from the AST into the given `ViewCompilation`.\n */\nfunction ingestBoundText(view: ViewCompilation, text: t.BoundText): void {\n  let value = text.value;\n  if (value instanceof e.ASTWithSource) {\n    value = value.ast;\n  }\n  if (!(value instanceof e.Interpolation)) {\n    throw new Error(\n        `AssertionError: expected Interpolation for BoundText node, got ${value.constructor.name}`);\n  }\n\n  const textXref = view.tpl.allocateXrefId();\n  view.create.push(ir.createTextOp(textXref, ''));\n  view.update.push(ir.createInterpolateTextOp(\n      textXref, value.strings, value.expressions.map(expr => convertAst(expr))));\n}\n\n/**\n * Convert a template AST expression into an output AST expression.\n */\nfunction convertAst(ast: e.AST): o.Expression {\n  if (ast instanceof e.ASTWithSource) {\n    return convertAst(ast.ast);\n  } else if (ast instanceof e.PropertyRead) {\n    if (ast.receiver instanceof e.ImplicitReceiver) {\n      return new ir.LexicalReadExpr(ast.name);\n    } else {\n      return new o.ReadPropExpr(convertAst(ast.receiver), ast.name);\n    }\n  } else if (ast instanceof e.Call) {\n    if (ast.receiver instanceof e.ImplicitReceiver) {\n      throw new Error(`Unexpected ImplicitReceiver`);\n    } else {\n      return new o.InvokeFunctionExpr(\n          convertAst(ast.receiver), ast.args.map(arg => convertAst(arg)));\n    }\n  } else {\n    throw new Error(`Unhandled expression type: ${ast.constructor.name}`);\n  }\n}\n\n/**\n * Process all of the attributes on an element-like structure in the template AST and convert them\n * to their IR representation.\n */\nfunction ingestAttributes(op: ir.ElementOpBase, element: t.Element|t.Template): void {\n  ir.assertIsElementAttributes(op.attributes);\n  for (const attr of element.attributes) {\n    op.attributes.add(ir.ElementAttributeKind.Attribute, attr.name, o.literal(attr.value));\n  }\n\n  for (const input of element.inputs) {\n    op.attributes.add(ir.ElementAttributeKind.Binding, input.name, null);\n  }\n  for (const output of element.outputs) {\n    op.attributes.add(ir.ElementAttributeKind.Binding, output.name, null);\n  }\n\n  if (element instanceof t.Template) {\n    for (const attr of element.templateAttrs) {\n      // TODO: what do we do about the value here?\n      op.attributes.add(ir.ElementAttributeKind.Template, attr.name, null);\n    }\n  }\n}\n\n/**\n * Process all of the bindings on an element-like structure in the template AST and convert them\n * to their IR representation.\n */\nfunction ingestBindings(\n    view: ViewCompilation, op: ir.ElementOpBase, element: t.Element|t.Template): void {\n  if (element instanceof t.Template) {\n    for (const attr of element.templateAttrs) {\n      if (typeof attr.value === 'string') {\n        throw new Error(`TODO: unhandled static attribute bindings (is this a thing?)`);\n      } else {\n        view.update.push(ir.createPropertyOp(op.xref, attr.name, convertAst(attr.value)));\n      }\n    }\n  } else {\n    for (const input of element.inputs) {\n      view.update.push(ir.createPropertyOp(op.xref, input.name, convertAst(input.value)));\n    }\n\n    for (const output of element.outputs) {\n      const listenerOp = ir.createListenerOp(op.xref, output.name);\n      listenerOp.handlerOps.push(\n          ir.createStatementOp(new o.ReturnStatement(convertAst(output.handler))));\n      view.create.push(listenerOp);\n    }\n  }\n}\n\n/**\n * Process all of the local references on an element-like structure in the template AST and convert\n * them to their IR representation.\n */\nfunction ingestReferences(op: ir.ElementOpBase, element: t.Element|t.Template): void {\n  assertIsArray<ir.LocalRef>(op.localRefs);\n  for (const {name, value} of element.references) {\n    op.localRefs.push({\n      name,\n      target: value,\n    });\n  }\n}\n\n/**\n * Assert that the given value is an array.\n */\nfunction assertIsArray<T>(value: any): asserts value is Array<T> {\n  if (!Array.isArray(value)) {\n    throw new Error(`AssertionError: expected an array`);\n  }\n}\n"]}

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

@@ -0,0 +1,139 @@
+/**
+ * @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 { Identifiers } from '../../../render3/r3_identifiers';
+import * as ir from '../ir';
+// This file contains helpers for generating calls to Ivy instructions. In particular, each
+// instruction type is represented as a function, which may select a specific instruction variant
+// depending on the exact arguments.
+export function element(slot, tag, constIndex, localRefIndex) {
+    return elementStartBase(Identifiers.element, slot, tag, constIndex, localRefIndex);
+}
+export function elementStart(slot, tag, constIndex, localRefIndex) {
+    return elementStartBase(Identifiers.elementStart, slot, tag, constIndex, localRefIndex);
+}
+function elementStartBase(instruction, slot, tag, constIndex, localRefIndex) {
+    const args = [
+        o.literal(slot),
+        o.literal(tag),
+    ];
+    if (localRefIndex !== null) {
+        args.push(o.literal(constIndex), // might be null, but that's okay.
+        o.literal(localRefIndex));
+    }
+    else if (constIndex !== null) {
+        args.push(o.literal(constIndex));
+    }
+    return call(instruction, args);
+}
+export function elementEnd() {
+    return call(Identifiers.elementEnd, []);
+}
+export function template(slot, templateFnRef, decls, vars, tag, constIndex) {
+    return call(Identifiers.templateCreate, [
+        o.literal(slot),
+        templateFnRef,
+        o.literal(decls),
+        o.literal(vars),
+        o.literal(tag),
+        o.literal(constIndex),
+    ]);
+}
+export function listener(name, handlerFn) {
+    return call(Identifiers.listener, [
+        o.literal(name),
+        handlerFn,
+    ]);
+}
+export function advance(delta) {
+    return call(Identifiers.advance, [
+        o.literal(delta),
+    ]);
+}
+export function reference(slot) {
+    return o.importExpr(Identifiers.reference).callFn([
+        o.literal(slot),
+    ]);
+}
+export function nextContext() {
+    return o.importExpr(Identifiers.nextContext).callFn([]);
+}
+export function getCurrentView() {
+    return o.importExpr(Identifiers.getCurrentView).callFn([]);
+}
+export function restoreView(savedView) {
+    return o.importExpr(Identifiers.restoreView).callFn([
+        savedView,
+    ]);
+}
+export function resetView(returnValue) {
+    return o.importExpr(Identifiers.reference).callFn([
+        returnValue,
+    ]);
+}
+export function text(slot, initialValue) {
+    const args = [o.literal(slot)];
+    if (initialValue !== '') {
+        args.push(o.literal(initialValue));
+    }
+    return call(Identifiers.text, args);
+}
+export function property(name, expression) {
+    return call(Identifiers.property, [
+        o.literal(name),
+        expression,
+    ]);
+}
+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`);
+    }
+    const interpolationArgs = [];
+    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 callInterpolation(TEXT_INTERPOLATE_CONFIG, [], interpolationArgs);
+}
+function call(instruction, args) {
+    return ir.createStatementOp(o.importExpr(instruction).callFn(args).toStmt());
+}
+/**
+ * `InterpolationConfig` for the `textInterpolate` instruction.
+ */
+const TEXT_INTERPOLATE_CONFIG = {
+    constant: [
+        Identifiers.textInterpolate,
+        Identifiers.textInterpolate1,
+        Identifiers.textInterpolate2,
+        Identifiers.textInterpolate3,
+        Identifiers.textInterpolate4,
+        Identifiers.textInterpolate5,
+        Identifiers.textInterpolate6,
+        Identifiers.textInterpolate7,
+        Identifiers.textInterpolate8,
+    ],
+    variable: Identifiers.textInterpolateV,
+};
+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;
+    if (n < config.constant.length) {
+        // Constant calling pattern.
+        return call(config.constant[n], [...baseArgs, ...interpolationArgs]);
+    }
+    else {
+        // Variable calling pattern.
+        return call(config.variable, [...baseArgs, o.literalArr(interpolationArgs)]);
+    }
+}
+//# 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 elementStartBase(Identifiers.element, slot, tag, constIndex, localRefIndex);\n}\n\n\nexport function elementStart(\n    slot: number, tag: string, constIndex: number|null, localRefIndex: number|null): ir.CreateOp {\n  return elementStartBase(Identifiers.elementStart, slot, tag, constIndex, localRefIndex);\n}\n\nfunction elementStartBase(\n    instruction: o.ExternalReference, slot: number, tag: string, constIndex: number|null,\n    localRefIndex: number|null): ir.CreateOp {\n  const args: o.Expression[] = [\n    o.literal(slot),\n    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 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(): o.Expression {\n  return o.importExpr(Identifiers.nextContext).callFn([]);\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.reference).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  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  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"]}

package/esm2022/src/template/pipeline/src/phases/const_collection.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 o from '../../../../output/output_ast';
+import * as ir from '../../ir';
+import { ElementAttributes } from '../../ir/src/element';
+/**
+ * Converts the semantic attributes of element-like operations (elements, templates) into constant
+ * array expressions, and lifts them into the overall component `consts`.
+ */
+export function phaseConstCollection(cpl) {
+    for (const [_, view] of cpl.views) {
+        for (const op of view.create) {
+            if (op.kind !== ir.OpKind.ElementStart && op.kind !== ir.OpKind.Element &&
+                op.kind !== ir.OpKind.Template) {
+                continue;
+            }
+            else if (!(op.attributes instanceof ElementAttributes)) {
+                continue;
+            }
+            const attrArray = serializeAttributes(op.attributes);
+            if (attrArray.entries.length > 0) {
+                op.attributes = cpl.addConst(attrArray);
+            }
+            else {
+                op.attributes = null;
+            }
+        }
+    }
+}
+function serializeAttributes({ attributes, bindings, classes, i18n, projectAs, styles, template }) {
+    const attrArray = [...attributes];
+    if (projectAs !== null) {
+        attrArray.push(o.literal(5 /* core.AttributeMarker.ProjectAs */), o.literal(projectAs));
+    }
+    if (classes.length > 0) {
+        attrArray.push(o.literal(1 /* core.AttributeMarker.Classes */), ...classes);
+    }
+    if (styles.length > 0) {
+        attrArray.push(o.literal(2 /* core.AttributeMarker.Styles */), ...styles);
+    }
+    if (bindings.length > 0) {
+        attrArray.push(o.literal(3 /* core.AttributeMarker.Bindings */), ...bindings);
+    }
+    if (template.length > 0) {
+        attrArray.push(o.literal(4 /* core.AttributeMarker.Template */), ...template);
+    }
+    if (i18n.length > 0) {
+        attrArray.push(o.literal(6 /* core.AttributeMarker.I18n */), ...i18n);
+    }
+    return o.literalArr(attrArray);
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,27 @@
+/**
+ * @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';
+/**
+ * Replace sequences of `ElementStart` followed by `ElementEnd` with a condensed `Element`
+ * instruction.
+ */
+export function phaseEmptyElements(cpl) {
+    for (const [_, view] of cpl.views) {
+        for (const op of view.create) {
+            if (op.kind === ir.OpKind.ElementEnd && op.prev !== null &&
+                op.prev.kind === ir.OpKind.ElementStart) {
+                // Transmute the `ElementStart` instruction to `Element`. This is safe as they're designed
+                // to be identical apart from the `kind`.
+                op.prev.kind = ir.OpKind.Element;
+                // Remove the `ElementEnd` instruction.
+                ir.OpList.remove(op);
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,56 @@
+/**
+ * @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';
+/**
+ * Generate `ir.AdvanceOp`s in between `ir.UpdateOp`s that ensure the runtime's implicit slot
+ * context will be advanced correctly.
+ */
+export function phaseGenerateAdvance(cpl) {
+    for (const [_, view] of cpl.views) {
+        // First build a map of all of the declarations in the view that have assigned slots.
+        const slotMap = new Map();
+        for (const op of view.create) {
+            if (!ir.hasConsumesSlotTrait(op)) {
+                continue;
+            }
+            else if (op.slot === null) {
+                throw new Error(`AssertionError: expected slots to have been allocated before generating advance() calls`);
+            }
+            slotMap.set(op.xref, op.slot);
+        }
+        // Next, step through the update operations and generate `ir.AdvanceOp`s as required to ensure
+        // the runtime's implicit slot counter will be set to the correct slot before executing each
+        // update operation which depends on it.
+        //
+        // To do that, we track what the runtime's slot counter will be through the update operations.
+        let slotContext = 0;
+        for (const op of view.update) {
+            if (!ir.hasDependsOnSlotContextTrait(op)) {
+                // `op` doesn't depend on the slot counter, so it can be skipped.
+                continue;
+            }
+            else if (!slotMap.has(op.target)) {
+                // We expect ops that _do_ depend on the slot counter to point at declarations that exist in
+                // the `slotMap`.
+                throw new Error(`AssertionError: reference to unknown slot for var ${op.target}`);
+            }
+            const slot = slotMap.get(op.target);
+            // Does the slot counter need to be adjusted?
+            if (slotContext !== slot) {
+                // If so, generate an `ir.AdvanceOp` to advance the counter.
+                const delta = slot - slotContext;
+                if (delta < 0) {
+                    throw new Error(`AssertionError: slot counter should never need to move backwards`);
+                }
+                ir.OpList.insertBefore(op, ir.createAdvanceOp(delta));
+                slotContext = slot;
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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