@angular/compiler 16.2.0-next.4 → 16.2.0-rc.0

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

@@ -0,0 +1,28 @@
+/**
+ * @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 phaseRemoveEmptyBindings(job) {
+    for (const unit of job.units) {
+        for (const op of unit.update) {
+            switch (op.kind) {
+                case ir.OpKind.Attribute:
+                case ir.OpKind.Binding:
+                case ir.OpKind.ClassProp:
+                case ir.OpKind.ClassMap:
+                case ir.OpKind.Property:
+                case ir.OpKind.StyleProp:
+                case ir.OpKind.StyleMap:
+                    if (op.expression instanceof ir.EmptyExpr) {
+                        ir.OpList.remove(op);
+                    }
+                    break;
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -13,9 +13,9 @@ import * as ir from '../../ir';
  * that store those contexts (for contexts accessed via the `nextContext()` instruction).
  */
 export function phaseResolveContexts(cpl) {
-    for (const view of cpl.views.values()) {
-        processLexicalScope(view, view.create);
-        processLexicalScope(view, view.update);
+    for (const unit of cpl.units) {
+        processLexicalScope(unit, unit.create);
+        processLexicalScope(unit, unit.update);
     }
 }
 function processLexicalScope(view, ops) {
@@ -52,4 +52,4 @@ function processLexicalScope(view, ops) {
         }, ir.VisitorContextFlag.None);
     }
 }
-//# 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/resolve_dollar_event.mjs

@@ -0,0 +1,33 @@
+/**
+ * @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';
+/**
+ * Any variable inside a listener with the name `$event` will be transformed into a output lexical
+ * read immediately, and does not participate in any of the normal logic for handling variables.
+ */
+export function phaseResolveDollarEvent(cpl) {
+    for (const [_, view] of cpl.views) {
+        resolveDollarEvent(view, view.create);
+        resolveDollarEvent(view, view.update);
+    }
+}
+function resolveDollarEvent(view, ops) {
+    for (const op of ops) {
+        if (op.kind === ir.OpKind.Listener) {
+            ir.transformExpressionsInOp(op, (expr) => {
+                if (expr instanceof ir.LexicalReadExpr && expr.name === '$event') {
+                    op.consumesDollarEvent = true;
+                    return new o.ReadVarExpr(expr.name);
+                }
+                return expr;
+            }, ir.VisitorContextFlag.InChildOperation);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -15,12 +15,12 @@ import * as ir from '../../ir';
  * views.
  */
 export function phaseResolveNames(cpl) {
-    for (const [_, view] of cpl.views) {
-        processLexicalScope(view, view.create, null);
-        processLexicalScope(view, view.update, null);
+    for (const unit of cpl.units) {
+        processLexicalScope(unit, unit.create, null);
+        processLexicalScope(unit, unit.update, null);
     }
 }
-function processLexicalScope(view, ops, savedView) {
+function processLexicalScope(unit, ops, savedView) {
     // Maps names defined in the lexical scope of this template to the `ir.XrefId`s of the variable
     // declarations which represent those values.
     //
@@ -54,7 +54,7 @@ function processLexicalScope(view, ops, savedView) {
             case ir.OpKind.Listener:
                 // Listener functions have separate variable declarations, so process them as a separate
                 // lexical scope.
-                processLexicalScope(view, op.handlerOps, savedView);
+                processLexicalScope(unit, op.handlerOps, savedView);
                 break;
         }
     }
@@ -62,7 +62,11 @@ function processLexicalScope(view, ops, savedView) {
     // scope. Also, look for `ir.RestoreViewExpr`s and match them with the snapshotted view context
     // variable.
     for (const op of ops) {
-        ir.transformExpressionsInOp(op, expr => {
+        if (op.kind == ir.OpKind.Listener) {
+            // Listeners were already processed above with their own scopes.
+            continue;
+        }
+        ir.transformExpressionsInOp(op, (expr, flags) => {
             if (expr instanceof ir.LexicalReadExpr) {
                 // `expr` is a read of a name within the lexical scope of this view.
                 // Either that name is defined within the current view, or it represents a property from the
@@ -73,7 +77,7 @@ function processLexicalScope(view, ops, savedView) {
                 }
                 else {
                     // Reading from the component context.
-                    return new o.ReadPropExpr(new ir.ContextExpr(view.tpl.root.xref), expr.name);
+                    return new o.ReadPropExpr(new ir.ContextExpr(unit.job.root.xref), expr.name);
                 }
             }
             else if (expr instanceof ir.RestoreViewExpr && typeof expr.view === 'number') {
@@ -81,7 +85,7 @@ function processLexicalScope(view, ops, savedView) {
                 // parent creation list. We expect to find that we captured the `savedView` previously, and
                 // that it matches the expected view to be restored.
                 if (savedView === null || savedView.view !== expr.view) {
-                    throw new Error(`AssertionError: no saved view ${expr.view} from view ${view.xref}`);
+                    throw new Error(`AssertionError: no saved view ${expr.view} from view ${unit.xref}`);
                 }
                 expr.view = new ir.ReadVariableExpr(savedView.variable);
                 return expr;
@@ -99,4 +103,4 @@ function processLexicalScope(view, ops, savedView) {
         });
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resolve_names.js","sourceRoot":"","sources":["../../../../../../../../../../packages/compiler/src/template/pipeline/src/phases/resolve_names.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,CAAC,MAAM,+BAA+B,CAAC;AACnD,OAAO,KAAK,EAAE,MAAM,UAAU,CAAC;AAG/B;;;;;;GAMG;AACH,MAAM,UAAU,iBAAiB,CAAC,GAAyB;IACzD,KAAK,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,GAAG,CAAC,KAAK,EAAE;QACjC,mBAAmB,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QAC7C,mBAAmB,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;KAC9C;AACH,CAAC;AAED,SAAS,mBAAmB,CACxB,IAAqB,EAAE,GAAkD,EACzE,SAAyB;IAC3B,+FAA+F;IAC/F,6CAA6C;IAC7C,EAAE;IACF,yFAAyF;IACzF,mFAAmF;IACnF,MAAM,KAAK,GAAG,IAAI,GAAG,EAAqB,CAAC;IAE3C,+CAA+C;IAC/C,kCAAkC;IAClC,yCAAyC;IACzC,KAAK,MAAM,EAAE,IAAI,GAAG,EAAE;QACpB,QAAQ,EAAE,CAAC,IAAI,EAAE;YACf,KAAK,EAAE,CAAC,MAAM,CAAC,QAAQ;gBACrB,QAAQ,EAAE,CAAC,QAAQ,CAAC,IAAI,EAAE;oBACxB,KAAK,EAAE,CAAC,oBAAoB,CAAC,UAAU;wBACrC,sFAAsF;wBACtF,IAAI,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE;4BACrC,SAAS;yBACV;wBACD,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,QAAQ,CAAC,UAAU,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC;wBAC3C,MAAM;oBACR,KAAK,EAAE,CAAC,oBAAoB,CAAC,SAAS;wBACpC,sFAAsF;wBACtF,kDAAkD;wBAClD,SAAS,GAAG;4BACV,IAAI,EAAE,EAAE,CAAC,QAAQ,CAAC,IAAI;4BACtB,QAAQ,EAAE,EAAE,CAAC,IAAI;yBAClB,CAAC;wBACF,MAAM;iBACT;gBACD,MAAM;YACR,KAAK,EAAE,CAAC,MAAM,CAAC,QAAQ;gBACrB,wFAAwF;gBACxF,iBAAiB;gBACjB,mBAAmB,CAAC,IAAI,EAAE,EAAE,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;gBACpD,MAAM;SACT;KACF;IAED,gGAAgG;IAChG,+FAA+F;IAC/F,YAAY;IACZ,KAAK,MAAM,EAAE,IAAI,GAAG,EAAE;QACpB,EAAE,CAAC,wBAAwB,CAAC,EAAE,EAAE,IAAI,CAAC,EAAE;YACrC,IAAI,IAAI,YAAY,EAAE,CAAC,eAAe,EAAE;gBACtC,oEAAoE;gBACpE,4FAA4F;gBAC5F,0BAA0B;gBAC1B,IAAI,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;oBACxB,oDAAoD;oBACpD,OAAO,IAAI,EAAE,CAAC,gBAAgB,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAE,CAAC,CAAC;iBACvD;qBAAM;oBACL,sCAAsC;oBACtC,OAAO,IAAI,CAAC,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;iBAC9E;aACF;iBAAM,IAAI,IAAI,YAAY,EAAE,CAAC,eAAe,IAAI,OAAO,IAAI,CAAC,IAAI,KAAK,QAAQ,EAAE;gBAC9E,wFAAwF;gBACxF,2FAA2F;gBAC3F,oDAAoD;gBACpD,IAAI,SAAS,KAAK,IAAI,IAAI,SAAS,CAAC,IAAI,KAAK,IAAI,CAAC,IAAI,EAAE;oBACtD,MAAM,IAAI,KAAK,CAAC,iCAAiC,IAAI,CAAC,IAAI,cAAc,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;iBACtF;gBACD,IAAI,CAAC,IAAI,GAAG,IAAI,EAAE,CAAC,gBAAgB,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;gBACxD,OAAO,IAAI,CAAC;aACb;iBAAM;gBACL,OAAO,IAAI,CAAC;aACb;QACH,CAAC,EAAE,EAAE,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC;KAChC;IAED,KAAK,MAAM,EAAE,IAAI,GAAG,EAAE;QACpB,EAAE,CAAC,oBAAoB,CAAC,EAAE,EAAE,IAAI,CAAC,EAAE;YACjC,IAAI,IAAI,YAAY,EAAE,CAAC,eAAe,EAAE;gBACtC,MAAM,IAAI,KAAK,CACX,qEAAqE,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;aACvF;QACH,CAAC,CAAC,CAAC;KACJ;AACH,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 * as o from '../../../../output/output_ast';\nimport * as ir from '../../ir';\nimport {ComponentCompilation, ViewCompilation} from '../compilation';\n\n/**\n * Resolves lexical references in views (`ir.LexicalReadExpr`) to either a target variable or to\n * property reads on the top-level component context.\n *\n * Also matches `ir.RestoreViewExpr` expressions with the variables of their corresponding saved\n * views.\n */\nexport function phaseResolveNames(cpl: ComponentCompilation): void {\n  for (const [_, view] of cpl.views) {\n    processLexicalScope(view, view.create, null);\n    processLexicalScope(view, view.update, null);\n  }\n}\n\nfunction processLexicalScope(\n    view: ViewCompilation, ops: ir.OpList<ir.CreateOp>|ir.OpList<ir.UpdateOp>,\n    savedView: SavedView|null): void {\n  // Maps names defined in the lexical scope of this template to the `ir.XrefId`s of the variable\n  // declarations which represent those values.\n  //\n  // Since variables are generated in each view for the entire lexical scope (including any\n  // identifiers from parent templates) only local variables need be considered here.\n  const scope = new Map<string, ir.XrefId>();\n\n  // First, step through the operations list and:\n  // 1) build up the `scope` mapping\n  // 2) recurse into any listener functions\n  for (const op of ops) {\n    switch (op.kind) {\n      case ir.OpKind.Variable:\n        switch (op.variable.kind) {\n          case ir.SemanticVariableKind.Identifier:\n            // This variable represents some kind of identifier which can be used in the template.\n            if (scope.has(op.variable.identifier)) {\n              continue;\n            }\n            scope.set(op.variable.identifier, op.xref);\n            break;\n          case ir.SemanticVariableKind.SavedView:\n            // This variable represents a snapshot of the current view context, and can be used to\n            // restore that context within listener functions.\n            savedView = {\n              view: op.variable.view,\n              variable: op.xref,\n            };\n            break;\n        }\n        break;\n      case ir.OpKind.Listener:\n        // Listener functions have separate variable declarations, so process them as a separate\n        // lexical scope.\n        processLexicalScope(view, op.handlerOps, savedView);\n        break;\n    }\n  }\n\n  // Next, use the `scope` mapping to match `ir.LexicalReadExpr` with defined names in the lexical\n  // scope. Also, look for `ir.RestoreViewExpr`s and match them with the snapshotted view context\n  // variable.\n  for (const op of ops) {\n    ir.transformExpressionsInOp(op, expr => {\n      if (expr instanceof ir.LexicalReadExpr) {\n        // `expr` is a read of a name within the lexical scope of this view.\n        // Either that name is defined within the current view, or it represents a property from the\n        // main component context.\n        if (scope.has(expr.name)) {\n          // This was a defined variable in the current scope.\n          return new ir.ReadVariableExpr(scope.get(expr.name)!);\n        } else {\n          // Reading from the component context.\n          return new o.ReadPropExpr(new ir.ContextExpr(view.tpl.root.xref), expr.name);\n        }\n      } else if (expr instanceof ir.RestoreViewExpr && typeof expr.view === 'number') {\n        // `ir.RestoreViewExpr` happens in listener functions and restores a saved view from the\n        // parent creation list. We expect to find that we captured the `savedView` previously, and\n        // that it matches the expected view to be restored.\n        if (savedView === null || savedView.view !== expr.view) {\n          throw new Error(`AssertionError: no saved view ${expr.view} from view ${view.xref}`);\n        }\n        expr.view = new ir.ReadVariableExpr(savedView.variable);\n        return expr;\n      } else {\n        return expr;\n      }\n    }, ir.VisitorContextFlag.None);\n  }\n\n  for (const op of ops) {\n    ir.visitExpressionsInOp(op, expr => {\n      if (expr instanceof ir.LexicalReadExpr) {\n        throw new Error(\n            `AssertionError: no lexical reads should remain, but found read of ${expr.name}`);\n      }\n    });\n  }\n}\n\n/**\n * Information about a `SavedView` variable.\n */\ninterface SavedView {\n  /**\n   * The view `ir.XrefId` which was saved into this variable.\n   */\n  view: ir.XrefId;\n\n  /**\n   * The `ir.XrefId` of the variable into which the view was saved.\n   */\n  variable: ir.XrefId;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resolve_names.js","sourceRoot":"","sources":["../../../../../../../../../../packages/compiler/src/template/pipeline/src/phases/resolve_names.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 * as ir from '../../ir';\nimport {CompilationJob, CompilationUnit, ViewCompilationUnit} from '../compilation';\n\n/**\n * Resolves lexical references in views (`ir.LexicalReadExpr`) to either a target variable or to\n * property reads on the top-level component context.\n *\n * Also matches `ir.RestoreViewExpr` expressions with the variables of their corresponding saved\n * views.\n */\nexport function phaseResolveNames(cpl: CompilationJob): void {\n  for (const unit of cpl.units) {\n    processLexicalScope(unit, unit.create, null);\n    processLexicalScope(unit, unit.update, null);\n  }\n}\n\nfunction processLexicalScope(\n    unit: CompilationUnit, ops: ir.OpList<ir.CreateOp>|ir.OpList<ir.UpdateOp>,\n    savedView: SavedView|null): void {\n  // Maps names defined in the lexical scope of this template to the `ir.XrefId`s of the variable\n  // declarations which represent those values.\n  //\n  // Since variables are generated in each view for the entire lexical scope (including any\n  // identifiers from parent templates) only local variables need be considered here.\n  const scope = new Map<string, ir.XrefId>();\n\n  // First, step through the operations list and:\n  // 1) build up the `scope` mapping\n  // 2) recurse into any listener functions\n  for (const op of ops) {\n    switch (op.kind) {\n      case ir.OpKind.Variable:\n        switch (op.variable.kind) {\n          case ir.SemanticVariableKind.Identifier:\n            // This variable represents some kind of identifier which can be used in the template.\n            if (scope.has(op.variable.identifier)) {\n              continue;\n            }\n            scope.set(op.variable.identifier, op.xref);\n            break;\n          case ir.SemanticVariableKind.SavedView:\n            // This variable represents a snapshot of the current view context, and can be used to\n            // restore that context within listener functions.\n            savedView = {\n              view: op.variable.view,\n              variable: op.xref,\n            };\n            break;\n        }\n        break;\n      case ir.OpKind.Listener:\n        // Listener functions have separate variable declarations, so process them as a separate\n        // lexical scope.\n        processLexicalScope(unit, op.handlerOps, savedView);\n        break;\n    }\n  }\n\n  // Next, use the `scope` mapping to match `ir.LexicalReadExpr` with defined names in the lexical\n  // scope. Also, look for `ir.RestoreViewExpr`s and match them with the snapshotted view context\n  // variable.\n  for (const op of ops) {\n    if (op.kind == ir.OpKind.Listener) {\n      // Listeners were already processed above with their own scopes.\n      continue;\n    }\n    ir.transformExpressionsInOp(op, (expr, flags) => {\n      if (expr instanceof ir.LexicalReadExpr) {\n        // `expr` is a read of a name within the lexical scope of this view.\n        // Either that name is defined within the current view, or it represents a property from the\n        // main component context.\n        if (scope.has(expr.name)) {\n          // This was a defined variable in the current scope.\n          return new ir.ReadVariableExpr(scope.get(expr.name)!);\n        } else {\n          // Reading from the component context.\n          return new o.ReadPropExpr(new ir.ContextExpr(unit.job.root.xref), expr.name);\n        }\n      } else if (expr instanceof ir.RestoreViewExpr && typeof expr.view === 'number') {\n        // `ir.RestoreViewExpr` happens in listener functions and restores a saved view from the\n        // parent creation list. We expect to find that we captured the `savedView` previously, and\n        // that it matches the expected view to be restored.\n        if (savedView === null || savedView.view !== expr.view) {\n          throw new Error(`AssertionError: no saved view ${expr.view} from view ${unit.xref}`);\n        }\n        expr.view = new ir.ReadVariableExpr(savedView.variable);\n        return expr;\n      } else {\n        return expr;\n      }\n    }, ir.VisitorContextFlag.None);\n  }\n\n  for (const op of ops) {\n    ir.visitExpressionsInOp(op, expr => {\n      if (expr instanceof ir.LexicalReadExpr) {\n        throw new Error(\n            `AssertionError: no lexical reads should remain, but found read of ${expr.name}`);\n      }\n    });\n  }\n}\n\n/**\n * Information about a `SavedView` variable.\n */\ninterface SavedView {\n  /**\n   * The view `ir.XrefId` which was saved into this variable.\n   */\n  view: ir.XrefId;\n\n  /**\n   * The `ir.XrefId` of the variable into which the view was saved.\n   */\n  variable: ir.XrefId;\n}\n"]}

package/esm2022/src/template/pipeline/src/phases/resolve_sanitizers.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 { SecurityContext } from '../../../../core';
+import { isIframeSecuritySensitiveAttr } from '../../../../schema/dom_security_schema';
+import * as ir from '../../ir';
+import { getElementsByXrefId } from '../util/elements';
+/**
+ * Mapping of security contexts to sanitizer function for that context.
+ */
+const sanitizers = new Map([
+    [SecurityContext.HTML, ir.SanitizerFn.Html], [SecurityContext.SCRIPT, ir.SanitizerFn.Script],
+    [SecurityContext.STYLE, ir.SanitizerFn.Style], [SecurityContext.URL, ir.SanitizerFn.Url],
+    [SecurityContext.RESOURCE_URL, ir.SanitizerFn.ResourceUrl]
+]);
+/**
+ * Resolves sanitization functions for ops that need them.
+ */
+export function phaseResolveSanitizers(cpl) {
+    for (const [_, view] of cpl.views) {
+        const elements = getElementsByXrefId(view);
+        let sanitizerFn;
+        for (const op of view.update) {
+            switch (op.kind) {
+                case ir.OpKind.Property:
+                case ir.OpKind.Attribute:
+                    sanitizerFn = sanitizers.get(op.securityContext) || null;
+                    op.sanitizer = sanitizerFn ? new ir.SanitizerExpr(sanitizerFn) : null;
+                    // If there was no sanitization function found based on the security context of an
+                    // attribute/property, check whether this attribute/property is one of the
+                    // security-sensitive <iframe> attributes (and that the current element is actually an
+                    // <iframe>).
+                    if (op.sanitizer === null) {
+                        const ownerOp = elements.get(op.target);
+                        if (ownerOp === undefined) {
+                            throw Error('Property should have an element-like owner');
+                        }
+                        if (isIframeElement(ownerOp) && isIframeSecuritySensitiveAttr(op.name)) {
+                            op.sanitizer = new ir.SanitizerExpr(ir.SanitizerFn.IframeAttribute);
+                        }
+                    }
+                    break;
+            }
+        }
+    }
+}
+/**
+ * Checks whether the given op represents an iframe element.
+ */
+function isIframeElement(op) {
+    return (op.kind === ir.OpKind.Element || op.kind === ir.OpKind.ElementStart) &&
+        op.tag.toLowerCase() === 'iframe';
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -10,7 +10,7 @@ import * as ir from '../../ir';
 export function phaseSaveRestoreView(cpl) {
     for (const view of cpl.views.values()) {
         view.create.prepend([
-            ir.createVariableOp(view.tpl.allocateXrefId(), {
+            ir.createVariableOp(view.job.allocateXrefId(), {
                 kind: ir.SemanticVariableKind.SavedView,
                 name: null,
                 view: view.xref,
@@ -40,7 +40,7 @@ export function phaseSaveRestoreView(cpl) {
 }
 function addSaveRestoreViewOperationToListener(view, op) {
     op.handlerOps.prepend([
-        ir.createVariableOp(view.tpl.allocateXrefId(), {
+        ir.createVariableOp(view.job.allocateXrefId(), {
             kind: ir.SemanticVariableKind.Context,
             name: null,
             view: view.xref,
@@ -56,4 +56,4 @@ function addSaveRestoreViewOperationToListener(view, op) {
         }
     }
 }
-//# 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/slot_allocation.mjs

@@ -82,4 +82,4 @@ export function phaseSlotAllocation(cpl) {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"slot_allocation.js","sourceRoot":"","sources":["../../../../../../../../../../packages/compiler/src/template/pipeline/src/phases/slot_allocation.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 ir from '../../ir';\nimport type {ComponentCompilation} from '../compilation';\n\n/**\n * Assign data slots for all operations which implement `ConsumesSlotOpTrait`, and propagate the\n * assigned data slots of those operations to any expressions which reference them via\n * `UsesSlotIndexTrait`.\n *\n * This phase is also responsible for counting the number of slots used for each view (its `decls`)\n * and propagating that number into the `Template` operations which declare embedded views.\n */\nexport function phaseSlotAllocation(cpl: ComponentCompilation): void {\n  // Map of all declarations in all views within the component which require an assigned slot index.\n  // This map needs to be global (across all views within the component) since it's possible to\n  // reference a slot from one view from an expression within another (e.g. local references work\n  // this way).\n  const slotMap = new Map<ir.XrefId, number>();\n\n  // Process all views in the component and assign slot indexes.\n  for (const [_, view] of cpl.views) {\n    // Slot indices start at 0 for each view (and are not unique between views).\n    let slotCount = 0;\n\n    for (const op of view.create) {\n      // Only consider declarations which consume data slots.\n      if (!ir.hasConsumesSlotTrait(op)) {\n        continue;\n      }\n\n      // Assign slots to this declaration starting at the current `slotCount`.\n      op.slot = slotCount;\n\n      // And track its assigned slot in the `slotMap`.\n      slotMap.set(op.xref, op.slot);\n\n      // Each declaration may use more than 1 slot, so increment `slotCount` to reserve the number\n      // of slots required.\n      slotCount += op.numSlotsUsed;\n    }\n\n    // Record the total number of slots used on the view itself. This will later be propagated into\n    // `ir.TemplateOp`s which declare those views (except for the root view).\n    view.decls = slotCount;\n  }\n\n  // After slot assignment, `slotMap` now contains slot assignments for every declaration in the\n  // whole template, across all views. Next, look for expressions which implement\n  // `UsesSlotIndexExprTrait` and propagate the assigned slot indexes into them.\n  // Additionally, this second scan allows us to find `ir.TemplateOp`s which declare views and\n  // propagate the number of slots used for each view into the operation which declares it.\n  for (const [_, view] of cpl.views) {\n    for (const op of view.ops()) {\n      if (op.kind === ir.OpKind.Template) {\n        // Record the number of slots used by the view this `ir.TemplateOp` declares in the\n        // operation itself, so it can be emitted later.\n        const childView = cpl.views.get(op.xref)!;\n        op.decls = childView.decls;\n      }\n\n      if (ir.hasUsesSlotIndexTrait(op) && op.slot === null) {\n        if (!slotMap.has(op.target)) {\n          // We do expect to find a slot allocated for everything which might be referenced.\n          throw new Error(\n              `AssertionError: no slot allocated for ${ir.OpKind[op.kind]} target ${op.target}`);\n        }\n\n        op.slot = slotMap.get(op.target)!;\n      }\n\n      // Process all `ir.Expression`s within this view, and look for `usesSlotIndexExprTrait`.\n      ir.visitExpressionsInOp(op, expr => {\n        if (!ir.isIrExpression(expr)) {\n          return;\n        }\n\n        if (!ir.hasUsesSlotIndexTrait(expr) || expr.slot !== null) {\n          return;\n        }\n\n        // The `UsesSlotIndexExprTrait` indicates that this expression references something declared\n        // in this component template by its slot index. Use the `target` `ir.XrefId` to find the\n        // allocated slot for that declaration in `slotMap`.\n\n        if (!slotMap.has(expr.target)) {\n          // We do expect to find a slot allocated for everything which might be referenced.\n          throw new Error(`AssertionError: no slot allocated for ${expr.constructor.name} target ${\n              expr.target}`);\n        }\n\n        // Record the allocated slot on the expression.\n        expr.slot = slotMap.get(expr.target)!;\n      });\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"slot_allocation.js","sourceRoot":"","sources":["../../../../../../../../../../packages/compiler/src/template/pipeline/src/phases/slot_allocation.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 ir from '../../ir';\nimport type {ComponentCompilationJob} from '../compilation';\n\n/**\n * Assign data slots for all operations which implement `ConsumesSlotOpTrait`, and propagate the\n * assigned data slots of those operations to any expressions which reference them via\n * `UsesSlotIndexTrait`.\n *\n * This phase is also responsible for counting the number of slots used for each view (its `decls`)\n * and propagating that number into the `Template` operations which declare embedded views.\n */\nexport function phaseSlotAllocation(cpl: ComponentCompilationJob): void {\n  // Map of all declarations in all views within the component which require an assigned slot index.\n  // This map needs to be global (across all views within the component) since it's possible to\n  // reference a slot from one view from an expression within another (e.g. local references work\n  // this way).\n  const slotMap = new Map<ir.XrefId, number>();\n\n  // Process all views in the component and assign slot indexes.\n  for (const [_, view] of cpl.views) {\n    // Slot indices start at 0 for each view (and are not unique between views).\n    let slotCount = 0;\n\n    for (const op of view.create) {\n      // Only consider declarations which consume data slots.\n      if (!ir.hasConsumesSlotTrait(op)) {\n        continue;\n      }\n\n      // Assign slots to this declaration starting at the current `slotCount`.\n      op.slot = slotCount;\n\n      // And track its assigned slot in the `slotMap`.\n      slotMap.set(op.xref, op.slot);\n\n      // Each declaration may use more than 1 slot, so increment `slotCount` to reserve the number\n      // of slots required.\n      slotCount += op.numSlotsUsed;\n    }\n\n    // Record the total number of slots used on the view itself. This will later be propagated into\n    // `ir.TemplateOp`s which declare those views (except for the root view).\n    view.decls = slotCount;\n  }\n\n  // After slot assignment, `slotMap` now contains slot assignments for every declaration in the\n  // whole template, across all views. Next, look for expressions which implement\n  // `UsesSlotIndexExprTrait` and propagate the assigned slot indexes into them.\n  // Additionally, this second scan allows us to find `ir.TemplateOp`s which declare views and\n  // propagate the number of slots used for each view into the operation which declares it.\n  for (const [_, view] of cpl.views) {\n    for (const op of view.ops()) {\n      if (op.kind === ir.OpKind.Template) {\n        // Record the number of slots used by the view this `ir.TemplateOp` declares in the\n        // operation itself, so it can be emitted later.\n        const childView = cpl.views.get(op.xref)!;\n        op.decls = childView.decls;\n      }\n\n      if (ir.hasUsesSlotIndexTrait(op) && op.slot === null) {\n        if (!slotMap.has(op.target)) {\n          // We do expect to find a slot allocated for everything which might be referenced.\n          throw new Error(\n              `AssertionError: no slot allocated for ${ir.OpKind[op.kind]} target ${op.target}`);\n        }\n\n        op.slot = slotMap.get(op.target)!;\n      }\n\n      // Process all `ir.Expression`s within this view, and look for `usesSlotIndexExprTrait`.\n      ir.visitExpressionsInOp(op, expr => {\n        if (!ir.isIrExpression(expr)) {\n          return;\n        }\n\n        if (!ir.hasUsesSlotIndexTrait(expr) || expr.slot !== null) {\n          return;\n        }\n\n        // The `UsesSlotIndexExprTrait` indicates that this expression references something declared\n        // in this component template by its slot index. Use the `target` `ir.XrefId` to find the\n        // allocated slot for that declaration in `slotMap`.\n\n        if (!slotMap.has(expr.target)) {\n          // We do expect to find a slot allocated for everything which might be referenced.\n          throw new Error(`AssertionError: no slot allocated for ${expr.constructor.name} target ${\n              expr.target}`);\n        }\n\n        // Record the allocated slot on the expression.\n        expr.slot = slotMap.get(expr.target)!;\n      });\n    }\n  }\n}\n"]}

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

@@ -0,0 +1,42 @@
+/**
+ * @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';
+/**
+ * Transforms special-case bindings with 'style' or 'class' in their names. Must run before the
+ * main binding specialization pass.
+ */
+export function phaseStyleBindingSpecialization(cpl) {
+    for (const unit of cpl.units) {
+        for (const op of unit.update) {
+            if (op.kind !== ir.OpKind.Binding) {
+                continue;
+            }
+            switch (op.bindingKind) {
+                case ir.BindingKind.ClassName:
+                    if (op.expression instanceof ir.Interpolation) {
+                        throw new Error(`Unexpected interpolation in ClassName binding`);
+                    }
+                    ir.OpList.replace(op, ir.createClassPropOp(op.target, op.name, op.expression, op.sourceSpan));
+                    break;
+                case ir.BindingKind.StyleProperty:
+                    ir.OpList.replace(op, ir.createStylePropOp(op.target, op.name, op.expression, op.unit, op.sourceSpan));
+                    break;
+                case ir.BindingKind.Property:
+                case ir.BindingKind.Template:
+                    if (op.name === 'style') {
+                        ir.OpList.replace(op, ir.createStyleMapOp(op.target, op.expression, op.sourceSpan));
+                    }
+                    else if (op.name === 'class') {
+                        ir.OpList.replace(op, ir.createClassMapOp(op.target, op.expression, op.sourceSpan));
+                    }
+                    break;
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -17,37 +17,57 @@ import * as ir from '../../ir';
  * Implement an algorithm for reuse.
  */
 export function phaseTemporaryVariables(cpl) {
-    for (const view of cpl.views.values()) {
+    for (const unit of cpl.units) {
         let opCount = 0;
         let generatedStatements = [];
-        for (const op of view.ops()) {
-            let count = 0;
-            let xrefs = new Set();
-            let defs = new Map();
+        for (const op of unit.ops()) {
+            // Identify the final time each temp var is read.
+            const finalReads = new Map();
             ir.visitExpressionsInOp(op, expr => {
-                if (expr instanceof ir.ReadTemporaryExpr || expr instanceof ir.AssignTemporaryExpr) {
-                    xrefs.add(expr.xref);
+                if (expr instanceof ir.ReadTemporaryExpr) {
+                    finalReads.set(expr.xref, expr);
                 }
             });
-            for (const xref of xrefs) {
-                // TODO: Exactly replicate the naming scheme used by `TemplateDefinitionBuilder`. It seems
-                // to rely on an expression index instead of an op index.
-                defs.set(xref, `tmp_${opCount}_${count++}`);
-            }
+            // Name the temp vars, accounting for the fact that a name can be reused after it has been
+            // read for the final time.
+            let count = 0;
+            const assigned = new Set();
+            const released = new Set();
+            const defs = new Map();
             ir.visitExpressionsInOp(op, expr => {
-                if (expr instanceof ir.ReadTemporaryExpr || expr instanceof ir.AssignTemporaryExpr) {
-                    const name = defs.get(expr.xref);
-                    if (name === undefined) {
-                        throw new Error('Found xref with unassigned name');
+                if (expr instanceof ir.AssignTemporaryExpr) {
+                    if (!assigned.has(expr.xref)) {
+                        assigned.add(expr.xref);
+                        // TODO: Exactly replicate the naming scheme used by `TemplateDefinitionBuilder`.
+                        // It seems to rely on an expression index instead of an op index.
+                        defs.set(expr.xref, `tmp_${opCount}_${count++}`);
+                    }
+                    assignName(defs, expr);
+                }
+                else if (expr instanceof ir.ReadTemporaryExpr) {
+                    if (finalReads.get(expr.xref) === expr) {
+                        released.add(expr.xref);
+                        count--;
                     }
-                    expr.name = name;
+                    assignName(defs, expr);
                 }
             });
-            generatedStatements.push(...Array.from(defs.values())
+            // Add declarations for the temp vars.
+            generatedStatements.push(...Array.from(new Set(defs.values()))
                 .map(name => ir.createStatementOp(new o.DeclareVarStmt(name))));
             opCount++;
         }
-        view.update.prepend(generatedStatements);
+        unit.update.prepend(generatedStatements);
+    }
+}
+/**
+ * Assigns a name to the temporary variable in the given temporary variable expression.
+ */
+function assignName(names, expr) {
+    const name = names.get(expr.xref);
+    if (name === undefined) {
+        throw new Error(`Found xref with unassigned name: ${expr.xref}`);
     }
+    expr.name = name;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVtcG9yYXJ5X3ZhcmlhYmxlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvbXBpbGVyL3NyYy90ZW1wbGF0ZS9waXBlbGluZS9zcmMvcGhhc2VzL3RlbXBvcmFyeV92YXJpYWJsZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsT0FBTyxLQUFLLENBQUMsTUFBTSwrQkFBK0IsQ0FBQztBQUNuRCxPQUFPLEtBQUssRUFBRSxNQUFNLFVBQVUsQ0FBQztBQUcvQjs7Ozs7Ozs7R0FRRztBQUNILE1BQU0sVUFBVSx1QkFBdUIsQ0FBQyxHQUFtQjtJQUN6RCxLQUFLLE1BQU0sSUFBSSxJQUFJLEdBQUcsQ0FBQyxLQUFLLEVBQUU7UUFDNUIsSUFBSSxPQUFPLEdBQUcsQ0FBQyxDQUFDO1FBQ2hCLElBQUksbUJBQW1CLEdBQXVDLEVBQUUsQ0FBQztRQUNqRSxLQUFLLE1BQU0sRUFBRSxJQUFJLElBQUksQ0FBQyxHQUFHLEVBQUUsRUFBRTtZQUMzQixpREFBaUQ7WUFDakQsTUFBTSxVQUFVLEdBQUcsSUFBSSxHQUFHLEVBQW1DLENBQUM7WUFDOUQsRUFBRSxDQUFDLG9CQUFvQixDQUFDLEVBQUUsRUFBRSxJQUFJLENBQUMsRUFBRTtnQkFDakMsSUFBSSxJQUFJLFlBQVksRUFBRSxDQUFDLGlCQUFpQixFQUFFO29CQUN4QyxVQUFVLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxJQUFJLEVBQUUsSUFBSSxDQUFDLENBQUM7aUJBQ2pDO1lBQ0gsQ0FBQyxDQUFDLENBQUM7WUFFSCwwRkFBMEY7WUFDMUYsMkJBQTJCO1lBQzNCLElBQUksS0FBSyxHQUFHLENBQUMsQ0FBQztZQUNkLE1BQU0sUUFBUSxHQUFHLElBQUksR0FBRyxFQUFhLENBQUM7WUFDdEMsTUFBTSxRQUFRLEdBQUcsSUFBSSxHQUFHLEVBQWEsQ0FBQztZQUN0QyxNQUFNLElBQUksR0FBRyxJQUFJLEdBQUcsRUFBcUIsQ0FBQztZQUMxQyxFQUFFLENBQUMsb0JBQW9CLENBQUMsRUFBRSxFQUFFLElBQUksQ0FBQyxFQUFFO2dCQUNqQyxJQUFJLElBQUksWUFBWSxFQUFFLENBQUMsbUJBQW1CLEVBQUU7b0JBQzFDLElBQUksQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsRUFBRTt3QkFDNUIsUUFBUSxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7d0JBQ3hCLGlGQUFpRjt3QkFDakYsa0VBQWtFO3dCQUNsRSxJQUFJLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxJQUFJLEVBQUUsT0FBTyxPQUFPLElBQUksS0FBSyxFQUFFLEVBQUUsQ0FBQyxDQUFDO3FCQUNsRDtvQkFDRCxVQUFVLENBQUMsSUFBSSxFQUFFLElBQUksQ0FBQyxDQUFDO2lCQUN4QjtxQkFBTSxJQUFJLElBQUksWUFBWSxFQUFFLENBQUMsaUJBQWlCLEVBQUU7b0JBQy9DLElBQUksVUFBVSxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLEtBQUssSUFBSSxFQUFFO3dCQUN0QyxRQUFRLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQzt3QkFDeEIsS0FBSyxFQUFFLENBQUM7cUJBQ1Q7b0JBQ0QsVUFBVSxDQUFDLElBQUksRUFBRSxJQUFJLENBQUMsQ0FBQztpQkFDeEI7WUFDSCxDQUFDLENBQUMsQ0FBQztZQUVILHNDQUFzQztZQUN0QyxtQkFBbUIsQ0FBQyxJQUFJLENBQ3BCLEdBQUcsS0FBSyxDQUFDLElBQUksQ0FBQyxJQUFJLEdBQUcsQ0FBQyxJQUFJLENBQUMsTUFBTSxFQUFFLENBQUMsQ0FBQztpQkFDaEMsR0FBRyxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsRUFBRSxDQUFDLGlCQUFpQixDQUFjLElBQUksQ0FBQyxDQUFDLGNBQWMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztZQUNyRixPQUFPLEVBQUUsQ0FBQztTQUNYO1FBQ0QsSUFBSSxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQUMsbUJBQW1CLENBQUMsQ0FBQztLQUMxQztBQUNILENBQUM7QUFFRDs7R0FFRztBQUNILFNBQVMsVUFBVSxDQUNmLEtBQTZCLEVBQUUsSUFBaUQ7SUFDbEYsTUFBTSxJQUFJLEdBQUcsS0FBSyxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDbEMsSUFBSSxJQUFJLEtBQUssU0FBUyxFQUFFO1FBQ3RCLE1BQU0sSUFBSSxLQUFLLENBQUMsb0NBQW9DLElBQUksQ0FBQyxJQUFJLEVBQUUsQ0FBQyxDQUFDO0tBQ2xFO0lBQ0QsSUFBSSxDQUFDLElBQUksR0FBRyxJQUFJLENBQUM7QUFDbkIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5pbXBvcnQgKiBhcyBvIGZyb20gJy4uLy4uLy4uLy4uL291dHB1dC9vdXRwdXRfYXN0JztcbmltcG9ydCAqIGFzIGlyIGZyb20gJy4uLy4uL2lyJztcbmltcG9ydCB7Q29tcGlsYXRpb25Kb2IsIENvbXBvbmVudENvbXBpbGF0aW9uSm9ifSBmcm9tICcuLi9jb21waWxhdGlvbic7XG5cbi8qKlxuICogRmluZCBhbGwgYXNzaWdubWVudHMgYW5kIHVzYWdlcyBvZiB0ZW1wb3JhcnkgdmFyaWFibGVzLCB3aGljaCBhcmUgbGlua2VkIHRvIGVhY2ggb3RoZXIgd2l0aCBjcm9zc1xuICogcmVmZXJlbmNlcy4gR2VuZXJhdGUgbmFtZXMgZm9yIGVhY2ggY3Jvc3MtcmVmZXJlbmNlLCBhbmQgYWRkIGEgYERlY2xhcmVWYXJTdG10YCB0byBpbml0aWFsaXplXG4gKiB0aGVtIGF0IHRoZSBiZWdpbm5pbmcgb2YgdGhlIHVwZGF0ZSBibG9jay5cbiAqXG4gKiBUT0RPOiBTb21ldGltZXMsIGl0IHdpbGwgYmUgcG9zc2libGUgdG8gcmV1c2UgbmFtZXMgYWNyb3NzIGRpZmZlcmVudCBzdWJleHByZXNzaW9ucy4gRm9yIGV4YW1wbGUsXG4gKiBpbiB0aGUgZG91YmxlIGtleWVkIHJlYWQgYGE/LltmKCldPy5bZigpXWAsIHRoZSB0d28gZnVuY3Rpb24gY2FsbHMgaGF2ZSBub24tb3ZlcmxhcHBpbmcgc2NvcGVzLlxuICogSW1wbGVtZW50IGFuIGFsZ29yaXRobSBmb3IgcmV1c2UuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBwaGFzZVRlbXBvcmFyeVZhcmlhYmxlcyhjcGw6IENvbXBpbGF0aW9uSm9iKTogdm9pZCB7XG4gIGZvciAoY29uc3QgdW5pdCBvZiBjcGwudW5pdHMpIHtcbiAgICBsZXQgb3BDb3VudCA9IDA7XG4gICAgbGV0IGdlbmVyYXRlZFN0YXRlbWVudHM6IEFycmF5PGlyLlN0YXRlbWVudE9wPGlyLlVwZGF0ZU9wPj4gPSBbXTtcbiAgICBmb3IgKGNvbnN0IG9wIG9mIHVuaXQub3BzKCkpIHtcbiAgICAgIC8vIElkZW50aWZ5IHRoZSBmaW5hbCB0aW1lIGVhY2ggdGVtcCB2YXIgaXMgcmVhZC5cbiAgICAgIGNvbnN0IGZpbmFsUmVhZHMgPSBuZXcgTWFwPGlyLlhyZWZJZCwgaXIuUmVhZFRlbXBvcmFyeUV4cHI+KCk7XG4gICAgICBpci52aXNpdEV4cHJlc3Npb25zSW5PcChvcCwgZXhwciA9PiB7XG4gICAgICAgIGlmIChleHByIGluc3RhbmNlb2YgaXIuUmVhZFRlbXBvcmFyeUV4cHIpIHtcbiAgICAgICAgICBmaW5hbFJlYWRzLnNldChleHByLnhyZWYsIGV4cHIpO1xuICAgICAgICB9XG4gICAgICB9KTtcblxuICAgICAgLy8gTmFtZSB0aGUgdGVtcCB2YXJzLCBhY2NvdW50aW5nIGZvciB0aGUgZmFjdCB0aGF0IGEgbmFtZSBjYW4gYmUgcmV1c2VkIGFmdGVyIGl0IGhhcyBiZWVuXG4gICAgICAvLyByZWFkIGZvciB0aGUgZmluYWwgdGltZS5cbiAgICAgIGxldCBjb3VudCA9IDA7XG4gICAgICBjb25zdCBhc3NpZ25lZCA9IG5ldyBTZXQ8aXIuWHJlZklkPigpO1xuICAgICAgY29uc3QgcmVsZWFzZWQgPSBuZXcgU2V0PGlyLlhyZWZJZD4oKTtcbiAgICAgIGNvbnN0IGRlZnMgPSBuZXcgTWFwPGlyLlhyZWZJZCwgc3RyaW5nPigpO1xuICAgICAgaXIudmlzaXRFeHByZXNzaW9uc0luT3Aob3AsIGV4cHIgPT4ge1xuICAgICAgICBpZiAoZXhwciBpbnN0YW5jZW9mIGlyLkFzc2lnblRlbXBvcmFyeUV4cHIpIHtcbiAgICAgICAgICBpZiAoIWFzc2lnbmVkLmhhcyhleHByLnhyZWYpKSB7XG4gICAgICAgICAgICBhc3NpZ25lZC5hZGQoZXhwci54cmVmKTtcbiAgICAgICAgICAgIC8vIFRPRE86IEV4YWN0bHkgcmVwbGljYXRlIHRoZSBuYW1pbmcgc2NoZW1lIHVzZWQgYnkgYFRlbXBsYXRlRGVmaW5pdGlvbkJ1aWxkZXJgLlxuICAgICAgICAgICAgLy8gSXQgc2VlbXMgdG8gcmVseSBvbiBhbiBleHByZXNzaW9uIGluZGV4IGluc3RlYWQgb2YgYW4gb3AgaW5kZXguXG4gICAgICAgICAgICBkZWZzLnNldChleHByLnhyZWYsIGB0bXBfJHtvcENvdW50fV8ke2NvdW50Kyt9YCk7XG4gICAgICAgICAgfVxuICAgICAgICAgIGFzc2lnbk5hbWUoZGVmcywgZXhwcik7XG4gICAgICAgIH0gZWxzZSBpZiAoZXhwciBpbnN0YW5jZW9mIGlyLlJlYWRUZW1wb3JhcnlFeHByKSB7XG4gICAgICAgICAgaWYgKGZpbmFsUmVhZHMuZ2V0KGV4cHIueHJlZikgPT09IGV4cHIpIHtcbiAgICAgICAgICAgIHJlbGVhc2VkLmFkZChleHByLnhyZWYpO1xuICAgICAgICAgICAgY291bnQtLTtcbiAgICAgICAgICB9XG4gICAgICAgICAgYXNzaWduTmFtZShkZWZzLCBleHByKTtcbiAgICAgICAgfVxuICAgICAgfSk7XG5cbiAgICAgIC8vIEFkZCBkZWNsYXJhdGlvbnMgZm9yIHRoZSB0ZW1wIHZhcnMuXG4gICAgICBnZW5lcmF0ZWRTdGF0ZW1lbnRzLnB1c2goXG4gICAgICAgICAgLi4uQXJyYXkuZnJvbShuZXcgU2V0KGRlZnMudmFsdWVzKCkpKVxuICAgICAgICAgICAgICAubWFwKG5hbWUgPT4gaXIuY3JlYXRlU3RhdGVtZW50T3A8aXIuVXBkYXRlT3A+KG5ldyBvLkRlY2xhcmVWYXJTdG10KG5hbWUpKSkpO1xuICAgICAgb3BDb3VudCsrO1xuICAgIH1cbiAgICB1bml0LnVwZGF0ZS5wcmVwZW5kKGdlbmVyYXRlZFN0YXRlbWVudHMpO1xuICB9XG59XG5cbi8qKlxuICogQXNzaWducyBhIG5hbWUgdG8gdGhlIHRlbXBvcmFyeSB2YXJpYWJsZSBpbiB0aGUgZ2l2ZW4gdGVtcG9yYXJ5IHZhcmlhYmxlIGV4cHJlc3Npb24uXG4gKi9cbmZ1bmN0aW9uIGFzc2lnbk5hbWUoXG4gICAgbmFtZXM6IE1hcDxpci5YcmVmSWQsIHN0cmluZz4sIGV4cHI6IGlyLkFzc2lnblRlbXBvcmFyeUV4cHJ8aXIuUmVhZFRlbXBvcmFyeUV4cHIpIHtcbiAgY29uc3QgbmFtZSA9IG5hbWVzLmdldChleHByLnhyZWYpO1xuICBpZiAobmFtZSA9PT0gdW5kZWZpbmVkKSB7XG4gICAgdGhyb3cgbmV3IEVycm9yKGBGb3VuZCB4cmVmIHdpdGggdW5hc3NpZ25lZCBuYW1lOiAke2V4cHIueHJlZn1gKTtcbiAgfVxuICBleHByLm5hbWUgPSBuYW1lO1xufVxuIl19