@angular/core 16.0.0-next.3 → 16.0.0-next.4

package/esm2020/src/hydration/node_lookup_utils.mjs

@@ -5,15 +5,24 @@
  * 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 { HEADER_OFFSET } from '../render3/interfaces/view';
-import { getNativeByTNode } from '../render3/util/view_utils';
+import { HEADER_OFFSET, HOST } from '../render3/interfaces/view';
+import { getFirstNativeNode } from '../render3/node_manipulation';
+import { ɵɵresolveBody } from '../render3/util/misc_utils';
+import { renderStringify } from '../render3/util/stringify_utils';
+import { getNativeByTNode, unwrapRNode } from '../render3/util/view_utils';
 import { assertDefined } from '../util/assert';
-import { validateSiblingNodeExists } from './error_handling';
+import { compressNodeLocation, decompressNodeLocation } from './compression';
+import { nodeNotFoundAtPathError, nodeNotFoundError, validateSiblingNodeExists } from './error_handling';
+import { NodeNavigationStep, NODES, REFERENCE_NODE_BODY, REFERENCE_NODE_HOST } from './interfaces';
 import { calcSerializedContainerSize, getSegmentHead } from './utils';
 /** Whether current TNode is a first node in an <ng-container>. */
 function isFirstElementInNgContainer(tNode) {
     return !tNode.prev && tNode.parent?.type === 8 /* TNodeType.ElementContainer */;
 }
+/** Returns an instruction index (subtracting HEADER_OFFSET). */
+function getNoOffsetIndex(tNode) {
+    return tNode.index - HEADER_OFFSET;
+}
 /**
  * Locate a node in DOM tree that corresponds to a given TNode.
  *
@@ -25,7 +34,13 @@ function isFirstElementInNgContainer(tNode) {
  */
 export function locateNextRNode(hydrationInfo, tView, lView, tNode) {
     let native = null;
-    if (tView.firstChild === tNode) {
+    const noOffsetIndex = getNoOffsetIndex(tNode);
+    const nodes = hydrationInfo.data[NODES];
+    if (nodes?.[noOffsetIndex]) {
+        // We know the exact location of the node.
+        native = locateRNodeByPath(nodes[noOffsetIndex], lView);
+    }
+    else if (tView.firstChild === tNode) {
         // We create a first node in this view, so we use a reference
         // to the first child in this DOM segment.
         native = hydrationInfo.firstChild;
@@ -38,7 +53,7 @@ export function locateNextRNode(hydrationInfo, tView, lView, tNode) {
             assertDefined(previousTNode, 'Unexpected state: current TNode does not have a connection ' +
                 'to the previous node or a parent node.');
         if (isFirstElementInNgContainer(tNode)) {
-            const noOffsetParentIndex = tNode.parent.index - HEADER_OFFSET;
+            const noOffsetParentIndex = getNoOffsetIndex(tNode.parent);
             native = getSegmentHead(hydrationInfo, noOffsetParentIndex);
         }
         else {
@@ -52,7 +67,7 @@ export function locateNextRNode(hydrationInfo, tView, lView, tNode) {
                 // represented in the DOM as `<div></div>...<!--container-->`.
                 // In this case, there are nodes *after* this element and we need to skip
                 // all of them to reach an element that we are looking for.
-                const noOffsetPrevSiblingIndex = previousTNode.index - HEADER_OFFSET;
+                const noOffsetPrevSiblingIndex = getNoOffsetIndex(previousTNode);
                 const segmentHead = getSegmentHead(hydrationInfo, noOffsetPrevSiblingIndex);
                 if (previousTNode.type === 2 /* TNodeType.Element */ && segmentHead) {
                     const numRootNodesToSkip = calcSerializedContainerSize(hydrationInfo, noOffsetPrevSiblingIndex);
@@ -80,4 +95,181 @@ export function siblingAfter(skip, from) {
     }
     return currentNode;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9kZV9sb29rdXBfdXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb3JlL3NyYy9oeWRyYXRpb24vbm9kZV9sb29rdXBfdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBSUgsT0FBTyxFQUFDLGFBQWEsRUFBZSxNQUFNLDRCQUE0QixDQUFDO0FBQ3ZFLE9BQU8sRUFBQyxnQkFBZ0IsRUFBQyxNQUFNLDRCQUE0QixDQUFDO0FBQzVELE9BQU8sRUFBQyxhQUFhLEVBQUMsTUFBTSxnQkFBZ0IsQ0FBQztBQUU3QyxPQUFPLEVBQUMseUJBQXlCLEVBQUMsTUFBTSxrQkFBa0IsQ0FBQztBQUUzRCxPQUFPLEVBQUMsMkJBQTJCLEVBQUUsY0FBYyxFQUFDLE1BQU0sU0FBUyxDQUFDO0FBRXBFLGtFQUFrRTtBQUNsRSxTQUFTLDJCQUEyQixDQUFDLEtBQVk7SUFDL0MsT0FBTyxDQUFDLEtBQUssQ0FBQyxJQUFJLElBQUksS0FBSyxDQUFDLE1BQU0sRUFBRSxJQUFJLHVDQUErQixDQUFDO0FBQzFFLENBQUM7QUFFRDs7Ozs7Ozs7R0FRRztBQUNILE1BQU0sVUFBVSxlQUFlLENBQzNCLGFBQTZCLEVBQUUsS0FBWSxFQUFFLEtBQXFCLEVBQUUsS0FBWTtJQUNsRixJQUFJLE1BQU0sR0FBZSxJQUFJLENBQUM7SUFDOUIsSUFBSSxLQUFLLENBQUMsVUFBVSxLQUFLLEtBQUssRUFBRTtRQUM5Qiw2REFBNkQ7UUFDN0QsMENBQTBDO1FBQzFDLE1BQU0sR0FBRyxhQUFhLENBQUMsVUFBVSxDQUFDO0tBQ25DO1NBQU07UUFDTCw4REFBOEQ7UUFDOUQsTUFBTSxtQkFBbUIsR0FBRyxLQUFLLENBQUMsSUFBSSxLQUFLLElBQUksQ0FBQztRQUNoRCxNQUFNLGFBQWEsR0FBRyxDQUFDLEtBQUssQ0FBQyxJQUFJLElBQUksS0FBSyxDQUFDLE1BQU0sQ0FBRSxDQUFDO1FBQ3BELFNBQVM7WUFDTCxhQUFhLENBQ1QsYUFBYSxFQUNiLDZEQUE2RDtnQkFDekQsd0NBQXdDLENBQUMsQ0FBQztRQUN0RCxJQUFJLDJCQUEyQixDQUFDLEtBQUssQ0FBQyxFQUFFO1lBQ3RDLE1BQU0sbUJBQW1CLEdBQUcsS0FBSyxDQUFDLE1BQU8sQ0FBQyxLQUFLLEdBQUcsYUFBYSxDQUFDO1lBQ2hFLE1BQU0sR0FBRyxjQUFjLENBQUMsYUFBYSxFQUFFLG1CQUFtQixDQUFDLENBQUM7U0FDN0Q7YUFBTTtZQUNMLElBQUksZ0JBQWdCLEdBQUcsZ0JBQWdCLENBQUMsYUFBYSxFQUFFLEtBQUssQ0FBQyxDQUFDO1lBQzlELElBQUksbUJBQW1CLEVBQUU7Z0JBQ3ZCLE1BQU0sR0FBSSxnQkFBNkIsQ0FBQyxVQUFVLENBQUM7YUFDcEQ7aUJBQU07Z0JBQ0wsc0VBQXNFO2dCQUN0RSw2RUFBNkU7Z0JBQzdFLDhEQUE4RDtnQkFDOUQseUVBQXlFO2dCQUN6RSwyREFBMkQ7Z0JBQzNELE1BQU0sd0JBQXdCLEdBQUcsYUFBYSxDQUFDLEtBQUssR0FBRyxhQUFhLENBQUM7Z0JBQ3JFLE1BQU0sV0FBVyxHQUFHLGNBQWMsQ0FBQyxhQUFhLEVBQUUsd0JBQXdCLENBQUMsQ0FBQztnQkFDNUUsSUFBSSxhQUFhLENBQUMsSUFBSSw4QkFBc0IsSUFBSSxXQUFXLEVBQUU7b0JBQzNELE1BQU0sa0JBQWtCLEdBQ3BCLDJCQUEyQixDQUFDLGFBQWEsRUFBRSx3QkFBd0IsQ0FBQyxDQUFDO29CQUN6RSxnRkFBZ0Y7b0JBQ2hGLE1BQU0sV0FBVyxHQUFHLGtCQUFrQixHQUFHLENBQUMsQ0FBQztvQkFDM0MsaUNBQWlDO29CQUNqQyxNQUFNLEdBQUcsWUFBWSxDQUFDLFdBQVcsRUFBRSxXQUFXLENBQUMsQ0FBQztpQkFDakQ7cUJBQU07b0JBQ0wsTUFBTSxHQUFHLGdCQUFnQixDQUFDLFdBQVcsQ0FBQztpQkFDdkM7YUFDRjtTQUNGO0tBQ0Y7SUFDRCxPQUFPLE1BQVcsQ0FBQztBQUNyQixDQUFDO0FBRUQ7O0dBRUc7QUFDSCxNQUFNLFVBQVUsWUFBWSxDQUFrQixJQUFZLEVBQUUsSUFBVztJQUNyRSxJQUFJLFdBQVcsR0FBRyxJQUFJLENBQUM7SUFDdkIsS0FBSyxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxHQUFHLElBQUksRUFBRSxDQUFDLEVBQUUsRUFBRTtRQUM3QixTQUFTLElBQUkseUJBQXlCLENBQUMsV0FBVyxDQUFDLENBQUM7UUFDcEQsV0FBVyxHQUFHLFdBQVcsQ0FBQyxXQUFZLENBQUM7S0FDeEM7SUFDRCxPQUFPLFdBQWdCLENBQUM7QUFDMUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5pbXBvcnQge1ROb2RlLCBUTm9kZVR5cGV9IGZyb20gJy4uL3JlbmRlcjMvaW50ZXJmYWNlcy9ub2RlJztcbmltcG9ydCB7UkVsZW1lbnQsIFJOb2RlfSBmcm9tICcuLi9yZW5kZXIzL2ludGVyZmFjZXMvcmVuZGVyZXJfZG9tJztcbmltcG9ydCB7SEVBREVSX09GRlNFVCwgTFZpZXcsIFRWaWV3fSBmcm9tICcuLi9yZW5kZXIzL2ludGVyZmFjZXMvdmlldyc7XG5pbXBvcnQge2dldE5hdGl2ZUJ5VE5vZGV9IGZyb20gJy4uL3JlbmRlcjMvdXRpbC92aWV3X3V0aWxzJztcbmltcG9ydCB7YXNzZXJ0RGVmaW5lZH0gZnJvbSAnLi4vdXRpbC9hc3NlcnQnO1xuXG5pbXBvcnQge3ZhbGlkYXRlU2libGluZ05vZGVFeGlzdHN9IGZyb20gJy4vZXJyb3JfaGFuZGxpbmcnO1xuaW1wb3J0IHtEZWh5ZHJhdGVkVmlld30gZnJvbSAnLi9pbnRlcmZhY2VzJztcbmltcG9ydCB7Y2FsY1NlcmlhbGl6ZWRDb250YWluZXJTaXplLCBnZXRTZWdtZW50SGVhZH0gZnJvbSAnLi91dGlscyc7XG5cbi8qKiBXaGV0aGVyIGN1cnJlbnQgVE5vZGUgaXMgYSBmaXJzdCBub2RlIGluIGFuIDxuZy1jb250YWluZXI+LiAqL1xuZnVuY3Rpb24gaXNGaXJzdEVsZW1lbnRJbk5nQ29udGFpbmVyKHROb2RlOiBUTm9kZSk6IGJvb2xlYW4ge1xuICByZXR1cm4gIXROb2RlLnByZXYgJiYgdE5vZGUucGFyZW50Py50eXBlID09PSBUTm9kZVR5cGUuRWxlbWVudENvbnRhaW5lcjtcbn1cblxuLyoqXG4gKiBMb2NhdGUgYSBub2RlIGluIERPTSB0cmVlIHRoYXQgY29ycmVzcG9uZHMgdG8gYSBnaXZlbiBUTm9kZS5cbiAqXG4gKiBAcGFyYW0gaHlkcmF0aW9uSW5mbyBUaGUgaHlkcmF0aW9uIGFubm90YXRpb24gZGF0YVxuICogQHBhcmFtIHRWaWV3IHRoZSBjdXJyZW50IHRWaWV3XG4gKiBAcGFyYW0gbFZpZXcgdGhlIGN1cnJlbnQgbFZpZXdcbiAqIEBwYXJhbSB0Tm9kZSB0aGUgY3VycmVudCB0Tm9kZVxuICogQHJldHVybnMgYW4gUk5vZGUgdGhhdCByZXByZXNlbnRzIGEgZ2l2ZW4gdE5vZGVcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGxvY2F0ZU5leHRSTm9kZTxUIGV4dGVuZHMgUk5vZGU+KFxuICAgIGh5ZHJhdGlvbkluZm86IERlaHlkcmF0ZWRWaWV3LCB0VmlldzogVFZpZXcsIGxWaWV3OiBMVmlldzx1bmtub3duPiwgdE5vZGU6IFROb2RlKTogVHxudWxsIHtcbiAgbGV0IG5hdGl2ZTogUk5vZGV8bnVsbCA9IG51bGw7XG4gIGlmICh0Vmlldy5maXJzdENoaWxkID09PSB0Tm9kZSkge1xuICAgIC8vIFdlIGNyZWF0ZSBhIGZpcnN0IG5vZGUgaW4gdGhpcyB2aWV3LCBzbyB3ZSB1c2UgYSByZWZlcmVuY2VcbiAgICAvLyB0byB0aGUgZmlyc3QgY2hpbGQgaW4gdGhpcyBET00gc2VnbWVudC5cbiAgICBuYXRpdmUgPSBoeWRyYXRpb25JbmZvLmZpcnN0Q2hpbGQ7XG4gIH0gZWxzZSB7XG4gICAgLy8gTG9jYXRlIGEgbm9kZSBiYXNlZCBvbiBhIHByZXZpb3VzIHNpYmxpbmcgb3IgYSBwYXJlbnQgbm9kZS5cbiAgICBjb25zdCBwcmV2aW91c1ROb2RlUGFyZW50ID0gdE5vZGUucHJldiA9PT0gbnVsbDtcbiAgICBjb25zdCBwcmV2aW91c1ROb2RlID0gKHROb2RlLnByZXYgPz8gdE5vZGUucGFyZW50KSE7XG4gICAgbmdEZXZNb2RlICYmXG4gICAgICAgIGFzc2VydERlZmluZWQoXG4gICAgICAgICAgICBwcmV2aW91c1ROb2RlLFxuICAgICAgICAgICAgJ1VuZXhwZWN0ZWQgc3RhdGU6IGN1cnJlbnQgVE5vZGUgZG9lcyBub3QgaGF2ZSBhIGNvbm5lY3Rpb24gJyArXG4gICAgICAgICAgICAgICAgJ3RvIHRoZSBwcmV2aW91cyBub2RlIG9yIGEgcGFyZW50IG5vZGUuJyk7XG4gICAgaWYgKGlzRmlyc3RFbGVtZW50SW5OZ0NvbnRhaW5lcih0Tm9kZSkpIHtcbiAgICAgIGNvbnN0IG5vT2Zmc2V0UGFyZW50SW5kZXggPSB0Tm9kZS5wYXJlbnQhLmluZGV4IC0gSEVBREVSX09GRlNFVDtcbiAgICAgIG5hdGl2ZSA9IGdldFNlZ21lbnRIZWFkKGh5ZHJhdGlvbkluZm8sIG5vT2Zmc2V0UGFyZW50SW5kZXgpO1xuICAgIH0gZWxzZSB7XG4gICAgICBsZXQgcHJldmlvdXNSRWxlbWVudCA9IGdldE5hdGl2ZUJ5VE5vZGUocHJldmlvdXNUTm9kZSwgbFZpZXcpO1xuICAgICAgaWYgKHByZXZpb3VzVE5vZGVQYXJlbnQpIHtcbiAgICAgICAgbmF0aXZlID0gKHByZXZpb3VzUkVsZW1lbnQgYXMgUkVsZW1lbnQpLmZpcnN0Q2hpbGQ7XG4gICAgICB9IGVsc2Uge1xuICAgICAgICAvLyBJZiB0aGUgcHJldmlvdXMgbm9kZSBpcyBhbiBlbGVtZW50LCBidXQgaXQgYWxzbyBoYXMgY29udGFpbmVyIGluZm8sXG4gICAgICAgIC8vIHRoaXMgbWVhbnMgdGhhdCB3ZSBhcmUgcHJvY2Vzc2luZyBhIG5vZGUgbGlrZSBgPGRpdiAjdmNyVGFyZ2V0PmAsIHdoaWNoIGlzXG4gICAgICAgIC8vIHJlcHJlc2VudGVkIGluIHRoZSBET00gYXMgYDxkaXY+PC9kaXY+Li4uPCEtLWNvbnRhaW5lci0tPmAuXG4gICAgICAgIC8vIEluIHRoaXMgY2FzZSwgdGhlcmUgYXJlIG5vZGVzICphZnRlciogdGhpcyBlbGVtZW50IGFuZCB3ZSBuZWVkIHRvIHNraXBcbiAgICAgICAgLy8gYWxsIG9mIHRoZW0gdG8gcmVhY2ggYW4gZWxlbWVudCB0aGF0IHdlIGFyZSBsb29raW5nIGZvci5cbiAgICAgICAgY29uc3Qgbm9PZmZzZXRQcmV2U2libGluZ0luZGV4ID0gcHJldmlvdXNUTm9kZS5pbmRleCAtIEhFQURFUl9PRkZTRVQ7XG4gICAgICAgIGNvbnN0IHNlZ21lbnRIZWFkID0gZ2V0U2VnbWVudEhlYWQoaHlkcmF0aW9uSW5mbywgbm9PZmZzZXRQcmV2U2libGluZ0luZGV4KTtcbiAgICAgICAgaWYgKHByZXZpb3VzVE5vZGUudHlwZSA9PT0gVE5vZGVUeXBlLkVsZW1lbnQgJiYgc2VnbWVudEhlYWQpIHtcbiAgICAgICAgICBjb25zdCBudW1Sb290Tm9kZXNUb1NraXAgPVxuICAgICAgICAgICAgICBjYWxjU2VyaWFsaXplZENvbnRhaW5lclNpemUoaHlkcmF0aW9uSW5mbywgbm9PZmZzZXRQcmV2U2libGluZ0luZGV4KTtcbiAgICAgICAgICAvLyBgKzFgIHN0YW5kcyBmb3IgYW4gYW5jaG9yIGNvbW1lbnQgbm9kZSBhZnRlciBhbGwgdGhlIHZpZXdzIGluIHRoaXMgY29udGFpbmVyLlxuICAgICAgICAgIGNvbnN0IG5vZGVzVG9Ta2lwID0gbnVtUm9vdE5vZGVzVG9Ta2lwICsgMTtcbiAgICAgICAgICAvLyBGaXJzdCBub2RlIGFmdGVyIHRoaXMgc2VnbWVudC5cbiAgICAgICAgICBuYXRpdmUgPSBzaWJsaW5nQWZ0ZXIobm9kZXNUb1NraXAsIHNlZ21lbnRIZWFkKTtcbiAgICAgICAgfSBlbHNlIHtcbiAgICAgICAgICBuYXRpdmUgPSBwcmV2aW91c1JFbGVtZW50Lm5leHRTaWJsaW5nO1xuICAgICAgICB9XG4gICAgICB9XG4gICAgfVxuICB9XG4gIHJldHVybiBuYXRpdmUgYXMgVDtcbn1cblxuLyoqXG4gKiBTa2lwcyBvdmVyIGEgc3BlY2lmaWVkIG51bWJlciBvZiBub2RlcyBhbmQgcmV0dXJucyB0aGUgbmV4dCBzaWJsaW5nIG5vZGUgYWZ0ZXIgdGhhdC5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHNpYmxpbmdBZnRlcjxUIGV4dGVuZHMgUk5vZGU+KHNraXA6IG51bWJlciwgZnJvbTogUk5vZGUpOiBUfG51bGwge1xuICBsZXQgY3VycmVudE5vZGUgPSBmcm9tO1xuICBmb3IgKGxldCBpID0gMDsgaSA8IHNraXA7IGkrKykge1xuICAgIG5nRGV2TW9kZSAmJiB2YWxpZGF0ZVNpYmxpbmdOb2RlRXhpc3RzKGN1cnJlbnROb2RlKTtcbiAgICBjdXJyZW50Tm9kZSA9IGN1cnJlbnROb2RlLm5leHRTaWJsaW5nITtcbiAgfVxuICByZXR1cm4gY3VycmVudE5vZGUgYXMgVDtcbn1cbiJdfQ==
+/**
+ * Helper function to produce a string representation of the navigation steps
+ * (in terms of `nextSibling` and `firstChild` navigations). Used in error
+ * messages in dev mode.
+ */
+function stringifyNavigationInstructions(instructions) {
+    const container = [];
+    let i = 0;
+    while (i < instructions.length) {
+        const step = instructions[i++];
+        const repeat = instructions[i++];
+        for (let r = 0; r < repeat; r++) {
+            container.push(step === NodeNavigationStep.FirstChild ? 'firstChild' : 'nextSibling');
+        }
+    }
+    return container.join('.');
+}
+/**
+ * Helper function that navigates from a starting point node (the `from` node)
+ * using provided set of navigation instructions (within `path` argument).
+ */
+function navigateToNode(from, instructions) {
+    let node = from;
+    let i = 0;
+    while (i < instructions.length) {
+        const step = instructions[i++];
+        const repeat = instructions[i++];
+        for (let r = 0; r < repeat; r++) {
+            if (ngDevMode && !node) {
+                throw nodeNotFoundAtPathError(from, stringifyNavigationInstructions(instructions));
+            }
+            switch (step) {
+                case NodeNavigationStep.FirstChild:
+                    node = node.firstChild;
+                    break;
+                case NodeNavigationStep.NextSibling:
+                    node = node.nextSibling;
+                    break;
+            }
+        }
+    }
+    if (ngDevMode && !node) {
+        throw nodeNotFoundAtPathError(from, stringifyNavigationInstructions(instructions));
+    }
+    return node;
+}
+/**
+ * Locates an RNode given a set of navigation instructions (which also contains
+ * a starting point node info).
+ */
+function locateRNodeByPath(path, lView) {
+    const [referenceNode, ...navigationInstructions] = decompressNodeLocation(path);
+    let ref;
+    if (referenceNode === REFERENCE_NODE_HOST) {
+        ref = lView[0];
+    }
+    else if (referenceNode === REFERENCE_NODE_BODY) {
+        ref = ɵɵresolveBody(lView[0]);
+    }
+    else {
+        const parentElementId = Number(referenceNode);
+        ref = unwrapRNode(lView[parentElementId + HEADER_OFFSET]);
+    }
+    return navigateToNode(ref, navigationInstructions);
+}
+/**
+ * Generate a list of DOM navigation operations to get from node `start` to node `finish`.
+ *
+ * Note: assumes that node `start` occurs before node `finish` in an in-order traversal of the DOM
+ * tree. That is, we should be able to get from `start` to `finish` purely by using `.firstChild`
+ * and `.nextSibling` operations.
+ */
+export function navigateBetween(start, finish) {
+    if (start === finish) {
+        return [];
+    }
+    else if (start.parentElement == null || finish.parentElement == null) {
+        return null;
+    }
+    else if (start.parentElement === finish.parentElement) {
+        return navigateBetweenSiblings(start, finish);
+    }
+    else {
+        // `finish` is a child of its parent, so the parent will always have a child.
+        const parent = finish.parentElement;
+        const parentPath = navigateBetween(start, parent);
+        const childPath = navigateBetween(parent.firstChild, finish);
+        if (!parentPath || !childPath)
+            return null;
+        return [
+            // First navigate to `finish`'s parent
+            ...parentPath,
+            // Then to its first child.
+            NodeNavigationStep.FirstChild,
+            // And finally from that node to `finish` (maybe a no-op if we're already there).
+            ...childPath,
+        ];
+    }
+}
+/**
+ * Calculates a path between 2 sibling nodes (generates a number of `NextSibling` navigations).
+ */
+function navigateBetweenSiblings(start, finish) {
+    const nav = [];
+    let node = null;
+    for (node = start; node != null && node !== finish; node = node.nextSibling) {
+        nav.push(NodeNavigationStep.NextSibling);
+    }
+    return node === null ? [] : nav;
+}
+/**
+ * Calculates a path between 2 nodes in terms of `nextSibling` and `firstChild`
+ * navigations:
+ * - the `from` node is a known node, used as an starting point for the lookup
+ *   (the `fromNodeName` argument is a string representation of the node).
+ * - the `to` node is a node that the runtime logic would be looking up,
+ *   using the path generated by this function.
+ */
+export function calcPathBetween(from, to, fromNodeName) {
+    const path = navigateBetween(from, to);
+    return path === null ? null : compressNodeLocation(fromNodeName, path);
+}
+/**
+ * Invoked at serialization time (on the server) when a set of navigation
+ * instructions needs to be generated for a TNode.
+ */
+export function calcPathForNode(tNode, lView) {
+    const parentTNode = tNode.parent;
+    let parentIndex;
+    let parentRNode;
+    let referenceNodeName;
+    if (parentTNode === null) {
+        // No parent TNode - use host element as a reference node.
+        parentIndex = referenceNodeName = REFERENCE_NODE_HOST;
+        parentRNode = lView[HOST];
+    }
+    else {
+        // Use parent TNode as a reference node.
+        parentIndex = parentTNode.index;
+        parentRNode = unwrapRNode(lView[parentIndex]);
+        referenceNodeName = renderStringify(parentIndex - HEADER_OFFSET);
+    }
+    let rNode = unwrapRNode(lView[tNode.index]);
+    if (tNode.type & 12 /* TNodeType.AnyContainer */) {
+        // For <ng-container> nodes, instead of serializing a reference
+        // to the anchor comment node, serialize a location of the first
+        // DOM element. Paired with the container size (serialized as a part
+        // of `ngh.containers`), it should give enough information for runtime
+        // to hydrate nodes in this container.
+        const firstRNode = getFirstNativeNode(lView, tNode);
+        // If container is not empty, use a reference to the first element,
+        // otherwise, rNode would point to an anchor comment node.
+        if (firstRNode) {
+            rNode = firstRNode;
+        }
+    }
+    let path = calcPathBetween(parentRNode, rNode, referenceNodeName);
+    if (path === null && parentRNode !== rNode) {
+        // Searching for a path between elements within a host node failed.
+        // Trying to find a path to an element starting from the `document.body` instead.
+        //
+        // Important note: this type of reference is relatively unstable, since Angular
+        // may not be able to control parts of the page that the runtime logic navigates
+        // through. This is mostly needed to cover "portals" use-case (like menus, dialog boxes,
+        // etc), where nodes are content-projected (including direct DOM manipulations) outside
+        // of the host node. The better solution is to provide APIs to work with "portals",
+        // at which point this code path would not be needed.
+        const body = parentRNode.ownerDocument.body;
+        path = calcPathBetween(body, rNode, REFERENCE_NODE_BODY);
+        if (path === null) {
+            // If the path is still empty, it's likely that this node is detached and
+            // won't be found during hydration.
+            throw nodeNotFoundError(lView, tNode);
+        }
+    }
+    return path;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node_lookup_utils.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/hydration/node_lookup_utils.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 {TNode, TNodeType} from '../render3/interfaces/node';\nimport {RElement, RNode} from '../render3/interfaces/renderer_dom';\nimport {HEADER_OFFSET, HOST, LView, TView} from '../render3/interfaces/view';\nimport {getFirstNativeNode} from '../render3/node_manipulation';\nimport {ɵɵresolveBody} from '../render3/util/misc_utils';\nimport {renderStringify} from '../render3/util/stringify_utils';\nimport {getNativeByTNode, unwrapRNode} from '../render3/util/view_utils';\nimport {assertDefined} from '../util/assert';\n\nimport {compressNodeLocation, decompressNodeLocation} from './compression';\nimport {nodeNotFoundAtPathError, nodeNotFoundError, validateSiblingNodeExists} from './error_handling';\nimport {DehydratedView, NodeNavigationStep, NODES, REFERENCE_NODE_BODY, REFERENCE_NODE_HOST} from './interfaces';\nimport {calcSerializedContainerSize, getSegmentHead} from './utils';\n\n\n/** Whether current TNode is a first node in an <ng-container>. */\nfunction isFirstElementInNgContainer(tNode: TNode): boolean {\n  return !tNode.prev && tNode.parent?.type === TNodeType.ElementContainer;\n}\n\n/** Returns an instruction index (subtracting HEADER_OFFSET). */\nfunction getNoOffsetIndex(tNode: TNode): number {\n  return tNode.index - HEADER_OFFSET;\n}\n\n/**\n * Locate a node in DOM tree that corresponds to a given TNode.\n *\n * @param hydrationInfo The hydration annotation data\n * @param tView the current tView\n * @param lView the current lView\n * @param tNode the current tNode\n * @returns an RNode that represents a given tNode\n */\nexport function locateNextRNode<T extends RNode>(\n    hydrationInfo: DehydratedView, tView: TView, lView: LView<unknown>, tNode: TNode): T|null {\n  let native: RNode|null = null;\n  const noOffsetIndex = getNoOffsetIndex(tNode);\n  const nodes = hydrationInfo.data[NODES];\n  if (nodes?.[noOffsetIndex]) {\n    // We know the exact location of the node.\n    native = locateRNodeByPath(nodes[noOffsetIndex], lView);\n  } else if (tView.firstChild === tNode) {\n    // We create a first node in this view, so we use a reference\n    // to the first child in this DOM segment.\n    native = hydrationInfo.firstChild;\n  } else {\n    // Locate a node based on a previous sibling or a parent node.\n    const previousTNodeParent = tNode.prev === null;\n    const previousTNode = (tNode.prev ?? tNode.parent)!;\n    ngDevMode &&\n        assertDefined(\n            previousTNode,\n            'Unexpected state: current TNode does not have a connection ' +\n                'to the previous node or a parent node.');\n    if (isFirstElementInNgContainer(tNode)) {\n      const noOffsetParentIndex = getNoOffsetIndex(tNode.parent!);\n      native = getSegmentHead(hydrationInfo, noOffsetParentIndex);\n    } else {\n      let previousRElement = getNativeByTNode(previousTNode, lView);\n      if (previousTNodeParent) {\n        native = (previousRElement as RElement).firstChild;\n      } else {\n        // If the previous node is an element, but it also has container info,\n        // this means that we are processing a node like `<div #vcrTarget>`, which is\n        // represented in the DOM as `<div></div>...<!--container-->`.\n        // In this case, there are nodes *after* this element and we need to skip\n        // all of them to reach an element that we are looking for.\n        const noOffsetPrevSiblingIndex = getNoOffsetIndex(previousTNode);\n        const segmentHead = getSegmentHead(hydrationInfo, noOffsetPrevSiblingIndex);\n        if (previousTNode.type === TNodeType.Element && segmentHead) {\n          const numRootNodesToSkip =\n              calcSerializedContainerSize(hydrationInfo, noOffsetPrevSiblingIndex);\n          // `+1` stands for an anchor comment node after all the views in this container.\n          const nodesToSkip = numRootNodesToSkip + 1;\n          // First node after this segment.\n          native = siblingAfter(nodesToSkip, segmentHead);\n        } else {\n          native = previousRElement.nextSibling;\n        }\n      }\n    }\n  }\n  return native as T;\n}\n\n/**\n * Skips over a specified number of nodes and returns the next sibling node after that.\n */\nexport function siblingAfter<T extends RNode>(skip: number, from: RNode): T|null {\n  let currentNode = from;\n  for (let i = 0; i < skip; i++) {\n    ngDevMode && validateSiblingNodeExists(currentNode);\n    currentNode = currentNode.nextSibling!;\n  }\n  return currentNode as T;\n}\n\n/**\n * Helper function to produce a string representation of the navigation steps\n * (in terms of `nextSibling` and `firstChild` navigations). Used in error\n * messages in dev mode.\n */\nfunction stringifyNavigationInstructions(instructions: (number|NodeNavigationStep)[]): string {\n  const container = [];\n  let i = 0;\n  while (i < instructions.length) {\n    const step = instructions[i++];\n    const repeat = instructions[i++] as number;\n    for (let r = 0; r < repeat; r++) {\n      container.push(step === NodeNavigationStep.FirstChild ? 'firstChild' : 'nextSibling');\n    }\n  }\n  return container.join('.');\n}\n\n/**\n * Helper function that navigates from a starting point node (the `from` node)\n * using provided set of navigation instructions (within `path` argument).\n */\nfunction navigateToNode(from: Node, instructions: (number|NodeNavigationStep)[]): RNode {\n  let node = from;\n  let i = 0;\n  while (i < instructions.length) {\n    const step = instructions[i++];\n    const repeat = instructions[i++] as number;\n    for (let r = 0; r < repeat; r++) {\n      if (ngDevMode && !node) {\n        throw nodeNotFoundAtPathError(from, stringifyNavigationInstructions(instructions));\n      }\n      switch (step) {\n        case NodeNavigationStep.FirstChild:\n          node = node.firstChild!;\n          break;\n        case NodeNavigationStep.NextSibling:\n          node = node.nextSibling!;\n          break;\n      }\n    }\n  }\n  if (ngDevMode && !node) {\n    throw nodeNotFoundAtPathError(from, stringifyNavigationInstructions(instructions));\n  }\n  return node as RNode;\n}\n\n/**\n * Locates an RNode given a set of navigation instructions (which also contains\n * a starting point node info).\n */\nfunction locateRNodeByPath(path: string, lView: LView): RNode {\n  const [referenceNode, ...navigationInstructions] = decompressNodeLocation(path);\n  let ref: Element;\n  if (referenceNode === REFERENCE_NODE_HOST) {\n    ref = lView[0] as unknown as Element;\n  } else if (referenceNode === REFERENCE_NODE_BODY) {\n    ref = ɵɵresolveBody(lView[0] as unknown as RElement & {ownerDocument: Document});\n  } else {\n    const parentElementId = Number(referenceNode);\n    ref = unwrapRNode((lView as any)[parentElementId + HEADER_OFFSET]) as Element;\n  }\n  return navigateToNode(ref, navigationInstructions);\n}\n\n/**\n * Generate a list of DOM navigation operations to get from node `start` to node `finish`.\n *\n * Note: assumes that node `start` occurs before node `finish` in an in-order traversal of the DOM\n * tree. That is, we should be able to get from `start` to `finish` purely by using `.firstChild`\n * and `.nextSibling` operations.\n */\nexport function navigateBetween(start: Node, finish: Node): NodeNavigationStep[]|null {\n  if (start === finish) {\n    return [];\n  } else if (start.parentElement == null || finish.parentElement == null) {\n    return null;\n  } else if (start.parentElement === finish.parentElement) {\n    return navigateBetweenSiblings(start, finish);\n  } else {\n    // `finish` is a child of its parent, so the parent will always have a child.\n    const parent = finish.parentElement!;\n\n    const parentPath = navigateBetween(start, parent);\n    const childPath = navigateBetween(parent.firstChild!, finish);\n    if (!parentPath || !childPath) return null;\n\n    return [\n      // First navigate to `finish`'s parent\n      ...parentPath,\n      // Then to its first child.\n      NodeNavigationStep.FirstChild,\n      // And finally from that node to `finish` (maybe a no-op if we're already there).\n      ...childPath,\n    ];\n  }\n}\n\n/**\n * Calculates a path between 2 sibling nodes (generates a number of `NextSibling` navigations).\n */\nfunction navigateBetweenSiblings(start: Node, finish: Node): NodeNavigationStep[] {\n  const nav: NodeNavigationStep[] = [];\n  let node: Node|null = null;\n  for (node = start; node != null && node !== finish; node = node.nextSibling) {\n    nav.push(NodeNavigationStep.NextSibling);\n  }\n  return node === null ? [] : nav;\n}\n\n/**\n * Calculates a path between 2 nodes in terms of `nextSibling` and `firstChild`\n * navigations:\n * - the `from` node is a known node, used as an starting point for the lookup\n *   (the `fromNodeName` argument is a string representation of the node).\n * - the `to` node is a node that the runtime logic would be looking up,\n *   using the path generated by this function.\n */\nexport function calcPathBetween(from: Node, to: Node, fromNodeName: string): string|null {\n  const path = navigateBetween(from, to);\n  return path === null ? null : compressNodeLocation(fromNodeName, path);\n}\n\n/**\n * Invoked at serialization time (on the server) when a set of navigation\n * instructions needs to be generated for a TNode.\n */\nexport function calcPathForNode(tNode: TNode, lView: LView): string {\n  const parentTNode = tNode.parent;\n  let parentIndex: number|string;\n  let parentRNode: RNode;\n  let referenceNodeName: string;\n  if (parentTNode === null) {\n    // No parent TNode - use host element as a reference node.\n    parentIndex = referenceNodeName = REFERENCE_NODE_HOST;\n    parentRNode = lView[HOST]!;\n  } else {\n    // Use parent TNode as a reference node.\n    parentIndex = parentTNode.index;\n    parentRNode = unwrapRNode(lView[parentIndex]);\n    referenceNodeName = renderStringify(parentIndex - HEADER_OFFSET);\n  }\n  let rNode = unwrapRNode(lView[tNode.index]);\n  if (tNode.type & TNodeType.AnyContainer) {\n    // For <ng-container> nodes, instead of serializing a reference\n    // to the anchor comment node, serialize a location of the first\n    // DOM element. Paired with the container size (serialized as a part\n    // of `ngh.containers`), it should give enough information for runtime\n    // to hydrate nodes in this container.\n    const firstRNode = getFirstNativeNode(lView, tNode);\n\n    // If container is not empty, use a reference to the first element,\n    // otherwise, rNode would point to an anchor comment node.\n    if (firstRNode) {\n      rNode = firstRNode;\n    }\n  }\n  let path: string|null = calcPathBetween(parentRNode as Node, rNode as Node, referenceNodeName);\n  if (path === null && parentRNode !== rNode) {\n    // Searching for a path between elements within a host node failed.\n    // Trying to find a path to an element starting from the `document.body` instead.\n    //\n    // Important note: this type of reference is relatively unstable, since Angular\n    // may not be able to control parts of the page that the runtime logic navigates\n    // through. This is mostly needed to cover \"portals\" use-case (like menus, dialog boxes,\n    // etc), where nodes are content-projected (including direct DOM manipulations) outside\n    // of the host node. The better solution is to provide APIs to work with \"portals\",\n    // at which point this code path would not be needed.\n    const body = (parentRNode as Node).ownerDocument!.body as Node;\n    path = calcPathBetween(body, rNode as Node, REFERENCE_NODE_BODY);\n\n    if (path === null) {\n      // If the path is still empty, it's likely that this node is detached and\n      // won't be found during hydration.\n      throw nodeNotFoundError(lView, tNode);\n    }\n  }\n  return path!;\n}\n"]}

package/esm2020/src/hydration/utils.mjs

@@ -10,7 +10,7 @@ import { isRootView } from '../render3/interfaces/type_checks';
 import { HEADER_OFFSET, TVIEW } from '../render3/interfaces/view';
 import { makeStateKey, TransferState } from '../transfer_state';
 import { assertDefined } from '../util/assert';
-import { CONTAINERS, ELEMENT_CONTAINERS, NUM_ROOT_NODES } from './interfaces';
+import { CONTAINERS, DISCONNECTED_NODES, ELEMENT_CONTAINERS, MULTIPLIER, NUM_ROOT_NODES } from './interfaces';
 /**
  * The name of the key used in the TransferState collection,
  * where hydration information is located.
@@ -199,8 +199,21 @@ export function calcSerializedContainerSize(hydrationInfo, index) {
     const views = getSerializedContainerViews(hydrationInfo, index) ?? [];
     let numNodes = 0;
     for (let view of views) {
-        numNodes += view[NUM_ROOT_NODES];
+        numNodes += view[NUM_ROOT_NODES] * (view[MULTIPLIER] ?? 1);
     }
     return numNodes;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/hydration/utils.ts"],"names":[],"mappings":"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","sourcesContent":["\n/**\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 {Injector} from '../di/injector';\nimport {ViewRef} from '../linker/view_ref';\nimport {getDocument} from '../render3/interfaces/document';\nimport {RElement, RNode} from '../render3/interfaces/renderer_dom';\nimport {isRootView} from '../render3/interfaces/type_checks';\nimport {HEADER_OFFSET, LView, TVIEW, TViewType} from '../render3/interfaces/view';\nimport {makeStateKey, TransferState} from '../transfer_state';\nimport {assertDefined} from '../util/assert';\n\nimport {CONTAINERS, DehydratedView, ELEMENT_CONTAINERS, NUM_ROOT_NODES, SerializedContainerView, SerializedView} from './interfaces';\n\n/**\n * The name of the key used in the TransferState collection,\n * where hydration information is located.\n */\nconst TRANSFER_STATE_TOKEN_ID = '__ɵnghData__';\n\n/**\n * Lookup key used to reference DOM hydration data (ngh) in `TransferState`.\n */\nexport const NGH_DATA_KEY = makeStateKey<Array<SerializedView>>(TRANSFER_STATE_TOKEN_ID);\n\n/**\n * The name of the attribute that would be added to host component\n * nodes and contain a reference to a particular slot in transferred\n * state that contains the necessary hydration info for this component.\n */\nexport const NGH_ATTR_NAME = 'ngh';\n\nexport const enum TextNodeMarker {\n\n  /**\n   * The contents of the text comment added to nodes that would otherwise be\n   * empty when serialized by the server and passed to the client. The empty\n   * node is lost when the browser parses it otherwise. This comment node will\n   * be replaced during hydration in the client to restore the lost empty text\n   * node.\n   */\n  EmptyNode = 'ngetn',\n\n  /**\n   * The contents of the text comment added in the case of adjacent text nodes.\n   * When adjacent text nodes are serialized by the server and sent to the\n   * client, the browser loses reference to the amount of nodes and assumes\n   * just one text node. This separator is replaced during hydration to restore\n   * the proper separation and amount of text nodes that should be present.\n   */\n  Separator = 'ngtns',\n}\n\n/**\n * Reference to a function that reads `ngh` attribute value from a given RNode\n * and retrieves hydration information from the TransferState using that value\n * as an index. Returns `null` by default, when hydration is not enabled.\n *\n * @param rNode Component's host element.\n * @param injector Injector that this component has access to.\n */\nlet _retrieveHydrationInfoImpl: typeof retrieveHydrationInfoImpl =\n    (rNode: RElement, injector: Injector) => null;\n\nexport function retrieveHydrationInfoImpl(rNode: RElement, injector: Injector): DehydratedView|\n    null {\n  const nghAttrValue = rNode.getAttribute(NGH_ATTR_NAME);\n  if (nghAttrValue == null) return null;\n\n  let data: SerializedView = {};\n  // An element might have an empty `ngh` attribute value (e.g. `<comp ngh=\"\" />`),\n  // which means that no special annotations are required. Do not attempt to read\n  // from the TransferState in this case.\n  if (nghAttrValue !== '') {\n    const transferState = injector.get(TransferState, null, {optional: true});\n    if (transferState !== null) {\n      const nghData = transferState.get(NGH_DATA_KEY, []);\n\n      // The nghAttrValue is always a number referencing an index\n      // in the hydration TransferState data.\n      data = nghData[Number(nghAttrValue)];\n\n      // If the `ngh` attribute exists and has a non-empty value,\n      // the hydration info *must* be present in the TransferState.\n      // If there is no data for some reasons, this is an error.\n      ngDevMode && assertDefined(data, 'Unable to retrieve hydration info from the TransferState.');\n    }\n  }\n  const dehydratedView: DehydratedView = {\n    data,\n    firstChild: rNode.firstChild ?? null,\n  };\n  // The `ngh` attribute is cleared from the DOM node now\n  // that the data has been retrieved.\n  rNode.removeAttribute(NGH_ATTR_NAME);\n\n  // Note: don't check whether this node was claimed for hydration,\n  // because this node might've been previously claimed while processing\n  // template instructions.\n  ngDevMode && markRNodeAsClaimedByHydration(rNode, /* checkIfAlreadyClaimed */ false);\n  ngDevMode && ngDevMode.hydratedComponents++;\n\n  return dehydratedView;\n}\n\n/**\n * Sets the implementation for the `retrieveHydrationInfo` function.\n */\nexport function enableRetrieveHydrationInfoImpl() {\n  _retrieveHydrationInfoImpl = retrieveHydrationInfoImpl;\n}\n\n/**\n * Retrieves hydration info by reading the value from the `ngh` attribute\n * and accessing a corresponding slot in TransferState storage.\n */\nexport function retrieveHydrationInfo(rNode: RElement, injector: Injector): DehydratedView|null {\n  return _retrieveHydrationInfoImpl(rNode, injector);\n}\n\n/**\n * Retrieves an instance of a component LView from a given ViewRef.\n * Returns an instance of a component LView or `null` in case of an embedded view.\n */\nexport function getComponentLViewForHydration(viewRef: ViewRef): LView|null {\n  // Reading an internal field from `ViewRef` instance.\n  let lView = (viewRef as any)._lView as LView;\n  const tView = lView[TVIEW];\n  // A registered ViewRef might represent an instance of an\n  // embedded view, in which case we do not need to annotate it.\n  if (tView.type === TViewType.Embedded) {\n    return null;\n  }\n  // Check if it's a root view and if so, retrieve component's\n  // LView from the first slot after the header.\n  if (isRootView(lView)) {\n    lView = lView[HEADER_OFFSET];\n  }\n  return lView;\n}\n\nfunction getTextNodeContent(node: Node): string|undefined {\n  return node.textContent?.replace(/\\s/gm, '');\n}\n\n/**\n * Restores text nodes and separators into the DOM that were lost during SSR\n * serialization. The hydration process replaces empty text nodes and text\n * nodes that are immediately adjacent to other text nodes with comment nodes\n * that this method filters on to restore those missing nodes that the\n * hydration process is expecting to be present.\n *\n * @param node The app's root HTML Element\n */\nexport function processTextNodeMarkersBeforeHydration(node: HTMLElement) {\n  const doc = getDocument();\n  const commentNodesIterator = doc.createNodeIterator(node, NodeFilter.SHOW_COMMENT, {\n    acceptNode(node) {\n      const content = getTextNodeContent(node);\n      const isTextNodeMarker =\n          content === TextNodeMarker.EmptyNode || content === TextNodeMarker.Separator;\n      return isTextNodeMarker ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_REJECT;\n    }\n  });\n  let currentNode: Comment;\n  // We cannot modify the DOM while using the commentIterator,\n  // because it throws off the iterator state.\n  // So we collect all marker nodes first and then follow up with\n  // applying the changes to the DOM: either inserting an empty node\n  // or just removing the marker if it was used as a separator.\n  const nodes = [];\n  while (currentNode = commentNodesIterator.nextNode() as Comment) {\n    nodes.push(currentNode);\n  }\n  for (const node of nodes) {\n    if (node.textContent === TextNodeMarker.EmptyNode) {\n      node.replaceWith(doc.createTextNode(''));\n    } else {\n      node.remove();\n    }\n  }\n}\n\n/**\n * Internal type that represents a claimed node.\n * Only used in dev mode.\n */\ntype ClaimedNode = {\n  __claimed?: boolean;\n};\n\n/**\n * Marks a node as \"claimed\" by hydration process.\n * This is needed to make assessments in tests whether\n * the hydration process handled all nodes.\n */\nexport function markRNodeAsClaimedByHydration(node: RNode, checkIfAlreadyClaimed = true) {\n  if (!ngDevMode) {\n    throw new Error(\n        'Calling `markRNodeAsClaimedByHydration` in prod mode ' +\n        'is not supported and likely a mistake.');\n  }\n  if (checkIfAlreadyClaimed && isRNodeClaimedForHydration(node)) {\n    throw new Error('Trying to claim a node, which was claimed already.');\n  }\n  (node as ClaimedNode).__claimed = true;\n  ngDevMode.hydratedNodes++;\n}\n\nexport function isRNodeClaimedForHydration(node: RNode): boolean {\n  return !!(node as ClaimedNode).__claimed;\n}\n\nexport function setSegmentHead(\n    hydrationInfo: DehydratedView, index: number, node: RNode|null): void {\n  hydrationInfo.segmentHeads ??= {};\n  hydrationInfo.segmentHeads[index] = node;\n}\n\nexport function getSegmentHead(hydrationInfo: DehydratedView, index: number): RNode|null {\n  return hydrationInfo.segmentHeads?.[index] ?? null;\n}\n\n/**\n * Returns the size of an <ng-container>, using either the information\n * serialized in `ELEMENT_CONTAINERS` (element container size) or by\n * computing the sum of root nodes in all dehydrated views in a given\n * container (in case this `<ng-container>` was also used as a view\n * container host node, e.g. <ng-container *ngIf>).\n */\nexport function getNgContainerSize(hydrationInfo: DehydratedView, index: number): number|null {\n  const data = hydrationInfo.data;\n  let size = data[ELEMENT_CONTAINERS]?.[index] ?? null;\n  // If there is no serialized information available in the `ELEMENT_CONTAINERS` slot,\n  // check if we have info about view containers at this location (e.g.\n  // `<ng-container *ngIf>`) and use container size as a number of root nodes in this\n  // element container.\n  if (size === null && data[CONTAINERS]?.[index]) {\n    size = calcSerializedContainerSize(hydrationInfo, index);\n  }\n  return size;\n}\n\nexport function getSerializedContainerViews(\n    hydrationInfo: DehydratedView, index: number): SerializedContainerView[]|null {\n  return hydrationInfo.data[CONTAINERS]?.[index] ?? null;\n}\n\n/**\n * Computes the size of a serialized container (the number of root nodes)\n * by calculating the sum of root nodes in all dehydrated views in this container.\n */\nexport function calcSerializedContainerSize(hydrationInfo: DehydratedView, index: number): number {\n  const views = getSerializedContainerViews(hydrationInfo, index) ?? [];\n  let numNodes = 0;\n  for (let view of views) {\n    numNodes += view[NUM_ROOT_NODES];\n  }\n  return numNodes;\n}\n"]}
+/**
+ * Checks whether a node is annotated as "disconnected", i.e. not present
+ * in the DOM at serialization time. We should not attempt hydration for
+ * such nodes and instead, use a regular "creation mode".
+ */
+export function isDisconnectedNode(hydrationInfo, index) {
+    // Check if we are processing disconnected info for the first time.
+    if (typeof hydrationInfo.disconnectedNodes === 'undefined') {
+        const nodeIds = hydrationInfo.data[DISCONNECTED_NODES];
+        hydrationInfo.disconnectedNodes = nodeIds ? (new Set(nodeIds)) : null;
+    }
+    return !!hydrationInfo.disconnectedNodes?.has(index);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/hydration/utils.ts"],"names":[],"mappings":"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","sourcesContent":["\n/**\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 {Injector} from '../di/injector';\nimport {ViewRef} from '../linker/view_ref';\nimport {getDocument} from '../render3/interfaces/document';\nimport {RElement, RNode} from '../render3/interfaces/renderer_dom';\nimport {isRootView} from '../render3/interfaces/type_checks';\nimport {HEADER_OFFSET, LView, TVIEW, TViewType} from '../render3/interfaces/view';\nimport {makeStateKey, TransferState} from '../transfer_state';\nimport {assertDefined} from '../util/assert';\n\nimport {CONTAINERS, DehydratedView, DISCONNECTED_NODES, ELEMENT_CONTAINERS, MULTIPLIER, NUM_ROOT_NODES, SerializedContainerView, SerializedView} from './interfaces';\n\n/**\n * The name of the key used in the TransferState collection,\n * where hydration information is located.\n */\nconst TRANSFER_STATE_TOKEN_ID = '__ɵnghData__';\n\n/**\n * Lookup key used to reference DOM hydration data (ngh) in `TransferState`.\n */\nexport const NGH_DATA_KEY = makeStateKey<Array<SerializedView>>(TRANSFER_STATE_TOKEN_ID);\n\n/**\n * The name of the attribute that would be added to host component\n * nodes and contain a reference to a particular slot in transferred\n * state that contains the necessary hydration info for this component.\n */\nexport const NGH_ATTR_NAME = 'ngh';\n\nexport const enum TextNodeMarker {\n\n  /**\n   * The contents of the text comment added to nodes that would otherwise be\n   * empty when serialized by the server and passed to the client. The empty\n   * node is lost when the browser parses it otherwise. This comment node will\n   * be replaced during hydration in the client to restore the lost empty text\n   * node.\n   */\n  EmptyNode = 'ngetn',\n\n  /**\n   * The contents of the text comment added in the case of adjacent text nodes.\n   * When adjacent text nodes are serialized by the server and sent to the\n   * client, the browser loses reference to the amount of nodes and assumes\n   * just one text node. This separator is replaced during hydration to restore\n   * the proper separation and amount of text nodes that should be present.\n   */\n  Separator = 'ngtns',\n}\n\n/**\n * Reference to a function that reads `ngh` attribute value from a given RNode\n * and retrieves hydration information from the TransferState using that value\n * as an index. Returns `null` by default, when hydration is not enabled.\n *\n * @param rNode Component's host element.\n * @param injector Injector that this component has access to.\n */\nlet _retrieveHydrationInfoImpl: typeof retrieveHydrationInfoImpl =\n    (rNode: RElement, injector: Injector) => null;\n\nexport function retrieveHydrationInfoImpl(rNode: RElement, injector: Injector): DehydratedView|\n    null {\n  const nghAttrValue = rNode.getAttribute(NGH_ATTR_NAME);\n  if (nghAttrValue == null) return null;\n\n  let data: SerializedView = {};\n  // An element might have an empty `ngh` attribute value (e.g. `<comp ngh=\"\" />`),\n  // which means that no special annotations are required. Do not attempt to read\n  // from the TransferState in this case.\n  if (nghAttrValue !== '') {\n    const transferState = injector.get(TransferState, null, {optional: true});\n    if (transferState !== null) {\n      const nghData = transferState.get(NGH_DATA_KEY, []);\n\n      // The nghAttrValue is always a number referencing an index\n      // in the hydration TransferState data.\n      data = nghData[Number(nghAttrValue)];\n\n      // If the `ngh` attribute exists and has a non-empty value,\n      // the hydration info *must* be present in the TransferState.\n      // If there is no data for some reasons, this is an error.\n      ngDevMode && assertDefined(data, 'Unable to retrieve hydration info from the TransferState.');\n    }\n  }\n  const dehydratedView: DehydratedView = {\n    data,\n    firstChild: rNode.firstChild ?? null,\n  };\n  // The `ngh` attribute is cleared from the DOM node now\n  // that the data has been retrieved.\n  rNode.removeAttribute(NGH_ATTR_NAME);\n\n  // Note: don't check whether this node was claimed for hydration,\n  // because this node might've been previously claimed while processing\n  // template instructions.\n  ngDevMode && markRNodeAsClaimedByHydration(rNode, /* checkIfAlreadyClaimed */ false);\n  ngDevMode && ngDevMode.hydratedComponents++;\n\n  return dehydratedView;\n}\n\n/**\n * Sets the implementation for the `retrieveHydrationInfo` function.\n */\nexport function enableRetrieveHydrationInfoImpl() {\n  _retrieveHydrationInfoImpl = retrieveHydrationInfoImpl;\n}\n\n/**\n * Retrieves hydration info by reading the value from the `ngh` attribute\n * and accessing a corresponding slot in TransferState storage.\n */\nexport function retrieveHydrationInfo(rNode: RElement, injector: Injector): DehydratedView|null {\n  return _retrieveHydrationInfoImpl(rNode, injector);\n}\n\n/**\n * Retrieves an instance of a component LView from a given ViewRef.\n * Returns an instance of a component LView or `null` in case of an embedded view.\n */\nexport function getComponentLViewForHydration(viewRef: ViewRef): LView|null {\n  // Reading an internal field from `ViewRef` instance.\n  let lView = (viewRef as any)._lView as LView;\n  const tView = lView[TVIEW];\n  // A registered ViewRef might represent an instance of an\n  // embedded view, in which case we do not need to annotate it.\n  if (tView.type === TViewType.Embedded) {\n    return null;\n  }\n  // Check if it's a root view and if so, retrieve component's\n  // LView from the first slot after the header.\n  if (isRootView(lView)) {\n    lView = lView[HEADER_OFFSET];\n  }\n  return lView;\n}\n\nfunction getTextNodeContent(node: Node): string|undefined {\n  return node.textContent?.replace(/\\s/gm, '');\n}\n\n/**\n * Restores text nodes and separators into the DOM that were lost during SSR\n * serialization. The hydration process replaces empty text nodes and text\n * nodes that are immediately adjacent to other text nodes with comment nodes\n * that this method filters on to restore those missing nodes that the\n * hydration process is expecting to be present.\n *\n * @param node The app's root HTML Element\n */\nexport function processTextNodeMarkersBeforeHydration(node: HTMLElement) {\n  const doc = getDocument();\n  const commentNodesIterator = doc.createNodeIterator(node, NodeFilter.SHOW_COMMENT, {\n    acceptNode(node) {\n      const content = getTextNodeContent(node);\n      const isTextNodeMarker =\n          content === TextNodeMarker.EmptyNode || content === TextNodeMarker.Separator;\n      return isTextNodeMarker ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_REJECT;\n    }\n  });\n  let currentNode: Comment;\n  // We cannot modify the DOM while using the commentIterator,\n  // because it throws off the iterator state.\n  // So we collect all marker nodes first and then follow up with\n  // applying the changes to the DOM: either inserting an empty node\n  // or just removing the marker if it was used as a separator.\n  const nodes = [];\n  while (currentNode = commentNodesIterator.nextNode() as Comment) {\n    nodes.push(currentNode);\n  }\n  for (const node of nodes) {\n    if (node.textContent === TextNodeMarker.EmptyNode) {\n      node.replaceWith(doc.createTextNode(''));\n    } else {\n      node.remove();\n    }\n  }\n}\n\n/**\n * Internal type that represents a claimed node.\n * Only used in dev mode.\n */\ntype ClaimedNode = {\n  __claimed?: boolean;\n};\n\n/**\n * Marks a node as \"claimed\" by hydration process.\n * This is needed to make assessments in tests whether\n * the hydration process handled all nodes.\n */\nexport function markRNodeAsClaimedByHydration(node: RNode, checkIfAlreadyClaimed = true) {\n  if (!ngDevMode) {\n    throw new Error(\n        'Calling `markRNodeAsClaimedByHydration` in prod mode ' +\n        'is not supported and likely a mistake.');\n  }\n  if (checkIfAlreadyClaimed && isRNodeClaimedForHydration(node)) {\n    throw new Error('Trying to claim a node, which was claimed already.');\n  }\n  (node as ClaimedNode).__claimed = true;\n  ngDevMode.hydratedNodes++;\n}\n\nexport function isRNodeClaimedForHydration(node: RNode): boolean {\n  return !!(node as ClaimedNode).__claimed;\n}\n\nexport function setSegmentHead(\n    hydrationInfo: DehydratedView, index: number, node: RNode|null): void {\n  hydrationInfo.segmentHeads ??= {};\n  hydrationInfo.segmentHeads[index] = node;\n}\n\nexport function getSegmentHead(hydrationInfo: DehydratedView, index: number): RNode|null {\n  return hydrationInfo.segmentHeads?.[index] ?? null;\n}\n\n/**\n * Returns the size of an <ng-container>, using either the information\n * serialized in `ELEMENT_CONTAINERS` (element container size) or by\n * computing the sum of root nodes in all dehydrated views in a given\n * container (in case this `<ng-container>` was also used as a view\n * container host node, e.g. <ng-container *ngIf>).\n */\nexport function getNgContainerSize(hydrationInfo: DehydratedView, index: number): number|null {\n  const data = hydrationInfo.data;\n  let size = data[ELEMENT_CONTAINERS]?.[index] ?? null;\n  // If there is no serialized information available in the `ELEMENT_CONTAINERS` slot,\n  // check if we have info about view containers at this location (e.g.\n  // `<ng-container *ngIf>`) and use container size as a number of root nodes in this\n  // element container.\n  if (size === null && data[CONTAINERS]?.[index]) {\n    size = calcSerializedContainerSize(hydrationInfo, index);\n  }\n  return size;\n}\n\nexport function getSerializedContainerViews(\n    hydrationInfo: DehydratedView, index: number): SerializedContainerView[]|null {\n  return hydrationInfo.data[CONTAINERS]?.[index] ?? null;\n}\n\n/**\n * Computes the size of a serialized container (the number of root nodes)\n * by calculating the sum of root nodes in all dehydrated views in this container.\n */\nexport function calcSerializedContainerSize(hydrationInfo: DehydratedView, index: number): number {\n  const views = getSerializedContainerViews(hydrationInfo, index) ?? [];\n  let numNodes = 0;\n  for (let view of views) {\n    numNodes += view[NUM_ROOT_NODES] * (view[MULTIPLIER] ?? 1);\n  }\n  return numNodes;\n}\n\n/**\n * Checks whether a node is annotated as \"disconnected\", i.e. not present\n * in the DOM at serialization time. We should not attempt hydration for\n * such nodes and instead, use a regular \"creation mode\".\n */\nexport function isDisconnectedNode(hydrationInfo: DehydratedView, index: number): boolean {\n  // Check if we are processing disconnected info for the first time.\n  if (typeof hydrationInfo.disconnectedNodes === 'undefined') {\n    const nodeIds = hydrationInfo.data[DISCONNECTED_NODES];\n    hydrationInfo.disconnectedNodes = nodeIds ? (new Set(nodeIds)) : null;\n  }\n  return !!hydrationInfo.disconnectedNodes?.has(index);\n}\n"]}

package/esm2020/src/hydration/views.mjs

@@ -7,7 +7,7 @@
  */
 import { DEHYDRATED_VIEWS } from '../render3/interfaces/container';
 import { removeDehydratedViews } from './cleanup';
-import { NUM_ROOT_NODES, TEMPLATE_ID } from './interfaces';
+import { MULTIPLIER, NUM_ROOT_NODES, TEMPLATE_ID } from './interfaces';
 import { siblingAfter } from './node_lookup_utils';
 /**
  * Given a current DOM node and a serialized information about the views
@@ -17,20 +17,24 @@ import { siblingAfter } from './node_lookup_utils';
 export function locateDehydratedViewsInContainer(currentRNode, serializedViews) {
     const dehydratedViews = [];
     for (const serializedView of serializedViews) {
-        const view = {
-            data: serializedView,
-            firstChild: null,
-        };
-        if (serializedView[NUM_ROOT_NODES] > 0) {
-            // Keep reference to the first node in this view,
-            // so it can be accessed while invoking template instructions.
-            view.firstChild = currentRNode;
-            // Move over to the next node after this view, which can
-            // either be a first node of the next view or an anchor comment
-            // node after the last view in a container.
-            currentRNode = siblingAfter(serializedView[NUM_ROOT_NODES], currentRNode);
+        // Repeats a view multiple times as needed, based on the serialized information
+        // (for example, for *ngFor-produced views).
+        for (let i = 0; i < (serializedView[MULTIPLIER] ?? 1); i++) {
+            const view = {
+                data: serializedView,
+                firstChild: null,
+            };
+            if (serializedView[NUM_ROOT_NODES] > 0) {
+                // Keep reference to the first node in this view,
+                // so it can be accessed while invoking template instructions.
+                view.firstChild = currentRNode;
+                // Move over to the next node after this view, which can
+                // either be a first node of the next view or an anchor comment
+                // node after the last view in a container.
+                currentRNode = siblingAfter(serializedView[NUM_ROOT_NODES], currentRNode);
+            }
+            dehydratedViews.push(view);
         }
-        dehydratedViews.push(view);
     }
     return [currentRNode, dehydratedViews];
 }
@@ -77,4 +81,4 @@ export function enableFindMatchingDehydratedViewImpl() {
 export function findMatchingDehydratedView(lContainer, template) {
     return _findMatchingDehydratedViewImpl(lContainer, template);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/linker/destroy_ref.mjs

@@ -6,12 +6,14 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { getLView } from '../render3/state';
-import { storeLViewOnDestroy } from '../render3/util/view_utils';
+import { removeLViewOnDestroy, storeLViewOnDestroy } from '../render3/util/view_utils';
 /**
  * `DestroyRef` lets you set callbacks to run for any cleanup or destruction behavior.
  * The scope of this destruction depends on where `DestroyRef` is injected. If `DestroyRef`
  * is injected in a component or directive, the callbacks run when that component or
  * directive is destroyed. Otherwise the callbacks run when a corresponding injector is destroyed.
+ *
+ * @publicApi
  */
 class DestroyRef {
 }
@@ -33,9 +35,10 @@ class NodeInjectorDestroyRef extends DestroyRef {
     }
     onDestroy(callback) {
         storeLViewOnDestroy(this._lView, callback);
+        return () => removeLViewOnDestroy(this._lView, callback);
     }
 }
 function injectDestroyRef() {
     return new NodeInjectorDestroyRef(getLView());
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVzdHJveV9yZWYuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb3JlL3NyYy9saW5rZXIvZGVzdHJveV9yZWYudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBSUgsT0FBTyxFQUFDLFFBQVEsRUFBQyxNQUFNLGtCQUFrQixDQUFDO0FBQzFDLE9BQU8sRUFBQyxvQkFBb0IsRUFBRSxtQkFBbUIsRUFBQyxNQUFNLDRCQUE0QixDQUFDO0FBRXJGOzs7Ozs7O0dBT0c7QUFDSCxNQUFzQixVQUFVOztBQXdCOUI7OztHQUdHO0FBQ0ksNEJBQWlCLEdBQXFCLGdCQUFnQixDQUFDO0FBRTlEOzs7R0FHRztBQUNJLHdCQUFhLEdBQWtELENBQUMsUUFBUSxFQUFFLEVBQUUsQ0FBQyxRQUFRLENBQUM7U0FsQ3pFLFVBQVU7QUFxQ2hDLE1BQU0sc0JBQXVCLFNBQVEsVUFBVTtJQUM3QyxZQUFvQixNQUFhO1FBQy9CLEtBQUssRUFBRSxDQUFDO1FBRFUsV0FBTSxHQUFOLE1BQU0sQ0FBTztJQUVqQyxDQUFDO0lBRVEsU0FBUyxDQUFDLFFBQW9CO1FBQ3JDLG1CQUFtQixDQUFDLElBQUksQ0FBQyxNQUFNLEVBQUUsUUFBUSxDQUFDLENBQUM7UUFDM0MsT0FBTyxHQUFHLEVBQUUsQ0FBQyxvQkFBb0IsQ0FBQyxJQUFJLENBQUMsTUFBTSxFQUFFLFFBQVEsQ0FBQyxDQUFDO0lBQzNELENBQUM7Q0FDRjtBQUVELFNBQVMsZ0JBQWdCO0lBQ3ZCLE9BQU8sSUFBSSxzQkFBc0IsQ0FBQyxRQUFRLEVBQUUsQ0FBQyxDQUFDO0FBQ2hELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuaW1wb3J0IHtFbnZpcm9ubWVudEluamVjdG9yfSBmcm9tICcuLi9kaSc7XG5pbXBvcnQge0xWaWV3fSBmcm9tICcuLi9yZW5kZXIzL2ludGVyZmFjZXMvdmlldyc7XG5pbXBvcnQge2dldExWaWV3fSBmcm9tICcuLi9yZW5kZXIzL3N0YXRlJztcbmltcG9ydCB7cmVtb3ZlTFZpZXdPbkRlc3Ryb3ksIHN0b3JlTFZpZXdPbkRlc3Ryb3l9IGZyb20gJy4uL3JlbmRlcjMvdXRpbC92aWV3X3V0aWxzJztcblxuLyoqXG4gKiBgRGVzdHJveVJlZmAgbGV0cyB5b3Ugc2V0IGNhbGxiYWNrcyB0byBydW4gZm9yIGFueSBjbGVhbnVwIG9yIGRlc3RydWN0aW9uIGJlaGF2aW9yLlxuICogVGhlIHNjb3BlIG9mIHRoaXMgZGVzdHJ1Y3Rpb24gZGVwZW5kcyBvbiB3aGVyZSBgRGVzdHJveVJlZmAgaXMgaW5qZWN0ZWQuIElmIGBEZXN0cm95UmVmYFxuICogaXMgaW5qZWN0ZWQgaW4gYSBjb21wb25lbnQgb3IgZGlyZWN0aXZlLCB0aGUgY2FsbGJhY2tzIHJ1biB3aGVuIHRoYXQgY29tcG9uZW50IG9yXG4gKiBkaXJlY3RpdmUgaXMgZGVzdHJveWVkLiBPdGhlcndpc2UgdGhlIGNhbGxiYWNrcyBydW4gd2hlbiBhIGNvcnJlc3BvbmRpbmcgaW5qZWN0b3IgaXMgZGVzdHJveWVkLlxuICpcbiAqIEBwdWJsaWNBcGlcbiAqL1xuZXhwb3J0IGFic3RyYWN0IGNsYXNzIERlc3Ryb3lSZWYge1xuICAvLyBIZXJlIHRoZSBgRGVzdHJveVJlZmAgYWN0cyBwcmltYXJpbHkgYXMgYSBESSB0b2tlbi4gVGhlcmUgYXJlIChjdXJyZW50bHkpIHR5cGVzIG9mIG9iamVjdHMgdGhhdFxuICAvLyBjYW4gYmUgcmV0dXJuZWQgZnJvbSB0aGUgaW5qZWN0b3Igd2hlbiBhc2tpbmcgZm9yIHRoaXMgdG9rZW46XG4gIC8vIC0gYE5vZGVJbmplY3RvckRlc3Ryb3lSZWZgIHdoZW4gcmV0cmlldmVkIGZyb20gYSBub2RlIGluamVjdG9yO1xuICAvLyAtIGBFbnZpcm9ubWVudEluamVjdG9yYCB3aGVuIHJldHJpZXZlZCBmcm9tIGFuIGVudmlyb25tZW50IGluamVjdG9yXG5cbiAgLyoqXG4gICAqIFJlZ2lzdGVycyBhIGRlc3Ryb3kgY2FsbGJhY2sgaW4gYSBnaXZlbiBsaWZlY3ljbGUgc2NvcGUuICBSZXR1cm5zIGEgY2xlYW51cCBmdW5jdGlvbiB0aGF0IGNhblxuICAgKiBiZSBpbnZva2VkIHRvIHVucmVnaXN0ZXIgdGhlIGNhbGxiYWNrLlxuICAgKlxuICAgKiBAdXNhZ2VOb3Rlc1xuICAgKiAjIyMgRXhhbXBsZVxuICAgKiBgYGB0eXBlc2NyaXB0XG4gICAqIGNvbnN0IGRlc3Ryb3lSZWYgPSBpbmplY3QoRGVzdHJveVJlZik7XG4gICAqXG4gICAqIC8vIHJlZ2lzdGVyIGEgZGVzdHJveSBjYWxsYmFja1xuICAgKiBjb25zdCB1bnJlZ2lzdGVyRm4gPSBkZXN0cm95UmVmLm9uRGVzdHJveSgoKSA9PiBkb1NvbWV0aGluZ09uRGVzdHJveSgpKTtcbiAgICpcbiAgICogLy8gc3RvcCB0aGUgZGVzdHJveSBjYWxsYmFjayBmcm9tIGV4ZWN1dGluZyBpZiBuZWVkZWRcbiAgICogdW5yZWdpc3RlckZuKCk7XG4gICAqIGBgYFxuICAgKi9cbiAgYWJzdHJhY3Qgb25EZXN0cm95KGNhbGxiYWNrOiAoKSA9PiB2b2lkKTogKCkgPT4gdm9pZDtcblxuICAvKipcbiAgICogQGludGVybmFsXG4gICAqIEBub2NvbGxhcHNlXG4gICAqL1xuICBzdGF0aWMgX19OR19FTEVNRU5UX0lEX186ICgpID0+IERlc3Ryb3lSZWYgPSBpbmplY3REZXN0cm95UmVmO1xuXG4gIC8qKlxuICAgKiBAaW50ZXJuYWxcbiAgICogQG5vY29sbGFwc2VcbiAgICovXG4gIHN0YXRpYyBfX05HX0VOVl9JRF9fOiAoaW5qZWN0b3I6IEVudmlyb25tZW50SW5qZWN0b3IpID0+IERlc3Ryb3lSZWYgPSAoaW5qZWN0b3IpID0+IGluamVjdG9yO1xufVxuXG5jbGFzcyBOb2RlSW5qZWN0b3JEZXN0cm95UmVmIGV4dGVuZHMgRGVzdHJveVJlZiB7XG4gIGNvbnN0cnVjdG9yKHByaXZhdGUgX2xWaWV3OiBMVmlldykge1xuICAgIHN1cGVyKCk7XG4gIH1cblxuICBvdmVycmlkZSBvbkRlc3Ryb3koY2FsbGJhY2s6ICgpID0+IHZvaWQpOiAoKSA9PiB2b2lkIHtcbiAgICBzdG9yZUxWaWV3T25EZXN0cm95KHRoaXMuX2xWaWV3LCBjYWxsYmFjayk7XG4gICAgcmV0dXJuICgpID0+IHJlbW92ZUxWaWV3T25EZXN0cm95KHRoaXMuX2xWaWV3LCBjYWxsYmFjayk7XG4gIH1cbn1cblxuZnVuY3Rpb24gaW5qZWN0RGVzdHJveVJlZigpOiBEZXN0cm95UmVmIHtcbiAgcmV0dXJuIG5ldyBOb2RlSW5qZWN0b3JEZXN0cm95UmVmKGdldExWaWV3KCkpO1xufVxuIl19