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

package/esm2022/src/template/pipeline/ir/src/ops/create.mjs

@@ -0,0 +1,78 @@
+/**
+ * @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 { ElementAttributes } from '../element';
+import { OpKind } from '../enums';
+import { OpList } from '../operations';
+import { TRAIT_CONSUMES_SLOT } from '../traits';
+import { NEW_OP } from './shared';
+/**
+ * Create an `ElementStartOp`.
+ */
+export function createElementStartOp(tag, xref) {
+    return {
+        kind: OpKind.ElementStart,
+        xref,
+        tag,
+        attributes: new ElementAttributes(),
+        localRefs: [],
+        ...TRAIT_CONSUMES_SLOT,
+        ...NEW_OP,
+    };
+}
+/**
+ * Create a `TemplateOp`.
+ */
+export function createTemplateOp(xref, tag) {
+    return {
+        kind: OpKind.Template,
+        xref,
+        attributes: new ElementAttributes(),
+        tag,
+        decls: null,
+        vars: null,
+        localRefs: [],
+        ...TRAIT_CONSUMES_SLOT,
+        ...NEW_OP,
+    };
+}
+/**
+ * Create an `ElementEndOp`.
+ */
+export function createElementEndOp(xref) {
+    return {
+        kind: OpKind.ElementEnd,
+        xref,
+        ...NEW_OP,
+    };
+}
+/**
+ * Create a `TextOp`.
+ */
+export function createTextOp(xref, initialValue) {
+    return {
+        kind: OpKind.Text,
+        xref,
+        initialValue,
+        ...TRAIT_CONSUMES_SLOT,
+        ...NEW_OP,
+    };
+}
+/**
+ * Create a `ListenerOp`.
+ */
+export function createListenerOp(xref, name) {
+    return {
+        kind: OpKind.Listener,
+        xref,
+        name,
+        handlerOps: new OpList(),
+        handlerFnName: null,
+        ...NEW_OP,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"create.js","sourceRoot":"","sources":["../../../../../../../../../../../packages/compiler/src/template/pipeline/ir/src/ops/create.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,iBAAiB,EAAC,MAAM,YAAY,CAAC;AAC7C,OAAO,EAAC,MAAM,EAAC,MAAM,UAAU,CAAC;AAChC,OAAO,EAAK,MAAM,EAAS,MAAM,eAAe,CAAC;AACjD,OAAO,EAAsB,mBAAmB,EAAC,MAAM,WAAW,CAAC;AAEnE,OAAO,EAAY,MAAM,EAA0B,MAAM,UAAU,CAAC;AAwEpE;;GAEG;AACH,MAAM,UAAU,oBAAoB,CAAC,GAAW,EAAE,IAAY;IAC5D,OAAO;QACL,IAAI,EAAE,MAAM,CAAC,YAAY;QACzB,IAAI;QACJ,GAAG;QACH,UAAU,EAAE,IAAI,iBAAiB,EAAE;QACnC,SAAS,EAAE,EAAE;QACb,GAAG,mBAAmB;QACtB,GAAG,MAAM;KACV,CAAC;AACJ,CAAC;AA4BD;;GAEG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAY,EAAE,GAAW;IACxD,OAAO;QACL,IAAI,EAAE,MAAM,CAAC,QAAQ;QACrB,IAAI;QACJ,UAAU,EAAE,IAAI,iBAAiB,EAAE;QACnC,GAAG;QACH,KAAK,EAAE,IAAI;QACX,IAAI,EAAE,IAAI;QACV,SAAS,EAAE,EAAE;QACb,GAAG,mBAAmB;QACtB,GAAG,MAAM;KACV,CAAC;AACJ,CAAC;AAgBD;;GAEG;AACH,MAAM,UAAU,kBAAkB,CAAC,IAAY;IAC7C,OAAO;QACL,IAAI,EAAE,MAAM,CAAC,UAAU;QACvB,IAAI;QACJ,GAAG,MAAM;KACV,CAAC;AACJ,CAAC;AAmBD;;GAEG;AACH,MAAM,UAAU,YAAY,CAAC,IAAY,EAAE,YAAoB;IAC7D,OAAO;QACL,IAAI,EAAE,MAAM,CAAC,IAAI;QACjB,IAAI;QACJ,YAAY;QACZ,GAAG,mBAAmB;QACtB,GAAG,MAAM;KACV,CAAC;AACJ,CAAC;AA6BD;;GAEG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAY,EAAE,IAAY;IACzD,OAAO;QACL,IAAI,EAAE,MAAM,CAAC,QAAQ;QACrB,IAAI;QACJ,IAAI;QACJ,UAAU,EAAE,IAAI,MAAM,EAAE;QACxB,aAAa,EAAE,IAAI;QACnB,GAAG,MAAM;KACV,CAAC;AACJ,CAAC","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 {ElementAttributes} from '../element';\nimport {OpKind} from '../enums';\nimport {Op, OpList, XrefId} from '../operations';\nimport {ConsumesSlotOpTrait, TRAIT_CONSUMES_SLOT} from '../traits';\n\nimport {ListEndOp, NEW_OP, StatementOp, VariableOp} from './shared';\nimport type {UpdateOp} from './update';\n\n/**\n * An operation usable on the creation side of the IR.\n */\nexport type CreateOp = ListEndOp<CreateOp>|StatementOp<CreateOp>|ElementOp|ElementStartOp|\n    ElementEndOp|TemplateOp|TextOp|ListenerOp|VariableOp<CreateOp>;\n\n/**\n * Representation of a local reference on an element.\n */\nexport interface LocalRef {\n  /**\n   * User-defined name of the local ref variable.\n   */\n  name: string;\n\n  /**\n   * Target of the local reference variable (often `''`).\n   */\n  target: string;\n}\n\n/**\n * Base interface for `Element`, `ElementStart`, and `Template` operations, containing common fields\n * used to represent their element-like nature.\n */\nexport interface ElementOpBase extends Op<CreateOp>, ConsumesSlotOpTrait {\n  kind: OpKind.Element|OpKind.ElementStart|OpKind.Template;\n\n  /**\n   * `XrefId` allocated for this element.\n   *\n   * This ID is used to reference this element from other IR structures.\n   */\n  xref: XrefId;\n\n  /**\n   * The HTML tag name for this element.\n   */\n  tag: string;\n\n  /**\n   * Attributes of various kinds on this element.\n   *\n   * Before attribute processing, this is an `ElementAttributes` structure representing the\n   * attributes on this element.\n   *\n   * After processing, it's a `ConstIndex` pointer into the shared `consts` array of the component\n   * compilation.\n   */\n  attributes: ElementAttributes|ConstIndex|null;\n\n  /**\n   * Local references to this element.\n   *\n   * Before local ref processing, this is an array of `LocalRef` declarations.\n   *\n   * After processing, it's a `ConstIndex` pointer into the shared `consts` array of the component\n   * compilation.\n   */\n  localRefs: LocalRef[]|ConstIndex|null;\n}\n\n/**\n * Logical operation representing the start of an element in the creation IR.\n */\nexport interface ElementStartOp extends ElementOpBase {\n  kind: OpKind.ElementStart;\n}\n\n/**\n * Create an `ElementStartOp`.\n */\nexport function createElementStartOp(tag: string, xref: XrefId): ElementStartOp {\n  return {\n    kind: OpKind.ElementStart,\n    xref,\n    tag,\n    attributes: new ElementAttributes(),\n    localRefs: [],\n    ...TRAIT_CONSUMES_SLOT,\n    ...NEW_OP,\n  };\n}\n\n/**\n * Logical operation representing an element with no children in the creation IR.\n */\nexport interface ElementOp extends ElementOpBase {\n  kind: OpKind.Element;\n}\n\n/**\n * Logical operation representing an embedded view declaration in the creation IR.\n */\nexport interface TemplateOp extends ElementOpBase {\n  kind: OpKind.Template;\n\n  /**\n   * The number of declaration slots used by this template, or `null` if slots have not yet been\n   * assigned.\n   */\n  decls: number|null;\n\n  /**\n   * The number of binding variable slots used by this template, or `null` if binding variables have\n   * not yet been counted.\n   */\n  vars: number|null;\n}\n\n/**\n * Create a `TemplateOp`.\n */\nexport function createTemplateOp(xref: XrefId, tag: string): TemplateOp {\n  return {\n    kind: OpKind.Template,\n    xref,\n    attributes: new ElementAttributes(),\n    tag,\n    decls: null,\n    vars: null,\n    localRefs: [],\n    ...TRAIT_CONSUMES_SLOT,\n    ...NEW_OP,\n  };\n}\n\n/**\n * Logical operation representing the end of an element structure in the creation IR.\n *\n * Pairs with an `ElementStart` operation.\n */\nexport interface ElementEndOp extends Op<CreateOp> {\n  kind: OpKind.ElementEnd;\n\n  /**\n   * The `XrefId` of the element declared via `ElementStart`.\n   */\n  xref: XrefId;\n}\n\n/**\n * Create an `ElementEndOp`.\n */\nexport function createElementEndOp(xref: XrefId): ElementEndOp {\n  return {\n    kind: OpKind.ElementEnd,\n    xref,\n    ...NEW_OP,\n  };\n}\n\n/**\n * Logical operation representing a text node in the creation IR.\n */\nexport interface TextOp extends Op<CreateOp>, ConsumesSlotOpTrait {\n  kind: OpKind.Text;\n\n  /**\n   * `XrefId` used to reference this text node in other IR structures.\n   */\n  xref: XrefId;\n\n  /**\n   * The static initial value of the text node.\n   */\n  initialValue: string;\n}\n\n/**\n * Create a `TextOp`.\n */\nexport function createTextOp(xref: XrefId, initialValue: string): TextOp {\n  return {\n    kind: OpKind.Text,\n    xref,\n    initialValue,\n    ...TRAIT_CONSUMES_SLOT,\n    ...NEW_OP,\n  };\n}\n\n/**\n * Logical operation representing an event listener on an element in the creation IR.\n */\nexport interface ListenerOp extends Op<CreateOp> {\n  kind: OpKind.Listener;\n\n  /**\n   * `XrefId` of the element on which the event listener is bound.\n   */\n  xref: XrefId;\n\n  /**\n   * Name of the event which is being listened to.\n   */\n  name: string;\n\n  /**\n   * A list of `UpdateOp`s representing the body of the event listener.\n   */\n  handlerOps: OpList<UpdateOp>;\n\n  /**\n   * Name of the function\n   */\n  handlerFnName: string|null;\n}\n\n/**\n * Create a `ListenerOp`.\n */\nexport function createListenerOp(xref: XrefId, name: string): ListenerOp {\n  return {\n    kind: OpKind.Listener,\n    xref,\n    name,\n    handlerOps: new OpList(),\n    handlerFnName: null,\n    ...NEW_OP,\n  };\n}\n\n/**\n * An index into the `consts` array which is shared across the compilation of all views in a\n * component.\n */\nexport type ConstIndex = number&{__brand: 'ConstIndex'};\n"]}

package/esm2022/src/template/pipeline/ir/src/ops/shared.mjs

@@ -0,0 +1,43 @@
+/**
+ * @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 { OpKind } from '../enums';
+/**
+ * Create a `StatementOp`.
+ */
+export function createStatementOp(statement) {
+    return {
+        kind: OpKind.Statement,
+        statement,
+        ...NEW_OP,
+    };
+}
+/**
+ * Create a `VariableOp`.
+ */
+export function createVariableOp(xref, variable, initializer) {
+    return {
+        kind: OpKind.Variable,
+        xref,
+        name: null,
+        variable,
+        initializer,
+        ...NEW_OP,
+    };
+}
+/**
+ * Static structure shared by all operations.
+ *
+ * Used as a convenience via the spread operator (`...NEW_OP`) when creating new operations, and
+ * ensures the fields are always in the same order.
+ */
+export const NEW_OP = {
+    debugListId: null,
+    prev: null,
+    next: null,
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/template/pipeline/ir/src/ops/update.mjs

@@ -0,0 +1,49 @@
+/**
+ * @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 { OpKind } from '../enums';
+import { TRAIT_CONSUMES_VARS, TRAIT_DEPENDS_ON_SLOT_CONTEXT } from '../traits';
+import { NEW_OP } from './shared';
+/**
+ * Create an `InterpolationTextOp`.
+ */
+export function createInterpolateTextOp(xref, strings, expressions) {
+    return {
+        kind: OpKind.InterpolateText,
+        target: xref,
+        strings,
+        expressions,
+        ...TRAIT_DEPENDS_ON_SLOT_CONTEXT,
+        ...TRAIT_CONSUMES_VARS,
+        ...NEW_OP,
+    };
+}
+/**
+ * Create a `PropertyOp`.
+ */
+export function createPropertyOp(xref, name, expression) {
+    return {
+        kind: OpKind.Property,
+        target: xref,
+        name,
+        expression,
+        ...TRAIT_DEPENDS_ON_SLOT_CONTEXT,
+        ...TRAIT_CONSUMES_VARS,
+        ...NEW_OP,
+    };
+}
+/**
+ * Create an `AdvanceOp`.
+ */
+export function createAdvanceOp(delta) {
+    return {
+        kind: OpKind.Advance,
+        delta,
+        ...NEW_OP,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/template/pipeline/ir/src/traits.mjs

@@ -0,0 +1,68 @@
+/**
+ * @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
+ */
+/**
+ * Marker symbol for `ConsumesSlotOpTrait`.
+ */
+export const ConsumesSlot = Symbol('ConsumesSlot');
+/**
+ * Marker symbol for `DependsOnSlotContextOpTrait`.
+ */
+export const DependsOnSlotContext = Symbol('DependsOnSlotContext');
+/**
+ * Marker symbol for `UsesSlotIndex` trait.
+ */
+export const UsesSlotIndex = Symbol('UsesSlotIndex');
+/**
+ * Marker symbol for `ConsumesVars` trait.
+ */
+export const ConsumesVarsTrait = Symbol('UsesVars');
+/**
+ * Default values for most `ConsumesSlotOpTrait` fields (used with the spread operator to initialize
+ * implementors of the trait).
+ */
+export const TRAIT_CONSUMES_SLOT = {
+    [ConsumesSlot]: true,
+    slot: null,
+    numSlotsUsed: 1,
+};
+/**
+ * Default values for most `DependsOnSlotContextOpTrait` fields (used with the spread operator to
+ * initialize implementors of the trait).
+ */
+export const TRAIT_DEPENDS_ON_SLOT_CONTEXT = {
+    [DependsOnSlotContext]: true,
+};
+/**
+ * Default values for `UsesVars` fields (used with the spread operator to initialize
+ * implementors of the trait).
+ */
+export const TRAIT_CONSUMES_VARS = {
+    [ConsumesVarsTrait]: true,
+};
+/**
+ * Test whether an operation implements `ConsumesSlotOpTrait`.
+ */
+export function hasConsumesSlotTrait(op) {
+    return op[ConsumesSlot] === true;
+}
+/**
+ * Test whether an operation implements `DependsOnSlotContextOpTrait`.
+ */
+export function hasDependsOnSlotContextTrait(op) {
+    return op[DependsOnSlotContext] === true;
+}
+export function hasConsumesVarsTrait(value) {
+    return value[ConsumesVarsTrait] === true;
+}
+/**
+ * Test whether an expression implements `UsesSlotIndexExprTrait`.
+ */
+export function hasUsesSlotIndexTrait(expr) {
+    return expr[UsesSlotIndex] === true;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"traits.js","sourceRoot":"","sources":["../../../../../../../../../../packages/compiler/src/template/pipeline/ir/src/traits.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH;;GAEG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC;AAEnD;;GAEG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,MAAM,CAAC,sBAAsB,CAAC,CAAC;AAEnE;;GAEG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,MAAM,CAAC,eAAe,CAAC,CAAC;AAErD;;GAEG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;AA8EpD;;;GAGG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAsC;IACpE,CAAC,YAAY,CAAC,EAAE,IAAI;IACpB,IAAI,EAAE,IAAI;IACV,YAAY,EAAE,CAAC;CACP,CAAC;AAEX;;;GAGG;AACH,MAAM,CAAC,MAAM,6BAA6B,GAAgD;IACxF,CAAC,oBAAoB,CAAC,EAAE,IAAI;CACpB,CAAC;AAEX;;;GAGG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAsB;IACpD,CAAC,iBAAiB,CAAC,EAAE,IAAI;CACjB,CAAC;AAEX;;GAEG;AACH,MAAM,UAAU,oBAAoB,CAAsB,EAAO;IAC/D,OAAQ,EAAmC,CAAC,YAAY,CAAC,KAAK,IAAI,CAAC;AACrE,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,4BAA4B,CAAsB,EAAO;IAEvE,OAAQ,EAA2C,CAAC,oBAAoB,CAAC,KAAK,IAAI,CAAC;AACrF,CAAC;AAQD,MAAM,UAAU,oBAAoB,CAAC,KAAU;IAC7C,OAAQ,KAAoC,CAAC,iBAAiB,CAAC,KAAK,IAAI,CAAC;AAC3E,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,qBAAqB,CAA2B,IAAW;IAEzE,OAAQ,IAAwC,CAAC,aAAa,CAAC,KAAK,IAAI,CAAC;AAC3E,CAAC","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 type {Op, XrefId} from './operations';\nimport type {Expression} from './expression';\n\n/**\n * Marker symbol for `ConsumesSlotOpTrait`.\n */\nexport const ConsumesSlot = Symbol('ConsumesSlot');\n\n/**\n * Marker symbol for `DependsOnSlotContextOpTrait`.\n */\nexport const DependsOnSlotContext = Symbol('DependsOnSlotContext');\n\n/**\n * Marker symbol for `UsesSlotIndex` trait.\n */\nexport const UsesSlotIndex = Symbol('UsesSlotIndex');\n\n/**\n * Marker symbol for `ConsumesVars` trait.\n */\nexport const ConsumesVarsTrait = Symbol('UsesVars');\n\n/**\n * Marks an operation as requiring allocation of one or more data slots for storage.\n */\nexport interface ConsumesSlotOpTrait {\n  readonly[ConsumesSlot]: true;\n\n  /**\n   * Assigned data slot (the starting index, if more than one slot is needed) for this operation, or\n   * `null` if slots have not yet been assigned.\n   */\n  slot: number|null;\n\n  /**\n   * The number of slots which will be used by this operation. By default 1, but can be increased if\n   * necessary.\n   */\n  numSlotsUsed: number;\n\n  /**\n   * `XrefId` of this operation (e.g. the element stored in the assigned slot). This `XrefId` is\n   * used to link this `ConsumesSlotOpTrait` operation with `DependsOnSlotContextTrait` or\n   * `UsesSlotIndexExprTrait` implementors and ensure that the assigned slot is propagated through\n   * the IR to all consumers.\n   */\n  xref: XrefId;\n}\n\n\n/**\n * Marks an operation as depending on the runtime's implicit slot context being set to a particular\n * slot.\n *\n * The runtime has an implicit slot context which is adjusted using the `advance()` instruction\n * during the execution of template update functions. This trait marks an operation as requiring\n * this implicit context to be `advance()`'d to point at a particular slot prior to execution.\n */\nexport interface DependsOnSlotContextOpTrait {\n  readonly[DependsOnSlotContext]: true;\n\n  /**\n   * `XrefId` of the `ConsumesSlotOpTrait` which the implicit slot context must reference before\n   * this operation can be executed.\n   */\n  target: XrefId;\n}\n\n\n/**\n * Marks an expression which requires knowledge of the assigned slot of a given\n * `ConsumesSlotOpTrait` implementor (e.g. an element slot).\n *\n * During IR processing, assigned slots of `ConsumesSlotOpTrait` implementors will be propagated to\n * `UsesSlotIndexTrait` implementors by matching their `XrefId`s.\n */\nexport interface UsesSlotIndexExprTrait {\n  readonly[UsesSlotIndex]: true;\n\n  /**\n   * `XrefId` of the `ConsumesSlotOpTrait` which this expression needs to reference by its assigned\n   * slot index.\n   */\n  target: XrefId;\n\n  /**\n   * The slot index of `target`, or `null` if slots have not yet been assigned.\n   */\n  slot: number|null;\n}\n\n/**\n * Marker trait indicating that an operation or expression consumes variable storage space.\n */\nexport interface ConsumesVarsTrait {\n  [ConsumesVarsTrait]: true;\n}\n\n/**\n * Default values for most `ConsumesSlotOpTrait` fields (used with the spread operator to initialize\n * implementors of the trait).\n */\nexport const TRAIT_CONSUMES_SLOT: Omit<ConsumesSlotOpTrait, 'xref'> = {\n  [ConsumesSlot]: true,\n  slot: null,\n  numSlotsUsed: 1,\n} as const;\n\n/**\n * Default values for most `DependsOnSlotContextOpTrait` fields (used with the spread operator to\n * initialize implementors of the trait).\n */\nexport const TRAIT_DEPENDS_ON_SLOT_CONTEXT: Omit<DependsOnSlotContextOpTrait, 'target'> = {\n  [DependsOnSlotContext]: true,\n} as const;\n\n/**\n * Default values for `UsesVars` fields (used with the spread operator to initialize\n * implementors of the trait).\n */\nexport const TRAIT_CONSUMES_VARS: ConsumesVarsTrait = {\n  [ConsumesVarsTrait]: true,\n} as const;\n\n/**\n * Test whether an operation implements `ConsumesSlotOpTrait`.\n */\nexport function hasConsumesSlotTrait<OpT extends Op<OpT>>(op: OpT): op is OpT&ConsumesSlotOpTrait {\n  return (op as Partial<ConsumesSlotOpTrait>)[ConsumesSlot] === true;\n}\n\n/**\n * Test whether an operation implements `DependsOnSlotContextOpTrait`.\n */\nexport function hasDependsOnSlotContextTrait<OpT extends Op<OpT>>(op: OpT): op is OpT&\n    DependsOnSlotContextOpTrait {\n  return (op as Partial<DependsOnSlotContextOpTrait>)[DependsOnSlotContext] === true;\n}\n\n/**\n * Test whether an operation implements `ConsumesVarsTrait`.\n */\nexport function hasConsumesVarsTrait<ExprT extends Expression>(expr: ExprT): expr is ExprT&\n    ConsumesVarsTrait;\nexport function hasConsumesVarsTrait<OpT extends Op<OpT>>(op: OpT): op is OpT&ConsumesVarsTrait;\nexport function hasConsumesVarsTrait(value: any): boolean {\n  return (value as Partial<ConsumesVarsTrait>)[ConsumesVarsTrait] === true;\n}\n\n/**\n * Test whether an expression implements `UsesSlotIndexExprTrait`.\n */\nexport function hasUsesSlotIndexTrait<ExprT extends Expression>(expr: ExprT): expr is ExprT&\n    UsesSlotIndexExprTrait {\n  return (expr as Partial<UsesSlotIndexExprTrait>)[UsesSlotIndex] === true;\n}\n"]}

package/esm2022/src/template/pipeline/ir/src/variable.mjs

@@ -0,0 +1,9 @@
+/**
+ * @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
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFyaWFibGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21waWxlci9zcmMvdGVtcGxhdGUvcGlwZWxpbmUvaXIvc3JjL3ZhcmlhYmxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5pbXBvcnQgdHlwZSB7U2VtYW50aWNWYXJpYWJsZUtpbmR9IGZyb20gJy4vZW51bXMnO1xuaW1wb3J0IHR5cGUge1hyZWZJZH0gZnJvbSAnLi9vcGVyYXRpb25zJztcblxuLyoqXG4gKiBVbmlvbiB0eXBlIGZvciB0aGUgZGlmZmVyZW50IGtpbmRzIG9mIHZhcmlhYmxlcy5cbiAqL1xuZXhwb3J0IHR5cGUgU2VtYW50aWNWYXJpYWJsZSA9IENvbnRleHRWYXJpYWJsZXxJZGVudGlmaWVyVmFyaWFibGV8U2F2ZWRWaWV3VmFyaWFibGU7XG5cbi8qKlxuICogQSB2YXJpYWJsZSB0aGF0IHJlcHJlc2VudHMgdGhlIGNvbnRleHQgb2YgYSBwYXJ0aWN1bGFyIHZpZXcuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgQ29udGV4dFZhcmlhYmxlIHtcbiAga2luZDogU2VtYW50aWNWYXJpYWJsZUtpbmQuQ29udGV4dDtcblxuICAvKipcbiAgICogYFhyZWZJZGAgb2YgdGhlIHZpZXcgdGhhdCB0aGlzIHZhcmlhYmxlIHJlcHJlc2VudHMuXG4gICAqL1xuICB2aWV3OiBYcmVmSWQ7XG59XG5cbi8qKlxuICogQSB2YXJpYWJsZSB0aGF0IHJlcHJlc2VudHMgYSBzcGVjaWZpYyBpZGVudGlmaWVyIHdpdGhpbiBhIHRlbXBsYXRlLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIElkZW50aWZpZXJWYXJpYWJsZSB7XG4gIGtpbmQ6IFNlbWFudGljVmFyaWFibGVLaW5kLklkZW50aWZpZXI7XG5cbiAgLyoqXG4gICAqIFRoZSBpZGVudGlmaWVyIHdob3NlIHZhbHVlIGluIHRoZSB0ZW1wbGF0ZSBpcyB0cmFja2VkIGluIHRoaXMgdmFyaWFibGUuXG4gICAqL1xuICBuYW1lOiBzdHJpbmc7XG59XG5cbi8qKlxuICogQSB2YXJpYWJsZSB0aGF0IHJlcHJlc2VudHMgYSBzYXZlZCB2aWV3IGNvbnRleHQuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgU2F2ZWRWaWV3VmFyaWFibGUge1xuICBraW5kOiBTZW1hbnRpY1ZhcmlhYmxlS2luZC5TYXZlZFZpZXc7XG5cbiAgLyoqXG4gICAqIFRoZSB2aWV3IGNvbnRleHQgc2F2ZWQgaW4gdGhpcyB2YXJpYWJsZS5cbiAgICovXG4gIHZpZXc6IFhyZWZJZDtcbn1cbiJdfQ==

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

@@ -0,0 +1,122 @@
+/**
+ * @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';
+/**
+ * Compilation-in-progress of a whole component's template, including the main template and any
+ * embedded views or host bindings.
+ */
+export class ComponentCompilation {
+    constructor(componentName) {
+        this.componentName = componentName;
+        /**
+         * Tracks the next `ir.XrefId` which can be assigned as template structures are ingested.
+         */
+        this.nextXrefId = 0;
+        /**
+         * Map of view IDs to `ViewCompilation`s.
+         */
+        this.views = new Map();
+        /**
+         * Constant expressions used by operations within this component's compilation.
+         *
+         * This will eventually become the `consts` array in the component definition.
+         */
+        this.consts = [];
+        // Allocate the root view.
+        const root = new ViewCompilation(this, this.allocateXrefId(), null);
+        this.views.set(root.xref, root);
+        this.root = root;
+    }
+    /**
+     * Add a `ViewCompilation` for a new embedded view to this compilation.
+     */
+    allocateView(parent) {
+        const view = new ViewCompilation(this, this.allocateXrefId(), parent);
+        this.views.set(view.xref, view);
+        return view;
+    }
+    /**
+     * Generate a new unique `ir.XrefId`.
+     */
+    allocateXrefId() {
+        return this.nextXrefId++;
+    }
+    /**
+     * Add a constant `o.Expression` to the compilation and return its index in the `consts` array.
+     */
+    addConst(newConst) {
+        for (let idx = 0; idx < this.consts.length; idx++) {
+            if (this.consts[idx].isEquivalent(newConst)) {
+                return idx;
+            }
+        }
+        const idx = this.consts.length;
+        this.consts.push(newConst);
+        return idx;
+    }
+}
+/**
+ * Compilation-in-progress of an individual view within a template.
+ */
+export class ViewCompilation {
+    constructor(tpl, xref, parent) {
+        this.tpl = tpl;
+        this.xref = xref;
+        this.parent = parent;
+        /**
+         * Name of the function which will be generated for this view.
+         *
+         * May be `null` if not yet determined.
+         */
+        this.fnName = null;
+        /**
+         * List of creation operations for this view.
+         *
+         * Creation operations may internally contain other operations, including update operations.
+         */
+        this.create = new ir.OpList();
+        /**
+         * List of update operations for this view.
+         */
+        this.update = new ir.OpList();
+        /**
+         * Map of declared variables available within this view to the property on the context object
+         * which they alias.
+         */
+        this.contextVariables = new Map();
+        /**
+         * Number of declaration slots used within this view, or `null` if slots have not yet been
+         * allocated.
+         */
+        this.decls = null;
+        /**
+         * Number of variable slots used within this view, or `null` if variables have not yet been
+         * counted.
+         */
+        this.vars = null;
+    }
+    /**
+     * Iterate over all `ir.Op`s within this view.
+     *
+     * Some operations may have child operations, which this iterator will visit.
+     */
+    *ops() {
+        for (const op of this.create) {
+            yield op;
+            if (op.kind === ir.OpKind.Listener) {
+                for (const listenerOp of op.handlerOps) {
+                    yield listenerOp;
+                }
+            }
+        }
+        for (const op of this.update) {
+            yield op;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"compilation.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler/src/template/pipeline/src/compilation.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,MAAM,OAAO,CAAC;AAE5B;;;GAGG;AACH,MAAM,OAAO,oBAAoB;IAuB/B,YAAqB,aAAqB;QAArB,kBAAa,GAAb,aAAa,CAAQ;QAtB1C;;WAEG;QACK,eAAU,GAAc,CAAc,CAAC;QAE/C;;WAEG;QACM,UAAK,GAAG,IAAI,GAAG,EAA8B,CAAC;QAEvD;;;;WAIG;QACM,WAAM,GAAmB,EAAE,CAAC;QAQnC,0BAA0B;QAC1B,MAAM,IAAI,GAAG,IAAI,eAAe,CAAC,IAAI,EAAE,IAAI,CAAC,cAAc,EAAE,EAAE,IAAI,CAAC,CAAC;QACpE,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QAChC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;IAED;;OAEG;IACH,YAAY,CAAC,MAAiB;QAC5B,MAAM,IAAI,GAAG,IAAI,eAAe,CAAC,IAAI,EAAE,IAAI,CAAC,cAAc,EAAE,EAAE,MAAM,CAAC,CAAC;QACtE,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QAChC,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACH,cAAc;QACZ,OAAO,IAAI,CAAC,UAAU,EAAe,CAAC;IACxC,CAAC;IAED;;OAEG;IACH,QAAQ,CAAC,QAAsB;QAC7B,KAAK,IAAI,GAAG,GAAG,CAAC,EAAE,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,EAAE,EAAE;YACjD,IAAI,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,YAAY,CAAC,QAAQ,CAAC,EAAE;gBAC3C,OAAO,GAAoB,CAAC;aAC7B;SACF;QACD,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC;QAC/B,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC3B,OAAO,GAAoB,CAAC;IAC9B,CAAC;CACF;AAED;;GAEG;AACH,MAAM,OAAO,eAAe;IAC1B,YACa,GAAyB,EAAW,IAAe,EACnD,MAAsB;QADtB,QAAG,GAAH,GAAG,CAAsB;QAAW,SAAI,GAAJ,IAAI,CAAW;QACnD,WAAM,GAAN,MAAM,CAAgB;QAEnC;;;;WAIG;QACH,WAAM,GAAgB,IAAI,CAAC;QAE3B;;;;WAIG;QACM,WAAM,GAAG,IAAI,EAAE,CAAC,MAAM,EAAe,CAAC;QAE/C;;WAEG;QACM,WAAM,GAAG,IAAI,EAAE,CAAC,MAAM,EAAe,CAAC;QAE/C;;;WAGG;QACM,qBAAgB,GAAG,IAAI,GAAG,EAAkB,CAAC;QAEtD;;;WAGG;QACH,UAAK,GAAgB,IAAI,CAAC;QAE1B;;;WAGG;QACH,SAAI,GAAgB,IAAI,CAAC;IArCa,CAAC;IAuCvC;;;;OAIG;IACH,CAAE,GAAG;QACH,KAAK,MAAM,EAAE,IAAI,IAAI,CAAC,MAAM,EAAE;YAC5B,MAAM,EAAE,CAAC;YACT,IAAI,EAAE,CAAC,IAAI,KAAK,EAAE,CAAC,MAAM,CAAC,QAAQ,EAAE;gBAClC,KAAK,MAAM,UAAU,IAAI,EAAE,CAAC,UAAU,EAAE;oBACtC,MAAM,UAAU,CAAC;iBAClB;aACF;SACF;QACD,KAAK,MAAM,EAAE,IAAI,IAAI,CAAC,MAAM,EAAE;YAC5B,MAAM,EAAE,CAAC;SACV;IACH,CAAC;CACF","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 * as ir from '../ir';\n\n/**\n * Compilation-in-progress of a whole component's template, including the main template and any\n * embedded views or host bindings.\n */\nexport class ComponentCompilation {\n  /**\n   * Tracks the next `ir.XrefId` which can be assigned as template structures are ingested.\n   */\n  private nextXrefId: ir.XrefId = 0 as ir.XrefId;\n\n  /**\n   * Map of view IDs to `ViewCompilation`s.\n   */\n  readonly views = new Map<ir.XrefId, ViewCompilation>();\n\n  /**\n   * Constant expressions used by operations within this component's compilation.\n   *\n   * This will eventually become the `consts` array in the component definition.\n   */\n  readonly consts: o.Expression[] = [];\n\n  /**\n   * The root view, representing the component's template.\n   */\n  readonly root: ViewCompilation;\n\n  constructor(readonly componentName: string) {\n    // Allocate the root view.\n    const root = new ViewCompilation(this, this.allocateXrefId(), null);\n    this.views.set(root.xref, root);\n    this.root = root;\n  }\n\n  /**\n   * Add a `ViewCompilation` for a new embedded view to this compilation.\n   */\n  allocateView(parent: ir.XrefId): ViewCompilation {\n    const view = new ViewCompilation(this, this.allocateXrefId(), parent);\n    this.views.set(view.xref, view);\n    return view;\n  }\n\n  /**\n   * Generate a new unique `ir.XrefId`.\n   */\n  allocateXrefId(): ir.XrefId {\n    return this.nextXrefId++ as ir.XrefId;\n  }\n\n  /**\n   * Add a constant `o.Expression` to the compilation and return its index in the `consts` array.\n   */\n  addConst(newConst: o.Expression): ir.ConstIndex {\n    for (let idx = 0; idx < this.consts.length; idx++) {\n      if (this.consts[idx].isEquivalent(newConst)) {\n        return idx as ir.ConstIndex;\n      }\n    }\n    const idx = this.consts.length;\n    this.consts.push(newConst);\n    return idx as ir.ConstIndex;\n  }\n}\n\n/**\n * Compilation-in-progress of an individual view within a template.\n */\nexport class ViewCompilation {\n  constructor(\n      readonly tpl: ComponentCompilation, readonly xref: ir.XrefId,\n      readonly parent: ir.XrefId|null) {}\n\n  /**\n   * Name of the function which will be generated for this view.\n   *\n   * May be `null` if not yet determined.\n   */\n  fnName: string|null = null;\n\n  /**\n   * List of creation operations for this view.\n   *\n   * Creation operations may internally contain other operations, including update operations.\n   */\n  readonly create = new ir.OpList<ir.CreateOp>();\n\n  /**\n   * List of update operations for this view.\n   */\n  readonly update = new ir.OpList<ir.UpdateOp>();\n\n  /**\n   * Map of declared variables available within this view to the property on the context object\n   * which they alias.\n   */\n  readonly contextVariables = new Map<string, string>();\n\n  /**\n   * Number of declaration slots used within this view, or `null` if slots have not yet been\n   * allocated.\n   */\n  decls: number|null = null;\n\n  /**\n   * Number of variable slots used within this view, or `null` if variables have not yet been\n   * counted.\n   */\n  vars: number|null = null;\n\n  /**\n   * Iterate over all `ir.Op`s within this view.\n   *\n   * Some operations may have child operations, which this iterator will visit.\n   */\n  * ops(): Generator<ir.CreateOp|ir.UpdateOp> {\n    for (const op of this.create) {\n      yield op;\n      if (op.kind === ir.OpKind.Listener) {\n        for (const listenerOp of op.handlerOps) {\n          yield listenerOp;\n        }\n      }\n    }\n    for (const op of this.update) {\n      yield op;\n    }\n  }\n}\n"]}

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

@@ -0,0 +1,83 @@
+/**
+ * @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 '../../../../src/output/output_ast';
+import * as ir from '../ir';
+import { phaseConstCollection } from './phases/const_collection';
+import { phaseEmptyElements } from './phases/empty_elements';
+import { phaseGenerateAdvance } from './phases/generate_advance';
+import { phaseReify } from './phases/reify';
+import { phaseSlotAllocation } from './phases/slot_allocation';
+import { phaseVarCounting } from './phases/var_counting';
+import { phaseNaming } from './phases/naming';
+import { phaseLocalRefs } from './phases/local_refs';
+import { phaseGenerateVariables } from './phases/generate_variables';
+import { phaseResolveNames } from './phases/resolve_names';
+import { phaseResolveContexts } from './phases/resolve_contexts';
+/**
+ * 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
+ */
+export function transformTemplate(cpl) {
+    phaseGenerateVariables(cpl);
+    phaseResolveNames(cpl);
+    phaseResolveContexts(cpl);
+    phaseLocalRefs(cpl);
+    phaseEmptyElements(cpl);
+    phaseConstCollection(cpl);
+    phaseSlotAllocation(cpl);
+    phaseVarCounting(cpl);
+    phaseGenerateAdvance(cpl);
+    phaseNaming(cpl);
+    phaseReify(cpl);
+}
+/**
+ * Compile all views in the given `ComponentCompilation` into the final template function, which may
+ * reference constants defined in a `ConstantPool`.
+ */
+export function emitTemplateFn(tpl, pool) {
+    const rootFn = emitView(tpl.root);
+    for (const view of tpl.views.values()) {
+        if (view === tpl.root) {
+            continue;
+        }
+        const viewFn = emitView(view);
+        pool.statements.push(viewFn.toDeclStmt(viewFn.name));
+    }
+    return rootFn;
+}
+/**
+ * Emit a template function for an individual `ViewCompilation` (which may be either the root view
+ * or an embedded view).
+ */
+function emitView(view) {
+    if (view.fnName === null) {
+        throw new Error(`AssertionError: view ${view.xref} is unnamed`);
+    }
+    const createStatements = [];
+    for (const op of view.create) {
+        if (op.kind !== ir.OpKind.Statement) {
+            throw new Error(`AssertionError: expected all create ops to have been compiled, but got ${ir.OpKind[op.kind]}`);
+        }
+        createStatements.push(op.statement);
+    }
+    const updateStatements = [];
+    for (const op of view.update) {
+        if (op.kind !== ir.OpKind.Statement) {
+            throw new Error(`AssertionError: expected all update ops to have been compiled, but got ${ir.OpKind[op.kind]}`);
+        }
+        updateStatements.push(op.statement);
+    }
+    const rf = o.variable('rf');
+    const createCond = o.ifStmt(new o.BinaryOperatorExpr(o.BinaryOperator.BitwiseAnd, rf, o.literal(1)), createStatements);
+    const updateCond = o.ifStmt(new o.BinaryOperatorExpr(o.BinaryOperator.BitwiseAnd, rf, o.literal(2)), updateStatements);
+    return o.fn([
+        new o.FnParam('rf'),
+        new o.FnParam('ctx'),
+    ], [createCond, updateCond], /* type */ undefined, /* sourceSpan */ undefined, view.fnName);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"emit.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler/src/template/pipeline/src/emit.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 '../../../../src/output/output_ast';\nimport {ConstantPool} from '../../../constant_pool';\nimport * as ir from '../ir';\n\nimport type {ComponentCompilation, ViewCompilation} from './compilation';\n\nimport {phaseConstCollection} from './phases/const_collection';\nimport {phaseEmptyElements} from './phases/empty_elements';\nimport {phaseGenerateAdvance} from './phases/generate_advance';\nimport {phaseReify} from './phases/reify';\nimport {phaseSlotAllocation} from './phases/slot_allocation';\nimport {phaseVarCounting} from './phases/var_counting';\nimport {phaseNaming} from './phases/naming';\nimport {phaseLocalRefs} from './phases/local_refs';\nimport {phaseGenerateVariables} from './phases/generate_variables';\nimport {phaseResolveNames} from './phases/resolve_names';\nimport {phaseResolveContexts} from './phases/resolve_contexts';\n\n/**\n * Run all transformation phases in the correct order against a `ComponentCompilation`. After this\n * processing, the compilation should be in a state where it can be emitted via `emitTemplateFn`.s\n */\nexport function transformTemplate(cpl: ComponentCompilation): void {\n  phaseGenerateVariables(cpl);\n  phaseResolveNames(cpl);\n  phaseResolveContexts(cpl);\n  phaseLocalRefs(cpl);\n  phaseEmptyElements(cpl);\n  phaseConstCollection(cpl);\n  phaseSlotAllocation(cpl);\n  phaseVarCounting(cpl);\n  phaseGenerateAdvance(cpl);\n  phaseNaming(cpl);\n  phaseReify(cpl);\n}\n\n/**\n * Compile all views in the given `ComponentCompilation` into the final template function, which may\n * reference constants defined in a `ConstantPool`.\n */\nexport function emitTemplateFn(tpl: ComponentCompilation, pool: ConstantPool): o.FunctionExpr {\n  const rootFn = emitView(tpl.root);\n  for (const view of tpl.views.values()) {\n    if (view === tpl.root) {\n      continue;\n    }\n\n    const viewFn = emitView(view);\n    pool.statements.push(viewFn.toDeclStmt(viewFn.name!));\n  }\n  return rootFn;\n}\n\n/**\n * Emit a template function for an individual `ViewCompilation` (which may be either the root view\n * or an embedded view).\n */\nfunction emitView(view: ViewCompilation): o.FunctionExpr {\n  if (view.fnName === null) {\n    throw new Error(`AssertionError: view ${view.xref} is unnamed`);\n  }\n\n  const createStatements: o.Statement[] = [];\n  for (const op of view.create) {\n    if (op.kind !== ir.OpKind.Statement) {\n      throw new Error(`AssertionError: expected all create ops to have been compiled, but got ${\n          ir.OpKind[op.kind]}`);\n    }\n    createStatements.push(op.statement);\n  }\n  const updateStatements: o.Statement[] = [];\n  for (const op of view.update) {\n    if (op.kind !== ir.OpKind.Statement) {\n      throw new Error(`AssertionError: expected all update ops to have been compiled, but got ${\n          ir.OpKind[op.kind]}`);\n    }\n    updateStatements.push(op.statement);\n  }\n\n  const rf = o.variable('rf');\n  const createCond = o.ifStmt(\n      new o.BinaryOperatorExpr(o.BinaryOperator.BitwiseAnd, rf, o.literal(1)), createStatements);\n  const updateCond = o.ifStmt(\n      new o.BinaryOperatorExpr(o.BinaryOperator.BitwiseAnd, rf, o.literal(2)), updateStatements);\n  return o.fn(\n      [\n        new o.FnParam('rf'),\n        new o.FnParam('ctx'),\n      ],\n      [createCond, updateCond], /* type */ undefined, /* sourceSpan */ undefined, view.fnName);\n}\n"]}