@angular/core 17.0.0-next.5 → 17.0.0-next.7

package/esm2022/src/render3/instructions/defer.mjs

@@ -5,21 +5,25 @@
  * 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 { InjectionToken } from '../../di';
+import { inject, InjectionToken, ɵɵdefineInjectable } from '../../di';
 import { findMatchingDehydratedView } from '../../hydration/views';
-import { populateDehydratedViewsInContainer } from '../../linker/view_container_ref';
-import { assertDefined, assertEqual, throwError } from '../../util/assert';
-import { assertIndexInDeclRange, assertLContainer, assertTNodeForLView } from '../assert';
+import { populateDehydratedViewsInLContainer } from '../../linker/view_container_ref';
+import { arrayInsert2, arraySplice } from '../../util/array_utils';
+import { assertDefined, assertElement, assertEqual, throwError } from '../../util/assert';
+import { NgZone } from '../../zone';
+import { afterRender } from '../after_render_hooks';
+import { assertIndexInDeclRange, assertLContainer, assertLView, assertTNodeForLView } from '../assert';
 import { bindingUpdated } from '../bindings';
 import { getComponentDef, getDirectiveDef, getPipeDef } from '../definition';
 import { CONTAINER_HEADER_OFFSET } from '../interfaces/container';
 import { DEFER_BLOCK_STATE, DeferBlockBehavior, DeferBlockInternalState, DeferBlockState, DeferDependenciesLoadingState } from '../interfaces/defer';
 import { isDestroyed, isLContainer, isLView } from '../interfaces/type_checks';
-import { HEADER_OFFSET, INJECTOR, PARENT, TVIEW } from '../interfaces/view';
+import { FLAGS, HEADER_OFFSET, INJECTOR, PARENT, TVIEW } from '../interfaces/view';
 import { getCurrentTNode, getLView, getSelectedTNode, getTView, nextBindingIndex } from '../state';
 import { isPlatformBrowser } from '../util/misc_utils';
-import { getConstant, getTNode, removeLViewOnDestroy, storeLViewOnDestroy } from '../util/view_utils';
+import { getConstant, getNativeByIndex, getTNode, removeLViewOnDestroy, storeLViewOnDestroy, walkUpViews } from '../util/view_utils';
 import { addLViewToLContainer, createAndRenderEmbeddedLView, removeLViewFromLContainer, shouldAddViewToDom } from '../view_manipulation';
+import { onHover, onInteraction, onViewport } from './defer_events';
 import { ɵɵtemplate } from './template';
 /**
  * Returns whether defer blocks should be triggered.
@@ -28,31 +32,25 @@ import { ɵɵtemplate } from './template';
  * only placeholder content is rendered (if provided).
  */
 function shouldTriggerDeferBlock(injector) {
-    const config = injector.get(DEFER_BLOCK_CONFIG, { optional: true });
+    const config = injector.get(DEFER_BLOCK_CONFIG, null, { optional: true });
     if (config?.behavior === DeferBlockBehavior.Manual) {
         return false;
     }
     return isPlatformBrowser(injector);
 }
 /**
- * Shims for the `requestIdleCallback` and `cancelIdleCallback` functions for environments
- * where those functions are not available (e.g. Node.js).
- */
-const _requestIdleCallback = typeof requestIdleCallback !== 'undefined' ? requestIdleCallback : setTimeout;
-const _cancelIdleCallback = typeof requestIdleCallback !== 'undefined' ? cancelIdleCallback : clearTimeout;
-/**
- * Creates runtime data structures for `{#defer}` blocks.
+ * Creates runtime data structures for defer blocks.
  *
  * @param index Index of the `defer` instruction.
  * @param primaryTmplIndex Index of the template with the primary block content.
  * @param dependencyResolverFn Function that contains dependencies for this defer block.
- * @param loadingTmplIndex Index of the template with the `{:loading}` block content.
- * @param placeholderTmplIndex Index of the template with the `{:placeholder}` block content.
- * @param errorTmplIndex Index of the template with the `{:error}` block content.
- * @param loadingConfigIndex Index in the constants array of the configuration of the `{:loading}`.
+ * @param loadingTmplIndex Index of the template with the loading block content.
+ * @param placeholderTmplIndex Index of the template with the placeholder block content.
+ * @param errorTmplIndex Index of the template with the error block content.
+ * @param loadingConfigIndex Index in the constants array of the configuration of the loading.
  *     block.
- * @param placeholderConfigIndexIndex in the constants array of the configuration of the
- *     `{:placeholder}` block.
+ * @param placeholderConfigIndex Index in the constants array of the configuration of the
+ *     placeholder block.
  *
  * @codeGenApi
  */
@@ -80,10 +78,12 @@ export function ɵɵdefer(index, primaryTmplIndex, dependencyResolverFn, loading
         };
         setTDeferBlockDetails(tView, adjustedIndex, deferBlockConfig);
     }
-    // Lookup dehydrated views that belong to this LContainer.
-    // In client-only mode, this operation is noop.
+    const tNode = getCurrentTNode();
     const lContainer = lView[adjustedIndex];
-    populateDehydratedViewsInContainer(lContainer);
+    // If hydration is enabled, looks up dehydrated views in the DOM
+    // using hydration annotation info and stores those views on LContainer.
+    // In client-only mode, this function is a noop.
+    populateDehydratedViewsInLContainer(lContainer, tNode, lView);
     // Init instance-specific defer details and store it.
     const lDetails = [];
     lDetails[DEFER_BLOCK_STATE] = DeferBlockInternalState.Initial;
@@ -134,122 +134,331 @@ export function ɵɵdeferPrefetchWhen(rawValue) {
     }
 }
 /**
- * Sets up handlers that represent `on idle` deferred trigger.
+ * Sets up logic to handle the `on idle` deferred trigger.
  * @codeGenApi
  */
 export function ɵɵdeferOnIdle() {
-    const lView = getLView();
-    const tNode = getCurrentTNode();
-    renderPlaceholder(lView, tNode);
-    // Note: we pass an `lView` as a second argument to cancel an `idle`
-    // callback in case an LView got destroyed before an `idle` callback
-    // is invoked.
-    onIdle(() => triggerDeferBlock(lView, tNode), lView);
+    scheduleDelayedTrigger(onIdle);
 }
 /**
- * Creates runtime data structures for the `prefetch on idle` deferred trigger.
+ * Sets up logic to handle the `prefetch on idle` deferred trigger.
  * @codeGenApi
  */
 export function ɵɵdeferPrefetchOnIdle() {
+    scheduleDelayedPrefetching(onIdle, 0 /* DeferBlockTriggers.OnIdle */);
+}
+/**
+ * Sets up logic to handle the `on immediate` deferred trigger.
+ * @codeGenApi
+ */
+export function ɵɵdeferOnImmediate() {
     const lView = getLView();
     const tNode = getCurrentTNode();
     const tView = lView[TVIEW];
     const tDetails = getTDeferBlockDetails(tView, tNode);
-    if (tDetails.loadingState === DeferDependenciesLoadingState.NOT_STARTED) {
-        // Set loading to the scheduled state, so that we don't register it again.
-        tDetails.loadingState = DeferDependenciesLoadingState.SCHEDULED;
-        // In case of prefetching, we intentionally avoid cancelling prefetching if
-        // an underlying LView get destroyed (thus passing `null` as a second argument),
-        // because there might be other LViews (that represent embedded views) that
-        // depend on resource loading.
-        onIdle(() => triggerPrefetching(tDetails, lView), null /* LView */);
+    // Render placeholder block only if loading template is not present
+    // to avoid content flickering, since it would be immediately replaced
+    // by the loading block.
+    if (tDetails.loadingTmplIndex === null) {
+        renderPlaceholder(lView, tNode);
     }
+    triggerDeferBlock(lView, tNode);
 }
 /**
- * Creates runtime data structures for the `on immediate` deferred trigger.
+ * Sets up logic to handle the `prefetch on immediate` deferred trigger.
  * @codeGenApi
  */
-export function ɵɵdeferOnImmediate() { } // TODO: implement runtime logic.
-/**
- * Creates runtime data structures for the `prefetch on immediate` deferred trigger.
- * @codeGenApi
- */
-export function ɵɵdeferPrefetchOnImmediate() { } // TODO: implement runtime logic.
+export function ɵɵdeferPrefetchOnImmediate() {
+    const lView = getLView();
+    const tNode = getCurrentTNode();
+    const tView = lView[TVIEW];
+    const tDetails = getTDeferBlockDetails(tView, tNode);
+    if (tDetails.loadingState === DeferDependenciesLoadingState.NOT_STARTED) {
+        triggerResourceLoading(tDetails, lView);
+    }
+}
 /**
  * Creates runtime data structures for the `on timer` deferred trigger.
  * @param delay Amount of time to wait before loading the content.
  * @codeGenApi
  */
-export function ɵɵdeferOnTimer(delay) { } // TODO: implement runtime logic.
+export function ɵɵdeferOnTimer(delay) {
+    scheduleDelayedTrigger(onTimer(delay));
+}
 /**
  * Creates runtime data structures for the `prefetch on timer` deferred trigger.
  * @param delay Amount of time to wait before prefetching the content.
  * @codeGenApi
  */
-export function ɵɵdeferPrefetchOnTimer(delay) { } // TODO: implement runtime logic.
+export function ɵɵdeferPrefetchOnTimer(delay) {
+    scheduleDelayedPrefetching(onTimer(delay), 1 /* DeferBlockTriggers.OnTimer */);
+}
 /**
  * Creates runtime data structures for the `on hover` deferred trigger.
+ * @param triggerIndex Index at which to find the trigger element.
+ * @param walkUpTimes Number of times to walk up/down the tree hierarchy to find the trigger.
  * @codeGenApi
  */
-export function ɵɵdeferOnHover() { } // TODO: implement runtime logic.
+export function ɵɵdeferOnHover(triggerIndex, walkUpTimes) {
+    const lView = getLView();
+    const tNode = getCurrentTNode();
+    renderPlaceholder(lView, tNode);
+    registerDomTrigger(lView, tNode, triggerIndex, walkUpTimes, onHover, () => triggerDeferBlock(lView, tNode));
+}
 /**
  * Creates runtime data structures for the `prefetch on hover` deferred trigger.
+ * @param triggerIndex Index at which to find the trigger element.
+ * @param walkUpTimes Number of times to walk up/down the tree hierarchy to find the trigger.
  * @codeGenApi
  */
-export function ɵɵdeferPrefetchOnHover() { } // TODO: implement runtime logic.
+export function ɵɵdeferPrefetchOnHover(triggerIndex, walkUpTimes) {
+    const lView = getLView();
+    const tNode = getCurrentTNode();
+    const tView = lView[TVIEW];
+    const tDetails = getTDeferBlockDetails(tView, tNode);
+    if (tDetails.loadingState === DeferDependenciesLoadingState.NOT_STARTED) {
+        registerDomTrigger(lView, tNode, triggerIndex, walkUpTimes, onHover, () => triggerPrefetching(tDetails, lView));
+    }
+}
 /**
  * Creates runtime data structures for the `on interaction` deferred trigger.
- * @param target Optional element on which to listen for hover events.
+ * @param triggerIndex Index at which to find the trigger element.
+ * @param walkUpTimes Number of times to walk up/down the tree hierarchy to find the trigger.
  * @codeGenApi
  */
-export function ɵɵdeferOnInteraction(target) { } // TODO: implement runtime logic.
+export function ɵɵdeferOnInteraction(triggerIndex, walkUpTimes) {
+    const lView = getLView();
+    const tNode = getCurrentTNode();
+    renderPlaceholder(lView, tNode);
+    registerDomTrigger(lView, tNode, triggerIndex, walkUpTimes, onInteraction, () => triggerDeferBlock(lView, tNode));
+}
 /**
  * Creates runtime data structures for the `prefetch on interaction` deferred trigger.
- * @param target Optional element on which to listen for hover events.
+ * @param triggerIndex Index at which to find the trigger element.
+ * @param walkUpTimes Number of times to walk up/down the tree hierarchy to find the trigger.
  * @codeGenApi
  */
-export function ɵɵdeferPrefetchOnInteraction(target) { } // TODO: implement runtime logic.
+export function ɵɵdeferPrefetchOnInteraction(triggerIndex, walkUpTimes) {
+    const lView = getLView();
+    const tNode = getCurrentTNode();
+    const tView = lView[TVIEW];
+    const tDetails = getTDeferBlockDetails(tView, tNode);
+    if (tDetails.loadingState === DeferDependenciesLoadingState.NOT_STARTED) {
+        registerDomTrigger(lView, tNode, triggerIndex, walkUpTimes, onInteraction, () => triggerPrefetching(tDetails, lView));
+    }
+}
 /**
  * Creates runtime data structures for the `on viewport` deferred trigger.
- * @param target Optional element on which to listen for hover events.
+ * @param triggerIndex Index at which to find the trigger element.
+ * @param walkUpTimes Number of times to walk up/down the tree hierarchy to find the trigger.
  * @codeGenApi
  */
-export function ɵɵdeferOnViewport(target) { } // TODO: implement runtime logic.
+export function ɵɵdeferOnViewport(triggerIndex, walkUpTimes) {
+    const lView = getLView();
+    const tNode = getCurrentTNode();
+    renderPlaceholder(lView, tNode);
+    registerDomTrigger(lView, tNode, triggerIndex, walkUpTimes, onViewport, () => triggerDeferBlock(lView, tNode));
+}
 /**
  * Creates runtime data structures for the `prefetch on viewport` deferred trigger.
- * @param target Optional element on which to listen for hover events.
+ * @param triggerIndex Index at which to find the trigger element.
+ * @param walkUpTimes Number of times to walk up/down the tree hierarchy to find the trigger.
  * @codeGenApi
  */
-export function ɵɵdeferPrefetchOnViewport(target) { } // TODO: implement runtime logic.
+export function ɵɵdeferPrefetchOnViewport(triggerIndex, walkUpTimes) {
+    const lView = getLView();
+    const tNode = getCurrentTNode();
+    const tView = lView[TVIEW];
+    const tDetails = getTDeferBlockDetails(tView, tNode);
+    if (tDetails.loadingState === DeferDependenciesLoadingState.NOT_STARTED) {
+        registerDomTrigger(lView, tNode, triggerIndex, walkUpTimes, onViewport, () => triggerPrefetching(tDetails, lView));
+    }
+}
 /********** Helper functions **********/
+/**
+ * Schedules triggering of a defer block for `on idle` and `on timer` conditions.
+ */
+function scheduleDelayedTrigger(scheduleFn) {
+    const lView = getLView();
+    const tNode = getCurrentTNode();
+    renderPlaceholder(lView, tNode);
+    scheduleFn(() => triggerDeferBlock(lView, tNode), lView, true /* withLViewCleanup */);
+}
+/**
+ * Schedules prefetching for `on idle` and `on timer` triggers.
+ *
+ * @param scheduleFn A function that does the scheduling.
+ * @param trigger A trigger that initiated scheduling.
+ */
+function scheduleDelayedPrefetching(scheduleFn, trigger) {
+    const lView = getLView();
+    const tNode = getCurrentTNode();
+    const tView = lView[TVIEW];
+    const tDetails = getTDeferBlockDetails(tView, tNode);
+    if (tDetails.loadingState === DeferDependenciesLoadingState.NOT_STARTED) {
+        // Prevent scheduling more than one prefetch init call
+        // for each defer block. For this reason we use only a trigger
+        // identifier in a key, so all instances would use the same key.
+        const key = String(trigger);
+        const injector = lView[INJECTOR];
+        const manager = injector.get(DeferBlockCleanupManager);
+        if (!manager.has(tDetails, key)) {
+            // In case of prefetching, we intentionally avoid cancelling resource loading if
+            // an underlying LView get destroyed (thus passing `null` as a second argument),
+            // because there might be other LViews (that represent embedded views) that
+            // depend on resource loading.
+            const prefetch = () => triggerPrefetching(tDetails, lView);
+            const cleanupFn = scheduleFn(prefetch, lView, false /* withLViewCleanup */);
+            registerTDetailsCleanup(injector, tDetails, key, cleanupFn);
+        }
+    }
+}
+/**
+ * Helper function to get the LView in which a deferred block's trigger is rendered.
+ * @param deferredHostLView LView in which the deferred block is defined.
+ * @param deferredTNode TNode defining the deferred block.
+ * @param walkUpTimes Number of times to go up in the view hierarchy to find the trigger's view.
+ *   A negative value means that the trigger is inside the block's placeholder, while an undefined
+ *   value means that the trigger is in the same LView as the deferred block.
+ */
+function getTriggerLView(deferredHostLView, deferredTNode, walkUpTimes) {
+    // The trigger is in the same view, we don't need to traverse.
+    if (walkUpTimes == null) {
+        return deferredHostLView;
+    }
+    // A positive value or zero means that the trigger is in a parent view.
+    if (walkUpTimes >= 0) {
+        return walkUpViews(walkUpTimes, deferredHostLView);
+    }
+    // If the value is negative, it means that the trigger is inside the placeholder.
+    const deferredContainer = deferredHostLView[deferredTNode.index];
+    ngDevMode && assertLContainer(deferredContainer);
+    const triggerLView = deferredContainer[CONTAINER_HEADER_OFFSET] ?? null;
+    // We need to null check, because the placeholder might not have been rendered yet.
+    if (ngDevMode && triggerLView !== null) {
+        const lDetails = getLDeferBlockDetails(deferredHostLView, deferredTNode);
+        const renderedState = lDetails[DEFER_BLOCK_STATE];
+        assertEqual(renderedState, DeferBlockState.Placeholder, 'Expected a placeholder to be rendered in this defer block.');
+        assertLView(triggerLView);
+    }
+    return triggerLView;
+}
+/**
+ * Gets the element that a deferred block's trigger is pointing to.
+ * @param triggerLView LView in which the trigger is defined.
+ * @param triggerIndex Index at which the trigger element should've been rendered.
+ */
+function getTriggerElement(triggerLView, triggerIndex) {
+    const element = getNativeByIndex(HEADER_OFFSET + triggerIndex, triggerLView);
+    ngDevMode && assertElement(element);
+    return element;
+}
+/**
+ * Registers a DOM-node based trigger.
+ * @param initialLView LView in which the defer block is rendered.
+ * @param tNode TNode representing the defer block.
+ * @param triggerIndex Index at which to find the trigger element.
+ * @param walkUpTimes Number of times to go up/down in the view hierarchy to find the trigger.
+ * @param registerFn Function that will register the DOM events.
+ * @param callback Callback to be invoked when the trigger receives the event that should render
+ *     the deferred block.
+ */
+function registerDomTrigger(initialLView, tNode, triggerIndex, walkUpTimes, registerFn, callback) {
+    const injector = initialLView[INJECTOR];
+    // Assumption: the `afterRender` reference should be destroyed
+    // automatically so we don't need to keep track of it.
+    const afterRenderRef = afterRender(() => {
+        const lDetails = getLDeferBlockDetails(initialLView, tNode);
+        const renderedState = lDetails[DEFER_BLOCK_STATE];
+        // If the block was loaded before the trigger was resolved, we don't need to do anything.
+        if (renderedState !== DeferBlockInternalState.Initial &&
+            renderedState !== DeferBlockState.Placeholder) {
+            afterRenderRef.destroy();
+            return;
+        }
+        const triggerLView = getTriggerLView(initialLView, tNode, walkUpTimes);
+        // Keep polling until we resolve the trigger's LView.
+        // `afterRender` should stop automatically if the view is destroyed.
+        if (!triggerLView) {
+            return;
+        }
+        // It's possible that the trigger's view was destroyed before we resolved the trigger element.
+        if (triggerLView[FLAGS] & 256 /* LViewFlags.Destroyed */) {
+            afterRenderRef.destroy();
+            return;
+        }
+        // TODO: add integration with `DeferBlockCleanupManager`.
+        const element = getTriggerElement(triggerLView, triggerIndex);
+        const cleanup = registerFn(element, () => {
+            callback();
+            removeLViewOnDestroy(triggerLView, cleanup);
+            if (initialLView !== triggerLView) {
+                removeLViewOnDestroy(initialLView, cleanup);
+            }
+            cleanup();
+        }, injector);
+        afterRenderRef.destroy();
+        storeLViewOnDestroy(triggerLView, cleanup);
+        // Since the trigger and deferred block might be in different
+        // views, we have to register the callback in both locations.
+        if (initialLView !== triggerLView) {
+            storeLViewOnDestroy(initialLView, cleanup);
+        }
+    }, { injector });
+}
 /**
  * Helper function to schedule a callback to be invoked when a browser becomes idle.
  *
  * @param callback A function to be invoked when a browser becomes idle.
- * @param lView An optional LView that hosts an instance of a defer block. LView is
- *    used to register a cleanup callback in case that LView got destroyed before
- *    callback was invoked. In this case, an `idle` callback is never invoked. This is
- *    helpful for cases when a defer block has scheduled rendering, but an underlying
- *    LView got destroyed prior to th block rendering.
- */
-function onIdle(callback, lView) {
-    let id;
-    const removeIdleCallback = () => _cancelIdleCallback(id);
-    id = _requestIdleCallback(() => {
-        removeIdleCallback();
-        if (lView !== null) {
-            // The idle callback is invoked, we no longer need
-            // to retain a cleanup callback in an LView.
-            removeLViewOnDestroy(lView, removeIdleCallback);
-        }
+ * @param lView LView that hosts an instance of a defer block.
+ * @param withLViewCleanup A flag that indicates whether a scheduled callback
+ *           should be cancelled in case an LView is destroyed before a callback
+ *           was invoked.
+ */
+function onIdle(callback, lView, withLViewCleanup) {
+    const injector = lView[INJECTOR];
+    const scheduler = injector.get(OnIdleScheduler);
+    const cleanupFn = () => scheduler.remove(callback);
+    const wrappedCallback = withLViewCleanup ? wrapWithLViewCleanup(callback, lView, cleanupFn) : callback;
+    scheduler.add(wrappedCallback);
+    return cleanupFn;
+}
+/**
+ * Returns a function that captures a provided delay.
+ * Invoking the returned function schedules a trigger.
+ */
+function onTimer(delay) {
+    return (callback, lView, withLViewCleanup) => scheduleTimerTrigger(delay, callback, lView, withLViewCleanup);
+}
+/**
+ * Schedules a callback to be invoked after a given timeout.
+ *
+ * @param delay A number of ms to wait until firing a callback.
+ * @param callback A function to be invoked after a timeout.
+ * @param lView LView that hosts an instance of a defer block.
+ * @param withLViewCleanup A flag that indicates whether a scheduled callback
+ *           should be cancelled in case an LView is destroyed before a callback
+ *           was invoked.
+ */
+function scheduleTimerTrigger(delay, callback, lView, withLViewCleanup) {
+    const injector = lView[INJECTOR];
+    const scheduler = injector.get(TimerScheduler);
+    const cleanupFn = () => scheduler.remove(callback);
+    const wrappedCallback = withLViewCleanup ? wrapWithLViewCleanup(callback, lView, cleanupFn) : callback;
+    scheduler.add(delay, wrappedCallback);
+    return cleanupFn;
+}
+/**
+ * Wraps a given callback into a logic that registers a cleanup function
+ * in the LView cleanup slot, to be invoked when an LView is destroyed.
+ */
+function wrapWithLViewCleanup(callback, lView, cleanup) {
+    const wrappedCallback = () => {
         callback();
-    });
-    if (lView !== null) {
-        // Store a cleanup function on LView, so that we cancel idle
-        // callback in case this LView is destroyed before a callback
-        // is invoked.
-        storeLViewOnDestroy(lView, removeIdleCallback);
-    }
+        removeLViewOnDestroy(lView, cleanup);
+    };
+    storeLViewOnDestroy(lView, cleanup);
+    return wrappedCallback;
 }
 /**
  * Calculates a data slot index for defer block info (either static or
@@ -332,7 +541,7 @@ export function renderDeferBlockState(newState, tNode, lContainer) {
         const adjustedIndex = stateTmplIndex + HEADER_OFFSET;
         const tNode = getTNode(hostTView, adjustedIndex);
         // There is only 1 view that can be present in an LContainer that
-        // represents a `{#defer}` block, so always refer to the first one.
+        // represents a defer block, so always refer to the first one.
         const viewIndex = 0;
         removeLViewFromLContainer(lContainer, viewIndex);
         const dehydratedView = findMatchingDehydratedView(lContainer, tNode.tView.ssrId);
@@ -360,8 +569,7 @@ export function triggerPrefetching(tDetails, lView) {
 export function triggerResourceLoading(tDetails, lView) {
     const injector = lView[INJECTOR];
     const tView = lView[TVIEW];
-    if (tDetails.loadingState !== DeferDependenciesLoadingState.NOT_STARTED &&
-        tDetails.loadingState !== DeferDependenciesLoadingState.SCHEDULED) {
+    if (tDetails.loadingState !== DeferDependenciesLoadingState.NOT_STARTED) {
         // If the loading status is different from initial one, it means that
         // the loading of dependencies is in progress and there is nothing to do
         // in this function. All details can be obtained from the `tDetails` object.
@@ -376,7 +584,7 @@ export function triggerResourceLoading(tDetails, lView) {
         deferDependencyInterceptor.intercept(tDetails.dependencyResolverFn) :
         tDetails.dependencyResolverFn;
     // The `dependenciesFn` might be `null` when all dependencies within
-    // a given `{#defer}` block were eagerly references elsewhere in a file,
+    // a given defer block were eagerly references elsewhere in a file,
     // thus no dynamic `import()`s were produced.
     if (!dependenciesFn) {
         tDetails.loadingPromise = Promise.resolve().then(() => {
@@ -384,6 +592,9 @@ export function triggerResourceLoading(tDetails, lView) {
         });
         return;
     }
+    // Defer block may have multiple prefetch triggers. Once the loading
+    // starts, invoke all clean functions, since they are no longer needed.
+    invokeTDetailsCleanup(injector, tDetails);
     // Start downloading of defer block dependencies.
     tDetails.loadingPromise = Promise.allSettled(dependenciesFn()).then(results => {
         let failed = false;
@@ -418,24 +629,36 @@ export function triggerResourceLoading(tDetails, lView) {
             // Update directive and pipe registries to add newly downloaded dependencies.
             const primaryBlockTView = primaryBlockTNode.tView;
             if (directiveDefs.length > 0) {
-                primaryBlockTView.directiveRegistry = primaryBlockTView.directiveRegistry ?
-                    [...primaryBlockTView.directiveRegistry, ...directiveDefs] :
-                    directiveDefs;
+                primaryBlockTView.directiveRegistry =
+                    addDepsToRegistry(primaryBlockTView.directiveRegistry, directiveDefs);
             }
             if (pipeDefs.length > 0) {
-                primaryBlockTView.pipeRegistry = primaryBlockTView.pipeRegistry ?
-                    [...primaryBlockTView.pipeRegistry, ...pipeDefs] :
-                    pipeDefs;
+                primaryBlockTView.pipeRegistry =
+                    addDepsToRegistry(primaryBlockTView.pipeRegistry, pipeDefs);
             }
         }
     });
 }
-/** Utility function to render `{:placeholder}` content (if present) */
+/**
+ * Adds downloaded dependencies into a directive or a pipe registry,
+ * making sure that a dependency doesn't yet exist in the registry.
+ */
+function addDepsToRegistry(currentDeps, newDeps) {
+    if (!currentDeps || currentDeps.length === 0) {
+        return newDeps;
+    }
+    const currentDepSet = new Set(currentDeps);
+    for (const dep of newDeps) {
+        currentDepSet.add(dep);
+    }
+    // If `currentDeps` is the same length, there were no new deps and can
+    // return the original array.
+    return (currentDeps.length === currentDepSet.size) ? currentDeps : Array.from(currentDepSet);
+}
+/** Utility function to render placeholder content (if present) */
 function renderPlaceholder(lView, tNode) {
-    const tView = lView[TVIEW];
     const lContainer = lView[tNode.index];
     ngDevMode && assertLContainer(lContainer);
-    const tDetails = getTDeferBlockDetails(tView, tNode);
     renderDeferBlockState(DeferBlockState.Placeholder, tNode, lContainer);
 }
 /**
@@ -482,7 +705,6 @@ function triggerDeferBlock(lView, tNode) {
     renderDeferBlockState(DeferBlockState.Loading, tNode, lContainer);
     switch (tDetails.loadingState) {
         case DeferDependenciesLoadingState.NOT_STARTED:
-        case DeferDependenciesLoadingState.SCHEDULED:
             triggerResourceLoading(tDetails, lView);
             // The `loadingState` might have changed to "loading".
             if (tDetails.loadingState ===
@@ -570,4 +792,300 @@ export function getDeferBlocks(lView, deferBlocks) {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"defer.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/instructions/defer.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 {InjectionToken, Injector} from '../../di';\nimport {findMatchingDehydratedView} from '../../hydration/views';\nimport {populateDehydratedViewsInContainer} from '../../linker/view_container_ref';\nimport {assertDefined, assertEqual, throwError} from '../../util/assert';\nimport {assertIndexInDeclRange, assertLContainer, assertTNodeForLView} from '../assert';\nimport {bindingUpdated} from '../bindings';\nimport {getComponentDef, getDirectiveDef, getPipeDef} from '../definition';\nimport {CONTAINER_HEADER_OFFSET, LContainer} from '../interfaces/container';\nimport {DEFER_BLOCK_STATE, DeferBlockBehavior, DeferBlockConfig, DeferBlockInternalState, DeferBlockState, DeferDependenciesLoadingState, DeferredLoadingBlockConfig, DeferredPlaceholderBlockConfig, DependencyResolverFn, LDeferBlockDetails, TDeferBlockDetails} from '../interfaces/defer';\nimport {DirectiveDefList, PipeDefList} from '../interfaces/definition';\nimport {TContainerNode, TNode} from '../interfaces/node';\nimport {isDestroyed, isLContainer, isLView} from '../interfaces/type_checks';\nimport {HEADER_OFFSET, INJECTOR, LView, PARENT, TVIEW, TView} from '../interfaces/view';\nimport {getCurrentTNode, getLView, getSelectedTNode, getTView, nextBindingIndex} from '../state';\nimport {isPlatformBrowser} from '../util/misc_utils';\nimport {getConstant, getTNode, removeLViewOnDestroy, storeLViewOnDestroy} from '../util/view_utils';\nimport {addLViewToLContainer, createAndRenderEmbeddedLView, removeLViewFromLContainer, shouldAddViewToDom} from '../view_manipulation';\n\nimport {ɵɵtemplate} from './template';\n\n/**\n * Returns whether defer blocks should be triggered.\n *\n * Currently, defer blocks are not triggered on the server,\n * only placeholder content is rendered (if provided).\n */\nfunction shouldTriggerDeferBlock(injector: Injector): boolean {\n  const config = injector.get(DEFER_BLOCK_CONFIG, {optional: true});\n  if (config?.behavior === DeferBlockBehavior.Manual) {\n    return false;\n  }\n  return isPlatformBrowser(injector);\n}\n\n/**\n * Shims for the `requestIdleCallback` and `cancelIdleCallback` functions for environments\n * where those functions are not available (e.g. Node.js).\n */\nconst _requestIdleCallback =\n    typeof requestIdleCallback !== 'undefined' ? requestIdleCallback : setTimeout;\nconst _cancelIdleCallback =\n    typeof requestIdleCallback !== 'undefined' ? cancelIdleCallback : clearTimeout;\n\n/**\n * Creates runtime data structures for `{#defer}` blocks.\n *\n * @param index Index of the `defer` instruction.\n * @param primaryTmplIndex Index of the template with the primary block content.\n * @param dependencyResolverFn Function that contains dependencies for this defer block.\n * @param loadingTmplIndex Index of the template with the `{:loading}` block content.\n * @param placeholderTmplIndex Index of the template with the `{:placeholder}` block content.\n * @param errorTmplIndex Index of the template with the `{:error}` block content.\n * @param loadingConfigIndex Index in the constants array of the configuration of the `{:loading}`.\n *     block.\n * @param placeholderConfigIndexIndex in the constants array of the configuration of the\n *     `{:placeholder}` block.\n *\n * @codeGenApi\n */\nexport function ɵɵdefer(\n    index: number, primaryTmplIndex: number, dependencyResolverFn?: DependencyResolverFn|null,\n    loadingTmplIndex?: number|null, placeholderTmplIndex?: number|null,\n    errorTmplIndex?: number|null, loadingConfigIndex?: number|null,\n    placeholderConfigIndex?: number|null) {\n  const lView = getLView();\n  const tView = getTView();\n  const tViewConsts = tView.consts;\n  const adjustedIndex = index + HEADER_OFFSET;\n\n  ɵɵtemplate(index, null, 0, 0);\n\n  if (tView.firstCreatePass) {\n    const deferBlockConfig: TDeferBlockDetails = {\n      primaryTmplIndex,\n      loadingTmplIndex: loadingTmplIndex ?? null,\n      placeholderTmplIndex: placeholderTmplIndex ?? null,\n      errorTmplIndex: errorTmplIndex ?? null,\n      placeholderBlockConfig: placeholderConfigIndex != null ?\n          getConstant<DeferredPlaceholderBlockConfig>(tViewConsts, placeholderConfigIndex) :\n          null,\n      loadingBlockConfig: loadingConfigIndex != null ?\n          getConstant<DeferredLoadingBlockConfig>(tViewConsts, loadingConfigIndex) :\n          null,\n      dependencyResolverFn: dependencyResolverFn ?? null,\n      loadingState: DeferDependenciesLoadingState.NOT_STARTED,\n      loadingPromise: null,\n    };\n\n    setTDeferBlockDetails(tView, adjustedIndex, deferBlockConfig);\n  }\n\n  // Lookup dehydrated views that belong to this LContainer.\n  // In client-only mode, this operation is noop.\n  const lContainer = lView[adjustedIndex];\n  populateDehydratedViewsInContainer(lContainer);\n\n  // Init instance-specific defer details and store it.\n  const lDetails = [];\n  lDetails[DEFER_BLOCK_STATE] = DeferBlockInternalState.Initial;\n  setLDeferBlockDetails(lView, adjustedIndex, lDetails as LDeferBlockDetails);\n}\n\n/**\n * Loads defer block dependencies when a trigger value becomes truthy.\n * @codeGenApi\n */\nexport function ɵɵdeferWhen(rawValue: unknown) {\n  const lView = getLView();\n  const bindingIndex = nextBindingIndex();\n  if (bindingUpdated(lView, bindingIndex, rawValue)) {\n    const value = Boolean(rawValue);  // handle truthy or falsy values\n    const tNode = getSelectedTNode();\n    const lDetails = getLDeferBlockDetails(lView, tNode);\n    const renderedState = lDetails[DEFER_BLOCK_STATE];\n    if (value === false && renderedState === DeferBlockInternalState.Initial) {\n      // If nothing is rendered yet, render a placeholder (if defined).\n      renderPlaceholder(lView, tNode);\n    } else if (\n        value === true &&\n        (renderedState === DeferBlockInternalState.Initial ||\n         renderedState === DeferBlockState.Placeholder)) {\n      // The `when` condition has changed to `true`, trigger defer block loading\n      // if the block is either in initial (nothing is rendered) or a placeholder\n      // state.\n      triggerDeferBlock(lView, tNode);\n    }\n  }\n}\n\n/**\n * Prefetches the deferred content when a value becomes truthy.\n * @codeGenApi\n */\nexport function ɵɵdeferPrefetchWhen(rawValue: unknown) {\n  const lView = getLView();\n  const bindingIndex = nextBindingIndex();\n\n  if (bindingUpdated(lView, bindingIndex, rawValue)) {\n    const value = Boolean(rawValue);  // handle truthy or falsy values\n    const tView = lView[TVIEW];\n    const tNode = getSelectedTNode();\n    const tDetails = getTDeferBlockDetails(tView, tNode);\n    if (value === true && tDetails.loadingState === DeferDependenciesLoadingState.NOT_STARTED) {\n      // If loading has not been started yet, trigger it now.\n      triggerPrefetching(tDetails, lView);\n    }\n  }\n}\n\n/**\n * Sets up handlers that represent `on idle` deferred trigger.\n * @codeGenApi\n */\nexport function ɵɵdeferOnIdle() {\n  const lView = getLView();\n  const tNode = getCurrentTNode()!;\n\n  renderPlaceholder(lView, tNode);\n\n  // Note: we pass an `lView` as a second argument to cancel an `idle`\n  // callback in case an LView got destroyed before an `idle` callback\n  // is invoked.\n  onIdle(() => triggerDeferBlock(lView, tNode), lView);\n}\n\n/**\n * Creates runtime data structures for the `prefetch on idle` deferred trigger.\n * @codeGenApi\n */\nexport function ɵɵdeferPrefetchOnIdle() {\n  const lView = getLView();\n  const tNode = getCurrentTNode()!;\n  const tView = lView[TVIEW];\n  const tDetails = getTDeferBlockDetails(tView, tNode);\n\n  if (tDetails.loadingState === DeferDependenciesLoadingState.NOT_STARTED) {\n    // Set loading to the scheduled state, so that we don't register it again.\n    tDetails.loadingState = DeferDependenciesLoadingState.SCHEDULED;\n\n    // In case of prefetching, we intentionally avoid cancelling prefetching if\n    // an underlying LView get destroyed (thus passing `null` as a second argument),\n    // because there might be other LViews (that represent embedded views) that\n    // depend on resource loading.\n    onIdle(() => triggerPrefetching(tDetails, lView), null /* LView */);\n  }\n}\n\n/**\n * Creates runtime data structures for the `on immediate` deferred trigger.\n * @codeGenApi\n */\nexport function ɵɵdeferOnImmediate() {}  // TODO: implement runtime logic.\n\n\n/**\n * Creates runtime data structures for the `prefetch on immediate` deferred trigger.\n * @codeGenApi\n */\nexport function ɵɵdeferPrefetchOnImmediate() {}  // TODO: implement runtime logic.\n\n/**\n * Creates runtime data structures for the `on timer` deferred trigger.\n * @param delay Amount of time to wait before loading the content.\n * @codeGenApi\n */\nexport function ɵɵdeferOnTimer(delay: number) {}  // TODO: implement runtime logic.\n\n/**\n * Creates runtime data structures for the `prefetch on timer` deferred trigger.\n * @param delay Amount of time to wait before prefetching the content.\n * @codeGenApi\n */\nexport function ɵɵdeferPrefetchOnTimer(delay: number) {}  // TODO: implement runtime logic.\n\n/**\n * Creates runtime data structures for the `on hover` deferred trigger.\n * @codeGenApi\n */\nexport function ɵɵdeferOnHover() {}  // TODO: implement runtime logic.\n\n/**\n * Creates runtime data structures for the `prefetch on hover` deferred trigger.\n * @codeGenApi\n */\nexport function ɵɵdeferPrefetchOnHover() {}  // TODO: implement runtime logic.\n\n/**\n * Creates runtime data structures for the `on interaction` deferred trigger.\n * @param target Optional element on which to listen for hover events.\n * @codeGenApi\n */\nexport function ɵɵdeferOnInteraction(target?: unknown) {}  // TODO: implement runtime logic.\n\n/**\n * Creates runtime data structures for the `prefetch on interaction` deferred trigger.\n * @param target Optional element on which to listen for hover events.\n * @codeGenApi\n */\nexport function ɵɵdeferPrefetchOnInteraction(target?: unknown) {}  // TODO: implement runtime logic.\n\n/**\n * Creates runtime data structures for the `on viewport` deferred trigger.\n * @param target Optional element on which to listen for hover events.\n * @codeGenApi\n */\nexport function ɵɵdeferOnViewport(target?: unknown) {}  // TODO: implement runtime logic.\n\n/**\n * Creates runtime data structures for the `prefetch on viewport` deferred trigger.\n * @param target Optional element on which to listen for hover events.\n * @codeGenApi\n */\nexport function ɵɵdeferPrefetchOnViewport(target?: unknown) {}  // TODO: implement runtime logic.\n\n/********** Helper functions **********/\n\n/**\n * Helper function to schedule a callback to be invoked when a browser becomes idle.\n *\n * @param callback A function to be invoked when a browser becomes idle.\n * @param lView An optional LView that hosts an instance of a defer block. LView is\n *    used to register a cleanup callback in case that LView got destroyed before\n *    callback was invoked. In this case, an `idle` callback is never invoked. This is\n *    helpful for cases when a defer block has scheduled rendering, but an underlying\n *    LView got destroyed prior to th block rendering.\n */\nfunction onIdle(callback: VoidFunction, lView: LView|null) {\n  let id: number;\n  const removeIdleCallback = () => _cancelIdleCallback(id);\n  id = _requestIdleCallback(() => {\n         removeIdleCallback();\n         if (lView !== null) {\n           // The idle callback is invoked, we no longer need\n           // to retain a cleanup callback in an LView.\n           removeLViewOnDestroy(lView, removeIdleCallback);\n         }\n         callback();\n       }) as number;\n\n  if (lView !== null) {\n    // Store a cleanup function on LView, so that we cancel idle\n    // callback in case this LView is destroyed before a callback\n    // is invoked.\n    storeLViewOnDestroy(lView, removeIdleCallback);\n  }\n}\n\n/**\n * Calculates a data slot index for defer block info (either static or\n * instance-specific), given an index of a defer instruction.\n */\nfunction getDeferBlockDataIndex(deferBlockIndex: number) {\n  // Instance state is located at the *next* position\n  // after the defer block slot in an LView or TView.data.\n  return deferBlockIndex + 1;\n}\n\n/** Retrieves a defer block state from an LView, given a TNode that represents a block. */\nfunction getLDeferBlockDetails(lView: LView, tNode: TNode): LDeferBlockDetails {\n  const tView = lView[TVIEW];\n  const slotIndex = getDeferBlockDataIndex(tNode.index);\n  ngDevMode && assertIndexInDeclRange(tView, slotIndex);\n  return lView[slotIndex];\n}\n\n/** Stores a defer block instance state in LView. */\nfunction setLDeferBlockDetails(\n    lView: LView, deferBlockIndex: number, lDetails: LDeferBlockDetails) {\n  const tView = lView[TVIEW];\n  const slotIndex = getDeferBlockDataIndex(deferBlockIndex);\n  ngDevMode && assertIndexInDeclRange(tView, slotIndex);\n  lView[slotIndex] = lDetails;\n}\n\n/** Retrieves static info about a defer block, given a TView and a TNode that represents a block. */\nfunction getTDeferBlockDetails(tView: TView, tNode: TNode): TDeferBlockDetails {\n  const slotIndex = getDeferBlockDataIndex(tNode.index);\n  ngDevMode && assertIndexInDeclRange(tView, slotIndex);\n  return tView.data[slotIndex] as TDeferBlockDetails;\n}\n\n/** Stores a defer block static info in `TView.data`. */\nfunction setTDeferBlockDetails(\n    tView: TView, deferBlockIndex: number, deferBlockConfig: TDeferBlockDetails) {\n  const slotIndex = getDeferBlockDataIndex(deferBlockIndex);\n  ngDevMode && assertIndexInDeclRange(tView, slotIndex);\n  tView.data[slotIndex] = deferBlockConfig;\n}\n\nfunction getTemplateIndexForState(\n    newState: DeferBlockState, hostLView: LView, tNode: TNode): number|null {\n  const tView = hostLView[TVIEW];\n  const tDetails = getTDeferBlockDetails(tView, tNode);\n\n  switch (newState) {\n    case DeferBlockState.Complete:\n      return tDetails.primaryTmplIndex;\n    case DeferBlockState.Loading:\n      return tDetails.loadingTmplIndex;\n    case DeferBlockState.Error:\n      return tDetails.errorTmplIndex;\n    case DeferBlockState.Placeholder:\n      return tDetails.placeholderTmplIndex;\n    default:\n      ngDevMode && throwError(`Unexpected defer block state: ${newState}`);\n      return null;\n  }\n}\n\n/**\n * Transitions a defer block to the new state. Updates the  necessary\n * data structures and renders corresponding block.\n *\n * @param newState New state that should be applied to the defer block.\n * @param tNode TNode that represents a defer block.\n * @param lContainer Represents an instance of a defer block.\n */\nexport function renderDeferBlockState(\n    newState: DeferBlockState, tNode: TNode, lContainer: LContainer): void {\n  const hostLView = lContainer[PARENT];\n\n  // Check if this view is not destroyed. Since the loading process was async,\n  // the view might end up being destroyed by the time rendering happens.\n  if (isDestroyed(hostLView)) return;\n\n  // Make sure this TNode belongs to TView that represents host LView.\n  ngDevMode && assertTNodeForLView(tNode, hostLView);\n\n  const lDetails = getLDeferBlockDetails(hostLView, tNode);\n\n  ngDevMode && assertDefined(lDetails, 'Expected a defer block state defined');\n\n  const stateTmplIndex = getTemplateIndexForState(newState, hostLView, tNode);\n  // Note: we transition to the next state if the previous state was represented\n  // with a number that is less than the next state. For example, if the current\n  // state is \"loading\" (represented as `2`), we should not show a placeholder\n  // (represented as `1`).\n  if (lDetails[DEFER_BLOCK_STATE] < newState && stateTmplIndex !== null) {\n    lDetails[DEFER_BLOCK_STATE] = newState;\n    const hostTView = hostLView[TVIEW];\n    const adjustedIndex = stateTmplIndex + HEADER_OFFSET;\n    const tNode = getTNode(hostTView, adjustedIndex) as TContainerNode;\n\n    // There is only 1 view that can be present in an LContainer that\n    // represents a `{#defer}` block, so always refer to the first one.\n    const viewIndex = 0;\n\n    removeLViewFromLContainer(lContainer, viewIndex);\n    const dehydratedView = findMatchingDehydratedView(lContainer, tNode.tView!.ssrId);\n    const embeddedLView = createAndRenderEmbeddedLView(hostLView, tNode, null, {dehydratedView});\n    addLViewToLContainer(\n        lContainer, embeddedLView, viewIndex, shouldAddViewToDom(tNode, dehydratedView));\n  }\n}\n\n/**\n * Trigger prefetching of dependencies for a defer block.\n *\n * @param tDetails Static information about this defer block.\n * @param lView LView of a host view.\n */\nexport function triggerPrefetching(tDetails: TDeferBlockDetails, lView: LView) {\n  if (lView[INJECTOR] && shouldTriggerDeferBlock(lView[INJECTOR]!)) {\n    triggerResourceLoading(tDetails, lView);\n  }\n}\n\n/**\n * Trigger loading of defer block dependencies if the process hasn't started yet.\n *\n * @param tDetails Static information about this defer block.\n * @param lView LView of a host view.\n */\nexport function triggerResourceLoading(tDetails: TDeferBlockDetails, lView: LView) {\n  const injector = lView[INJECTOR]!;\n  const tView = lView[TVIEW];\n\n  if (tDetails.loadingState !== DeferDependenciesLoadingState.NOT_STARTED &&\n      tDetails.loadingState !== DeferDependenciesLoadingState.SCHEDULED) {\n    // If the loading status is different from initial one, it means that\n    // the loading of dependencies is in progress and there is nothing to do\n    // in this function. All details can be obtained from the `tDetails` object.\n    return;\n  }\n\n  const primaryBlockTNode = getPrimaryBlockTNode(tView, tDetails);\n\n  // Switch from NOT_STARTED -> IN_PROGRESS state.\n  tDetails.loadingState = DeferDependenciesLoadingState.IN_PROGRESS;\n\n  // Check if dependency function interceptor is configured.\n  const deferDependencyInterceptor =\n      injector.get(DEFER_BLOCK_DEPENDENCY_INTERCEPTOR, null, {optional: true});\n\n  const dependenciesFn = deferDependencyInterceptor ?\n      deferDependencyInterceptor.intercept(tDetails.dependencyResolverFn) :\n      tDetails.dependencyResolverFn;\n\n  // The `dependenciesFn` might be `null` when all dependencies within\n  // a given `{#defer}` block were eagerly references elsewhere in a file,\n  // thus no dynamic `import()`s were produced.\n  if (!dependenciesFn) {\n    tDetails.loadingPromise = Promise.resolve().then(() => {\n      tDetails.loadingState = DeferDependenciesLoadingState.COMPLETE;\n    });\n    return;\n  }\n\n  // Start downloading of defer block dependencies.\n  tDetails.loadingPromise = Promise.allSettled(dependenciesFn()).then(results => {\n    let failed = false;\n    const directiveDefs: DirectiveDefList = [];\n    const pipeDefs: PipeDefList = [];\n\n    for (const result of results) {\n      if (result.status === 'fulfilled') {\n        const dependency = result.value;\n        const directiveDef = getComponentDef(dependency) || getDirectiveDef(dependency);\n        if (directiveDef) {\n          directiveDefs.push(directiveDef);\n        } else {\n          const pipeDef = getPipeDef(dependency);\n          if (pipeDef) {\n            pipeDefs.push(pipeDef);\n          }\n        }\n      } else {\n        failed = true;\n        break;\n      }\n    }\n\n    // Loading is completed, we no longer need this Promise.\n    tDetails.loadingPromise = null;\n\n    if (failed) {\n      tDetails.loadingState = DeferDependenciesLoadingState.FAILED;\n    } else {\n      tDetails.loadingState = DeferDependenciesLoadingState.COMPLETE;\n\n      // Update directive and pipe registries to add newly downloaded dependencies.\n      const primaryBlockTView = primaryBlockTNode.tView!;\n      if (directiveDefs.length > 0) {\n        primaryBlockTView.directiveRegistry = primaryBlockTView.directiveRegistry ?\n            [...primaryBlockTView.directiveRegistry, ...directiveDefs] :\n            directiveDefs;\n      }\n      if (pipeDefs.length > 0) {\n        primaryBlockTView.pipeRegistry = primaryBlockTView.pipeRegistry ?\n            [...primaryBlockTView.pipeRegistry, ...pipeDefs] :\n            pipeDefs;\n      }\n    }\n  });\n}\n\n/** Utility function to render `{:placeholder}` content (if present) */\nfunction renderPlaceholder(lView: LView, tNode: TNode) {\n  const tView = lView[TVIEW];\n  const lContainer = lView[tNode.index];\n  ngDevMode && assertLContainer(lContainer);\n\n  const tDetails = getTDeferBlockDetails(tView, tNode);\n  renderDeferBlockState(DeferBlockState.Placeholder, tNode, lContainer);\n}\n\n/**\n * Subscribes to the \"loading\" Promise and renders corresponding defer sub-block,\n * based on the loading results.\n *\n * @param lContainer Represents an instance of a defer block.\n * @param tNode Represents defer block info shared across all instances.\n */\nfunction renderDeferStateAfterResourceLoading(\n    tDetails: TDeferBlockDetails, tNode: TNode, lContainer: LContainer) {\n  ngDevMode &&\n      assertDefined(\n          tDetails.loadingPromise, 'Expected loading Promise to exist on this defer block');\n\n  tDetails.loadingPromise!.then(() => {\n    if (tDetails.loadingState === DeferDependenciesLoadingState.COMPLETE) {\n      ngDevMode && assertDeferredDependenciesLoaded(tDetails);\n\n      // Everything is loaded, show the primary block content\n      renderDeferBlockState(DeferBlockState.Complete, tNode, lContainer);\n\n    } else if (tDetails.loadingState === DeferDependenciesLoadingState.FAILED) {\n      renderDeferBlockState(DeferBlockState.Error, tNode, lContainer);\n    }\n  });\n}\n\n/** Retrieves a TNode that represents main content of a defer block. */\nfunction getPrimaryBlockTNode(tView: TView, tDetails: TDeferBlockDetails): TContainerNode {\n  const adjustedIndex = tDetails.primaryTmplIndex + HEADER_OFFSET;\n  return getTNode(tView, adjustedIndex) as TContainerNode;\n}\n\n/**\n * Attempts to trigger loading of defer block dependencies.\n * If the block is already in a loading, completed or an error state -\n * no additional actions are taken.\n */\nfunction triggerDeferBlock(lView: LView, tNode: TNode) {\n  const tView = lView[TVIEW];\n  const lContainer = lView[tNode.index];\n  const injector = lView[INJECTOR]!;\n  ngDevMode && assertLContainer(lContainer);\n\n  if (!shouldTriggerDeferBlock(injector)) return;\n\n  const tDetails = getTDeferBlockDetails(tView, tNode);\n\n  // Condition is triggered, try to render loading state and start downloading.\n  // Note: if a block is in a loading, completed or an error state, this call would be a noop.\n  renderDeferBlockState(DeferBlockState.Loading, tNode, lContainer);\n\n  switch (tDetails.loadingState) {\n    case DeferDependenciesLoadingState.NOT_STARTED:\n    case DeferDependenciesLoadingState.SCHEDULED:\n      triggerResourceLoading(tDetails, lView);\n\n      // The `loadingState` might have changed to \"loading\".\n      if ((tDetails.loadingState as DeferDependenciesLoadingState) ===\n          DeferDependenciesLoadingState.IN_PROGRESS) {\n        renderDeferStateAfterResourceLoading(tDetails, tNode, lContainer);\n      }\n      break;\n    case DeferDependenciesLoadingState.IN_PROGRESS:\n      renderDeferStateAfterResourceLoading(tDetails, tNode, lContainer);\n      break;\n    case DeferDependenciesLoadingState.COMPLETE:\n      ngDevMode && assertDeferredDependenciesLoaded(tDetails);\n      renderDeferBlockState(DeferBlockState.Complete, tNode, lContainer);\n      break;\n    case DeferDependenciesLoadingState.FAILED:\n      renderDeferBlockState(DeferBlockState.Error, tNode, lContainer);\n      break;\n    default:\n      if (ngDevMode) {\n        throwError('Unknown defer block state');\n      }\n  }\n}\n\n/**\n * Asserts whether all dependencies for a defer block are loaded.\n * Always run this function (in dev mode) before rendering a defer\n * block in completed state.\n */\nfunction assertDeferredDependenciesLoaded(tDetails: TDeferBlockDetails) {\n  assertEqual(\n      tDetails.loadingState, DeferDependenciesLoadingState.COMPLETE,\n      'Expecting all deferred dependencies to be loaded.');\n}\n\n/**\n * **INTERNAL**, avoid referencing it in application code.\n *\n * Describes a helper class that allows to intercept a call to retrieve current\n * dependency loading function and replace it with a different implementation.\n * This interceptor class is needed to allow testing blocks in different states\n * by simulating loading response.\n */\nexport interface DeferBlockDependencyInterceptor {\n  /**\n   * Invoked for each defer block when dependency loading function is accessed.\n   */\n  intercept(dependencyFn: DependencyResolverFn|null): DependencyResolverFn|null;\n\n  /**\n   * Allows to configure an interceptor function.\n   */\n  setInterceptor(interceptorFn: (current: DependencyResolverFn) => DependencyResolverFn): void;\n}\n\n/**\n * **INTERNAL**, avoid referencing it in application code.\n *\n * Injector token that allows to provide `DeferBlockDependencyInterceptor` class\n * implementation.\n */\nexport const DEFER_BLOCK_DEPENDENCY_INTERCEPTOR =\n    new InjectionToken<DeferBlockDependencyInterceptor>(\n        ngDevMode ? 'DEFER_BLOCK_DEPENDENCY_INTERCEPTOR' : '');\n\n/**\n * Determines if a given value matches the expected structure of a defer block\n *\n * We can safely rely on the primaryTmplIndex because every defer block requires\n * that a primary template exists. All the other template options are optional.\n */\nfunction isTDeferBlockDetails(value: unknown): value is TDeferBlockDetails {\n  return (typeof value === 'object') &&\n      (typeof (value as TDeferBlockDetails).primaryTmplIndex === 'number');\n}\n\n/**\n * Internal token used for configuring defer block behavior.\n */\nexport const DEFER_BLOCK_CONFIG =\n    new InjectionToken<DeferBlockConfig>(ngDevMode ? 'DEFER_BLOCK_CONFIG' : '');\n\n/**\n * Defer block instance for testing.\n */\nexport interface DeferBlockDetails {\n  lContainer: LContainer;\n  lView: LView;\n  tNode: TNode;\n  tDetails: TDeferBlockDetails;\n}\n\n/**\n * Retrieves all defer blocks in a given LView.\n *\n * @param lView lView with defer blocks\n * @param deferBlocks defer block aggregator array\n */\nexport function getDeferBlocks(lView: LView, deferBlocks: DeferBlockDetails[]) {\n  const tView = lView[TVIEW];\n  for (let i = HEADER_OFFSET; i < tView.bindingStartIndex; i++) {\n    if (isLContainer(lView[i])) {\n      const lContainer = lView[i];\n      // An LContainer may represent an instance of a defer block, in which case\n      // we store it as a result. Otherwise, keep iterating over LContainer views and\n      // look for defer blocks.\n      const isLast = i === tView.bindingStartIndex - 1;\n      if (!isLast) {\n        const tNode = tView.data[i] as TNode;\n        const tDetails = getTDeferBlockDetails(tView, tNode);\n        if (isTDeferBlockDetails(tDetails)) {\n          deferBlocks.push({lContainer, lView, tNode, tDetails});\n          // This LContainer represents a defer block, so we exit\n          // this iteration and don't inspect views in this LContainer.\n          continue;\n        }\n      }\n      for (let i = CONTAINER_HEADER_OFFSET; i < lContainer.length; i++) {\n        getDeferBlocks(lContainer[i] as LView, deferBlocks);\n      }\n    } else if (isLView(lView[i])) {\n      // This is a component, enter the `getDeferBlocks` recursively.\n      getDeferBlocks(lView[i], deferBlocks);\n    }\n  }\n}\n"]}
+/**
+ * Registers a cleanup function associated with a prefetching trigger
+ * of a given defer block.
+ */
+function registerTDetailsCleanup(injector, tDetails, key, cleanupFn) {
+    injector.get(DeferBlockCleanupManager).add(tDetails, key, cleanupFn);
+}
+/**
+ * Invokes all registered prefetch cleanup triggers
+ * and removes all cleanup functions afterwards.
+ */
+function invokeTDetailsCleanup(injector, tDetails) {
+    injector.get(DeferBlockCleanupManager).cleanup(tDetails);
+}
+/**
+ * Internal service to keep track of cleanup functions associated
+ * with defer blocks. This class is used to manage cleanup functions
+ * created for prefetching triggers.
+ */
+class DeferBlockCleanupManager {
+    constructor() {
+        this.blocks = new Map();
+    }
+    add(tDetails, key, callback) {
+        if (!this.blocks.has(tDetails)) {
+            this.blocks.set(tDetails, new Map());
+        }
+        const block = this.blocks.get(tDetails);
+        if (!block.has(key)) {
+            block.set(key, []);
+        }
+        const callbacks = block.get(key);
+        callbacks.push(callback);
+    }
+    has(tDetails, key) {
+        return !!this.blocks.get(tDetails)?.has(key);
+    }
+    cleanup(tDetails) {
+        const block = this.blocks.get(tDetails);
+        if (block) {
+            for (const callbacks of Object.values(block)) {
+                for (const callback of callbacks) {
+                    callback();
+                }
+            }
+            this.blocks.delete(tDetails);
+        }
+    }
+    ngOnDestroy() {
+        for (const [block] of this.blocks) {
+            this.cleanup(block);
+        }
+        this.blocks.clear();
+    }
+    /** @nocollapse */
+    static { this.ɵprov = ɵɵdefineInjectable({
+        token: DeferBlockCleanupManager,
+        providedIn: 'root',
+        factory: () => new DeferBlockCleanupManager(),
+    }); }
+}
+/**
+ * Use shims for the `requestIdleCallback` and `cancelIdleCallback` functions for
+ * environments where those functions are not available (e.g. Node.js and Safari).
+ *
+ * Note: we wrap the `requestIdleCallback` call into a function, so that it can be
+ * overridden/mocked in test environment and picked up by the runtime code.
+ */
+const _requestIdleCallback = () => typeof requestIdleCallback !== 'undefined' ? requestIdleCallback : setTimeout;
+const _cancelIdleCallback = () => typeof requestIdleCallback !== 'undefined' ? cancelIdleCallback : clearTimeout;
+/**
+ * Helper service to schedule `requestIdleCallback`s for batches of defer blocks,
+ * to avoid calling `requestIdleCallback` for each defer block (e.g. if
+ * defer blocks are defined inside a for loop).
+ */
+class OnIdleScheduler {
+    constructor() {
+        // Indicates whether current callbacks are being invoked.
+        this.executingCallbacks = false;
+        // Currently scheduled idle callback id.
+        this.idleId = null;
+        // Set of callbacks to be invoked next.
+        this.current = new Set();
+        // Set of callbacks collected while invoking current set of callbacks.
+        // Those callbacks are scheduled for the next idle period.
+        this.deferred = new Set();
+        this.ngZone = inject(NgZone);
+        this.requestIdleCallback = _requestIdleCallback().bind(globalThis);
+        this.cancelIdleCallback = _cancelIdleCallback().bind(globalThis);
+    }
+    add(callback) {
+        const target = this.executingCallbacks ? this.deferred : this.current;
+        target.add(callback);
+        if (this.idleId === null) {
+            this.scheduleIdleCallback();
+        }
+    }
+    remove(callback) {
+        this.current.delete(callback);
+        this.deferred.delete(callback);
+    }
+    scheduleIdleCallback() {
+        const callback = () => {
+            this.cancelIdleCallback(this.idleId);
+            this.idleId = null;
+            this.executingCallbacks = true;
+            for (const callback of this.current) {
+                callback();
+            }
+            this.current.clear();
+            this.executingCallbacks = false;
+            // If there are any callbacks added during an invocation
+            // of the current ones - make them "current" and schedule
+            // a new idle callback.
+            if (this.deferred.size > 0) {
+                for (const callback of this.deferred) {
+                    this.current.add(callback);
+                }
+                this.deferred.clear();
+                this.scheduleIdleCallback();
+            }
+        };
+        // Ensure that the callback runs in the NgZone since
+        // the `requestIdleCallback` is not currently patched by Zone.js.
+        this.idleId = this.requestIdleCallback(() => this.ngZone.run(callback));
+    }
+    ngOnDestroy() {
+        if (this.idleId !== null) {
+            this.cancelIdleCallback(this.idleId);
+            this.idleId = null;
+        }
+        this.current.clear();
+        this.deferred.clear();
+    }
+    /** @nocollapse */
+    static { this.ɵprov = ɵɵdefineInjectable({
+        token: OnIdleScheduler,
+        providedIn: 'root',
+        factory: () => new OnIdleScheduler(),
+    }); }
+}
+/**
+ * Helper service to schedule `setTimeout`s for batches of defer blocks,
+ * to avoid calling `setTimeout` for each defer block (e.g. if defer blocks
+ * are created inside a for loop).
+ */
+class TimerScheduler {
+    constructor() {
+        // Indicates whether current callbacks are being invoked.
+        this.executingCallbacks = false;
+        // Currently scheduled `setTimeout` id.
+        this.timeoutId = null;
+        // When currently scheduled timer would fire.
+        this.invokeTimerAt = null;
+        // List of callbacks to be invoked.
+        // For each callback we also store a timestamp on when the callback
+        // should be invoked. We store timestamps and callback functions
+        // in a flat array to avoid creating new objects for each entry.
+        // [timestamp1, callback1, timestamp2, callback2, ...]
+        this.current = [];
+        // List of callbacks collected while invoking current set of callbacks.
+        // Those callbacks are added to the "current" queue at the end of
+        // the current callback invocation. The shape of this list is the same
+        // as the shape of the `current` list.
+        this.deferred = [];
+    }
+    add(delay, callback) {
+        const target = this.executingCallbacks ? this.deferred : this.current;
+        this.addToQueue(target, Date.now() + delay, callback);
+        this.scheduleTimer();
+    }
+    remove(callback) {
+        const callbackIndex = this.removeFromQueue(this.current, callback);
+        if (callbackIndex === -1) {
+            // Try cleaning up deferred queue only in case
+            // we didn't find a callback in the "current" queue.
+            this.removeFromQueue(this.deferred, callback);
+        }
+    }
+    addToQueue(target, invokeAt, callback) {
+        let insertAtIndex = target.length;
+        for (let i = 0; i < target.length; i += 2) {
+            const invokeQueuedCallbackAt = target[i];
+            if (invokeQueuedCallbackAt > invokeAt) {
+                // We've reached a first timer that is scheduled
+                // for a later time than what we are trying to insert.
+                // This is the location at which we need to insert,
+                // no need to iterate further.
+                insertAtIndex = i;
+                break;
+            }
+        }
+        arrayInsert2(target, insertAtIndex, invokeAt, callback);
+    }
+    removeFromQueue(target, callback) {
+        let index = -1;
+        for (let i = 0; i < target.length; i += 2) {
+            const queuedCallback = target[i + 1];
+            if (queuedCallback === callback) {
+                index = i;
+                break;
+            }
+        }
+        if (index > -1) {
+            // Remove 2 elements: a timestamp slot and
+            // the following slot with a callback function.
+            arraySplice(target, index, 2);
+        }
+        return index;
+    }
+    scheduleTimer() {
+        const callback = () => {
+            clearTimeout(this.timeoutId);
+            this.timeoutId = null;
+            this.executingCallbacks = true;
+            // Invoke callbacks that were scheduled to run
+            // before the current time.
+            let now = Date.now();
+            let lastCallbackIndex = null;
+            for (let i = 0; i < this.current.length; i += 2) {
+                const invokeAt = this.current[i];
+                const callback = this.current[i + 1];
+                if (invokeAt <= now) {
+                    callback();
+                    // Point at the invoked callback function, which is located
+                    // after the timestamp.
+                    lastCallbackIndex = i + 1;
+                }
+                else {
+                    // We've reached a timer that should not be invoked yet.
+                    break;
+                }
+            }
+            if (lastCallbackIndex !== null) {
+                // If last callback index is `null` - no callbacks were invoked,
+                // so no cleanup is needed. Otherwise, remove invoked callbacks
+                // from the queue.
+                arraySplice(this.current, 0, lastCallbackIndex + 1);
+            }
+            this.executingCallbacks = false;
+            // If there are any callbacks added during an invocation
+            // of the current ones - move them over to the "current"
+            // queue.
+            if (this.deferred.length > 0) {
+                for (let i = 0; i < this.deferred.length; i += 2) {
+                    const invokeAt = this.deferred[i];
+                    const callback = this.deferred[i + 1];
+                    this.addToQueue(this.current, invokeAt, callback);
+                }
+                this.deferred.length = 0;
+            }
+            this.scheduleTimer();
+        };
+        // Avoid running timer callbacks more than once per
+        // average frame duration. This is needed for better
+        // batching and to avoid kicking off excessive change
+        // detection cycles.
+        const FRAME_DURATION_MS = 16; // 1000ms / 60fps
+        if (this.current.length > 0) {
+            const now = Date.now();
+            // First element in the queue points at the timestamp
+            // of the first (earliest) event.
+            const invokeAt = this.current[0];
+            if (!this.timeoutId ||
+                // Reschedule a timer in case a queue contains an item with
+                // an earlier timestamp and the delta is more than an average
+                // frame duration.
+                (this.invokeTimerAt && (this.invokeTimerAt - invokeAt > FRAME_DURATION_MS))) {
+                if (this.timeoutId !== null) {
+                    // There was a timeout already, but an earlier event was added
+                    // into the queue. In this case we drop an old timer and setup
+                    // a new one with an updated (smaller) timeout.
+                    clearTimeout(this.timeoutId);
+                    this.timeoutId = null;
+                }
+                const timeout = Math.max(invokeAt - now, FRAME_DURATION_MS);
+                this.invokeTimerAt = invokeAt;
+                this.timeoutId = setTimeout(callback, timeout);
+            }
+        }
+    }
+    ngOnDestroy() {
+        if (this.timeoutId !== null) {
+            clearTimeout(this.timeoutId);
+            this.timeoutId = null;
+        }
+        this.current.length = 0;
+        this.deferred.length = 0;
+    }
+    /** @nocollapse */
+    static { this.ɵprov = ɵɵdefineInjectable({
+        token: TimerScheduler,
+        providedIn: 'root',
+        factory: () => new TimerScheduler(),
+    }); }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"defer.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/instructions/defer.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 {inject, InjectionToken, Injector, ɵɵdefineInjectable} from '../../di';\nimport {findMatchingDehydratedView} from '../../hydration/views';\nimport {populateDehydratedViewsInLContainer} from '../../linker/view_container_ref';\nimport {arrayInsert2, arraySplice} from '../../util/array_utils';\nimport {assertDefined, assertElement, assertEqual, throwError} from '../../util/assert';\nimport {NgZone} from '../../zone';\nimport {afterRender} from '../after_render_hooks';\nimport {assertIndexInDeclRange, assertLContainer, assertLView, assertTNodeForLView} from '../assert';\nimport {bindingUpdated} from '../bindings';\nimport {getComponentDef, getDirectiveDef, getPipeDef} from '../definition';\nimport {CONTAINER_HEADER_OFFSET, LContainer} from '../interfaces/container';\nimport {DEFER_BLOCK_STATE, DeferBlockBehavior, DeferBlockConfig, DeferBlockInternalState, DeferBlockState, DeferBlockTriggers, DeferDependenciesLoadingState, DeferredLoadingBlockConfig, DeferredPlaceholderBlockConfig, DependencyResolverFn, LDeferBlockDetails, TDeferBlockDetails} from '../interfaces/defer';\nimport {DependencyDef, DirectiveDefList, PipeDefList} from '../interfaces/definition';\nimport {TContainerNode, TNode} from '../interfaces/node';\nimport {isDestroyed, isLContainer, isLView} from '../interfaces/type_checks';\nimport {FLAGS, HEADER_OFFSET, INJECTOR, LView, LViewFlags, PARENT, TVIEW, TView} from '../interfaces/view';\nimport {getCurrentTNode, getLView, getSelectedTNode, getTView, nextBindingIndex} from '../state';\nimport {isPlatformBrowser} from '../util/misc_utils';\nimport {getConstant, getNativeByIndex, getTNode, removeLViewOnDestroy, storeLViewOnDestroy, walkUpViews} from '../util/view_utils';\nimport {addLViewToLContainer, createAndRenderEmbeddedLView, removeLViewFromLContainer, shouldAddViewToDom} from '../view_manipulation';\n\nimport {onHover, onInteraction, onViewport} from './defer_events';\nimport {ɵɵtemplate} from './template';\n\n/**\n * Returns whether defer blocks should be triggered.\n *\n * Currently, defer blocks are not triggered on the server,\n * only placeholder content is rendered (if provided).\n */\nfunction shouldTriggerDeferBlock(injector: Injector): boolean {\n  const config = injector.get(DEFER_BLOCK_CONFIG, null, {optional: true});\n  if (config?.behavior === DeferBlockBehavior.Manual) {\n    return false;\n  }\n  return isPlatformBrowser(injector);\n}\n\n/**\n * Creates runtime data structures for defer blocks.\n *\n * @param index Index of the `defer` instruction.\n * @param primaryTmplIndex Index of the template with the primary block content.\n * @param dependencyResolverFn Function that contains dependencies for this defer block.\n * @param loadingTmplIndex Index of the template with the loading block content.\n * @param placeholderTmplIndex Index of the template with the placeholder block content.\n * @param errorTmplIndex Index of the template with the error block content.\n * @param loadingConfigIndex Index in the constants array of the configuration of the loading.\n *     block.\n * @param placeholderConfigIndex Index in the constants array of the configuration of the\n *     placeholder block.\n *\n * @codeGenApi\n */\nexport function ɵɵdefer(\n    index: number, primaryTmplIndex: number, dependencyResolverFn?: DependencyResolverFn|null,\n    loadingTmplIndex?: number|null, placeholderTmplIndex?: number|null,\n    errorTmplIndex?: number|null, loadingConfigIndex?: number|null,\n    placeholderConfigIndex?: number|null) {\n  const lView = getLView();\n  const tView = getTView();\n  const tViewConsts = tView.consts;\n  const adjustedIndex = index + HEADER_OFFSET;\n\n  ɵɵtemplate(index, null, 0, 0);\n\n  if (tView.firstCreatePass) {\n    const deferBlockConfig: TDeferBlockDetails = {\n      primaryTmplIndex,\n      loadingTmplIndex: loadingTmplIndex ?? null,\n      placeholderTmplIndex: placeholderTmplIndex ?? null,\n      errorTmplIndex: errorTmplIndex ?? null,\n      placeholderBlockConfig: placeholderConfigIndex != null ?\n          getConstant<DeferredPlaceholderBlockConfig>(tViewConsts, placeholderConfigIndex) :\n          null,\n      loadingBlockConfig: loadingConfigIndex != null ?\n          getConstant<DeferredLoadingBlockConfig>(tViewConsts, loadingConfigIndex) :\n          null,\n      dependencyResolverFn: dependencyResolverFn ?? null,\n      loadingState: DeferDependenciesLoadingState.NOT_STARTED,\n      loadingPromise: null,\n    };\n\n    setTDeferBlockDetails(tView, adjustedIndex, deferBlockConfig);\n  }\n\n  const tNode = getCurrentTNode()!;\n  const lContainer = lView[adjustedIndex];\n\n  // If hydration is enabled, looks up dehydrated views in the DOM\n  // using hydration annotation info and stores those views on LContainer.\n  // In client-only mode, this function is a noop.\n  populateDehydratedViewsInLContainer(lContainer, tNode, lView);\n\n  // Init instance-specific defer details and store it.\n  const lDetails = [];\n  lDetails[DEFER_BLOCK_STATE] = DeferBlockInternalState.Initial;\n  setLDeferBlockDetails(lView, adjustedIndex, lDetails as LDeferBlockDetails);\n}\n\n/**\n * Loads defer block dependencies when a trigger value becomes truthy.\n * @codeGenApi\n */\nexport function ɵɵdeferWhen(rawValue: unknown) {\n  const lView = getLView();\n  const bindingIndex = nextBindingIndex();\n  if (bindingUpdated(lView, bindingIndex, rawValue)) {\n    const value = Boolean(rawValue);  // handle truthy or falsy values\n    const tNode = getSelectedTNode();\n    const lDetails = getLDeferBlockDetails(lView, tNode);\n    const renderedState = lDetails[DEFER_BLOCK_STATE];\n    if (value === false && renderedState === DeferBlockInternalState.Initial) {\n      // If nothing is rendered yet, render a placeholder (if defined).\n      renderPlaceholder(lView, tNode);\n    } else if (\n        value === true &&\n        (renderedState === DeferBlockInternalState.Initial ||\n         renderedState === DeferBlockState.Placeholder)) {\n      // The `when` condition has changed to `true`, trigger defer block loading\n      // if the block is either in initial (nothing is rendered) or a placeholder\n      // state.\n      triggerDeferBlock(lView, tNode);\n    }\n  }\n}\n\n/**\n * Prefetches the deferred content when a value becomes truthy.\n * @codeGenApi\n */\nexport function ɵɵdeferPrefetchWhen(rawValue: unknown) {\n  const lView = getLView();\n  const bindingIndex = nextBindingIndex();\n\n  if (bindingUpdated(lView, bindingIndex, rawValue)) {\n    const value = Boolean(rawValue);  // handle truthy or falsy values\n    const tView = lView[TVIEW];\n    const tNode = getSelectedTNode();\n    const tDetails = getTDeferBlockDetails(tView, tNode);\n    if (value === true && tDetails.loadingState === DeferDependenciesLoadingState.NOT_STARTED) {\n      // If loading has not been started yet, trigger it now.\n      triggerPrefetching(tDetails, lView);\n    }\n  }\n}\n\n/**\n * Sets up logic to handle the `on idle` deferred trigger.\n * @codeGenApi\n */\nexport function ɵɵdeferOnIdle() {\n  scheduleDelayedTrigger(onIdle);\n}\n\n/**\n * Sets up logic to handle the `prefetch on idle` deferred trigger.\n * @codeGenApi\n */\nexport function ɵɵdeferPrefetchOnIdle() {\n  scheduleDelayedPrefetching(onIdle, DeferBlockTriggers.OnIdle);\n}\n\n/**\n * Sets up logic to handle the `on immediate` deferred trigger.\n * @codeGenApi\n */\nexport function ɵɵdeferOnImmediate() {\n  const lView = getLView();\n  const tNode = getCurrentTNode()!;\n  const tView = lView[TVIEW];\n  const tDetails = getTDeferBlockDetails(tView, tNode);\n\n  // Render placeholder block only if loading template is not present\n  // to avoid content flickering, since it would be immediately replaced\n  // by the loading block.\n  if (tDetails.loadingTmplIndex === null) {\n    renderPlaceholder(lView, tNode);\n  }\n  triggerDeferBlock(lView, tNode);\n}\n\n\n/**\n * Sets up logic to handle the `prefetch on immediate` deferred trigger.\n * @codeGenApi\n */\nexport function ɵɵdeferPrefetchOnImmediate() {\n  const lView = getLView();\n  const tNode = getCurrentTNode()!;\n  const tView = lView[TVIEW];\n  const tDetails = getTDeferBlockDetails(tView, tNode);\n\n  if (tDetails.loadingState === DeferDependenciesLoadingState.NOT_STARTED) {\n    triggerResourceLoading(tDetails, lView);\n  }\n}\n\n/**\n * Creates runtime data structures for the `on timer` deferred trigger.\n * @param delay Amount of time to wait before loading the content.\n * @codeGenApi\n */\nexport function ɵɵdeferOnTimer(delay: number) {\n  scheduleDelayedTrigger(onTimer(delay));\n}\n\n/**\n * Creates runtime data structures for the `prefetch on timer` deferred trigger.\n * @param delay Amount of time to wait before prefetching the content.\n * @codeGenApi\n */\nexport function ɵɵdeferPrefetchOnTimer(delay: number) {\n  scheduleDelayedPrefetching(onTimer(delay), DeferBlockTriggers.OnTimer);\n}\n\n/**\n * Creates runtime data structures for the `on hover` deferred trigger.\n * @param triggerIndex Index at which to find the trigger element.\n * @param walkUpTimes Number of times to walk up/down the tree hierarchy to find the trigger.\n * @codeGenApi\n */\nexport function ɵɵdeferOnHover(triggerIndex: number, walkUpTimes?: number) {\n  const lView = getLView();\n  const tNode = getCurrentTNode()!;\n\n  renderPlaceholder(lView, tNode);\n  registerDomTrigger(\n      lView, tNode, triggerIndex, walkUpTimes, onHover, () => triggerDeferBlock(lView, tNode));\n}\n\n/**\n * Creates runtime data structures for the `prefetch on hover` deferred trigger.\n * @param triggerIndex Index at which to find the trigger element.\n * @param walkUpTimes Number of times to walk up/down the tree hierarchy to find the trigger.\n * @codeGenApi\n */\nexport function ɵɵdeferPrefetchOnHover(triggerIndex: number, walkUpTimes?: number) {\n  const lView = getLView();\n  const tNode = getCurrentTNode()!;\n  const tView = lView[TVIEW];\n  const tDetails = getTDeferBlockDetails(tView, tNode);\n\n  if (tDetails.loadingState === DeferDependenciesLoadingState.NOT_STARTED) {\n    registerDomTrigger(\n        lView, tNode, triggerIndex, walkUpTimes, onHover,\n        () => triggerPrefetching(tDetails, lView));\n  }\n}\n\n/**\n * Creates runtime data structures for the `on interaction` deferred trigger.\n * @param triggerIndex Index at which to find the trigger element.\n * @param walkUpTimes Number of times to walk up/down the tree hierarchy to find the trigger.\n * @codeGenApi\n */\nexport function ɵɵdeferOnInteraction(triggerIndex: number, walkUpTimes?: number) {\n  const lView = getLView();\n  const tNode = getCurrentTNode()!;\n\n  renderPlaceholder(lView, tNode);\n  registerDomTrigger(\n      lView, tNode, triggerIndex, walkUpTimes, onInteraction,\n      () => triggerDeferBlock(lView, tNode));\n}\n\n/**\n * Creates runtime data structures for the `prefetch on interaction` deferred trigger.\n * @param triggerIndex Index at which to find the trigger element.\n * @param walkUpTimes Number of times to walk up/down the tree hierarchy to find the trigger.\n * @codeGenApi\n */\nexport function ɵɵdeferPrefetchOnInteraction(triggerIndex: number, walkUpTimes?: number) {\n  const lView = getLView();\n  const tNode = getCurrentTNode()!;\n  const tView = lView[TVIEW];\n  const tDetails = getTDeferBlockDetails(tView, tNode);\n\n  if (tDetails.loadingState === DeferDependenciesLoadingState.NOT_STARTED) {\n    registerDomTrigger(\n        lView, tNode, triggerIndex, walkUpTimes, onInteraction,\n        () => triggerPrefetching(tDetails, lView));\n  }\n}\n\n/**\n * Creates runtime data structures for the `on viewport` deferred trigger.\n * @param triggerIndex Index at which to find the trigger element.\n * @param walkUpTimes Number of times to walk up/down the tree hierarchy to find the trigger.\n * @codeGenApi\n */\nexport function ɵɵdeferOnViewport(triggerIndex: number, walkUpTimes?: number) {\n  const lView = getLView();\n  const tNode = getCurrentTNode()!;\n\n  renderPlaceholder(lView, tNode);\n  registerDomTrigger(\n      lView, tNode, triggerIndex, walkUpTimes, onViewport, () => triggerDeferBlock(lView, tNode));\n}\n\n/**\n * Creates runtime data structures for the `prefetch on viewport` deferred trigger.\n * @param triggerIndex Index at which to find the trigger element.\n * @param walkUpTimes Number of times to walk up/down the tree hierarchy to find the trigger.\n * @codeGenApi\n */\nexport function ɵɵdeferPrefetchOnViewport(triggerIndex: number, walkUpTimes?: number) {\n  const lView = getLView();\n  const tNode = getCurrentTNode()!;\n  const tView = lView[TVIEW];\n  const tDetails = getTDeferBlockDetails(tView, tNode);\n\n  if (tDetails.loadingState === DeferDependenciesLoadingState.NOT_STARTED) {\n    registerDomTrigger(\n        lView, tNode, triggerIndex, walkUpTimes, onViewport,\n        () => triggerPrefetching(tDetails, lView));\n  }\n}\n\n/********** Helper functions **********/\n\n/**\n * Schedules triggering of a defer block for `on idle` and `on timer` conditions.\n */\nfunction scheduleDelayedTrigger(\n    scheduleFn: (callback: VoidFunction, lView: LView, withLViewCleanup: boolean) => VoidFunction) {\n  const lView = getLView();\n  const tNode = getCurrentTNode()!;\n\n  renderPlaceholder(lView, tNode);\n  scheduleFn(() => triggerDeferBlock(lView, tNode), lView, true /* withLViewCleanup */);\n}\n\n/**\n * Schedules prefetching for `on idle` and `on timer` triggers.\n *\n * @param scheduleFn A function that does the scheduling.\n * @param trigger A trigger that initiated scheduling.\n */\nfunction scheduleDelayedPrefetching(\n    scheduleFn: (callback: VoidFunction, lView: LView, withLViewCleanup: boolean) => VoidFunction,\n    trigger: DeferBlockTriggers) {\n  const lView = getLView();\n  const tNode = getCurrentTNode()!;\n  const tView = lView[TVIEW];\n  const tDetails = getTDeferBlockDetails(tView, tNode);\n\n  if (tDetails.loadingState === DeferDependenciesLoadingState.NOT_STARTED) {\n    // Prevent scheduling more than one prefetch init call\n    // for each defer block. For this reason we use only a trigger\n    // identifier in a key, so all instances would use the same key.\n    const key = String(trigger);\n    const injector = lView[INJECTOR]!;\n    const manager = injector.get(DeferBlockCleanupManager);\n    if (!manager.has(tDetails, key)) {\n      // In case of prefetching, we intentionally avoid cancelling resource loading if\n      // an underlying LView get destroyed (thus passing `null` as a second argument),\n      // because there might be other LViews (that represent embedded views) that\n      // depend on resource loading.\n      const prefetch = () => triggerPrefetching(tDetails, lView);\n      const cleanupFn = scheduleFn(prefetch, lView, false /* withLViewCleanup */);\n      registerTDetailsCleanup(injector, tDetails, key, cleanupFn);\n    }\n  }\n}\n\n/**\n * Helper function to get the LView in which a deferred block's trigger is rendered.\n * @param deferredHostLView LView in which the deferred block is defined.\n * @param deferredTNode TNode defining the deferred block.\n * @param walkUpTimes Number of times to go up in the view hierarchy to find the trigger's view.\n *   A negative value means that the trigger is inside the block's placeholder, while an undefined\n *   value means that the trigger is in the same LView as the deferred block.\n */\nfunction getTriggerLView(\n    deferredHostLView: LView, deferredTNode: TNode, walkUpTimes: number|undefined): LView|null {\n  // The trigger is in the same view, we don't need to traverse.\n  if (walkUpTimes == null) {\n    return deferredHostLView;\n  }\n\n  // A positive value or zero means that the trigger is in a parent view.\n  if (walkUpTimes >= 0) {\n    return walkUpViews(walkUpTimes, deferredHostLView);\n  }\n\n  // If the value is negative, it means that the trigger is inside the placeholder.\n  const deferredContainer = deferredHostLView[deferredTNode.index];\n  ngDevMode && assertLContainer(deferredContainer);\n  const triggerLView = deferredContainer[CONTAINER_HEADER_OFFSET] ?? null;\n\n  // We need to null check, because the placeholder might not have been rendered yet.\n  if (ngDevMode && triggerLView !== null) {\n    const lDetails = getLDeferBlockDetails(deferredHostLView, deferredTNode);\n    const renderedState = lDetails[DEFER_BLOCK_STATE];\n    assertEqual(\n        renderedState, DeferBlockState.Placeholder,\n        'Expected a placeholder to be rendered in this defer block.');\n    assertLView(triggerLView);\n  }\n\n  return triggerLView;\n}\n\n/**\n * Gets the element that a deferred block's trigger is pointing to.\n * @param triggerLView LView in which the trigger is defined.\n * @param triggerIndex Index at which the trigger element should've been rendered.\n */\nfunction getTriggerElement(triggerLView: LView, triggerIndex: number): Element {\n  const element = getNativeByIndex(HEADER_OFFSET + triggerIndex, triggerLView);\n  ngDevMode && assertElement(element);\n  return element as Element;\n}\n\n/**\n * Registers a DOM-node based trigger.\n * @param initialLView LView in which the defer block is rendered.\n * @param tNode TNode representing the defer block.\n * @param triggerIndex Index at which to find the trigger element.\n * @param walkUpTimes Number of times to go up/down in the view hierarchy to find the trigger.\n * @param registerFn Function that will register the DOM events.\n * @param callback Callback to be invoked when the trigger receives the event that should render\n *     the deferred block.\n */\nfunction registerDomTrigger(\n    initialLView: LView, tNode: TNode, triggerIndex: number, walkUpTimes: number|undefined,\n    registerFn: (element: Element, callback: VoidFunction, injector: Injector) => VoidFunction,\n    callback: VoidFunction) {\n  const injector = initialLView[INJECTOR]!;\n\n  // Assumption: the `afterRender` reference should be destroyed\n  // automatically so we don't need to keep track of it.\n  const afterRenderRef = afterRender(() => {\n    const lDetails = getLDeferBlockDetails(initialLView, tNode);\n    const renderedState = lDetails[DEFER_BLOCK_STATE];\n\n    // If the block was loaded before the trigger was resolved, we don't need to do anything.\n    if (renderedState !== DeferBlockInternalState.Initial &&\n        renderedState !== DeferBlockState.Placeholder) {\n      afterRenderRef.destroy();\n      return;\n    }\n\n    const triggerLView = getTriggerLView(initialLView, tNode, walkUpTimes);\n\n    // Keep polling until we resolve the trigger's LView.\n    // `afterRender` should stop automatically if the view is destroyed.\n    if (!triggerLView) {\n      return;\n    }\n\n    // It's possible that the trigger's view was destroyed before we resolved the trigger element.\n    if (triggerLView[FLAGS] & LViewFlags.Destroyed) {\n      afterRenderRef.destroy();\n      return;\n    }\n\n    // TODO: add integration with `DeferBlockCleanupManager`.\n    const element = getTriggerElement(triggerLView, triggerIndex);\n    const cleanup = registerFn(element, () => {\n      callback();\n      removeLViewOnDestroy(triggerLView, cleanup);\n      if (initialLView !== triggerLView) {\n        removeLViewOnDestroy(initialLView, cleanup);\n      }\n      cleanup();\n    }, injector);\n\n    afterRenderRef.destroy();\n    storeLViewOnDestroy(triggerLView, cleanup);\n\n    // Since the trigger and deferred block might be in different\n    // views, we have to register the callback in both locations.\n    if (initialLView !== triggerLView) {\n      storeLViewOnDestroy(initialLView, cleanup);\n    }\n  }, {injector});\n}\n\n/**\n * Helper function to schedule a callback to be invoked when a browser becomes idle.\n *\n * @param callback A function to be invoked when a browser becomes idle.\n * @param lView LView that hosts an instance of a defer block.\n * @param withLViewCleanup A flag that indicates whether a scheduled callback\n *           should be cancelled in case an LView is destroyed before a callback\n *           was invoked.\n */\nfunction onIdle(callback: VoidFunction, lView: LView, withLViewCleanup: boolean) {\n  const injector = lView[INJECTOR]!;\n  const scheduler = injector.get(OnIdleScheduler);\n  const cleanupFn = () => scheduler.remove(callback);\n  const wrappedCallback =\n      withLViewCleanup ? wrapWithLViewCleanup(callback, lView, cleanupFn) : callback;\n  scheduler.add(wrappedCallback);\n  return cleanupFn;\n}\n\n/**\n * Returns a function that captures a provided delay.\n * Invoking the returned function schedules a trigger.\n */\nfunction onTimer(delay: number) {\n  return (callback: VoidFunction, lView: LView, withLViewCleanup: boolean) =>\n             scheduleTimerTrigger(delay, callback, lView, withLViewCleanup);\n}\n\n/**\n * Schedules a callback to be invoked after a given timeout.\n *\n * @param delay A number of ms to wait until firing a callback.\n * @param callback A function to be invoked after a timeout.\n * @param lView LView that hosts an instance of a defer block.\n * @param withLViewCleanup A flag that indicates whether a scheduled callback\n *           should be cancelled in case an LView is destroyed before a callback\n *           was invoked.\n */\nfunction scheduleTimerTrigger(\n    delay: number, callback: VoidFunction, lView: LView, withLViewCleanup: boolean) {\n  const injector = lView[INJECTOR]!;\n  const scheduler = injector.get(TimerScheduler);\n  const cleanupFn = () => scheduler.remove(callback);\n  const wrappedCallback =\n      withLViewCleanup ? wrapWithLViewCleanup(callback, lView, cleanupFn) : callback;\n  scheduler.add(delay, wrappedCallback);\n  return cleanupFn;\n}\n\n/**\n * Wraps a given callback into a logic that registers a cleanup function\n * in the LView cleanup slot, to be invoked when an LView is destroyed.\n */\nfunction wrapWithLViewCleanup(\n    callback: VoidFunction, lView: LView, cleanup: VoidFunction): VoidFunction {\n  const wrappedCallback = () => {\n    callback();\n    removeLViewOnDestroy(lView, cleanup);\n  };\n  storeLViewOnDestroy(lView, cleanup);\n  return wrappedCallback;\n}\n\n/**\n * Calculates a data slot index for defer block info (either static or\n * instance-specific), given an index of a defer instruction.\n */\nfunction getDeferBlockDataIndex(deferBlockIndex: number) {\n  // Instance state is located at the *next* position\n  // after the defer block slot in an LView or TView.data.\n  return deferBlockIndex + 1;\n}\n\n/** Retrieves a defer block state from an LView, given a TNode that represents a block. */\nfunction getLDeferBlockDetails(lView: LView, tNode: TNode): LDeferBlockDetails {\n  const tView = lView[TVIEW];\n  const slotIndex = getDeferBlockDataIndex(tNode.index);\n  ngDevMode && assertIndexInDeclRange(tView, slotIndex);\n  return lView[slotIndex];\n}\n\n/** Stores a defer block instance state in LView. */\nfunction setLDeferBlockDetails(\n    lView: LView, deferBlockIndex: number, lDetails: LDeferBlockDetails) {\n  const tView = lView[TVIEW];\n  const slotIndex = getDeferBlockDataIndex(deferBlockIndex);\n  ngDevMode && assertIndexInDeclRange(tView, slotIndex);\n  lView[slotIndex] = lDetails;\n}\n\n/** Retrieves static info about a defer block, given a TView and a TNode that represents a block. */\nfunction getTDeferBlockDetails(tView: TView, tNode: TNode): TDeferBlockDetails {\n  const slotIndex = getDeferBlockDataIndex(tNode.index);\n  ngDevMode && assertIndexInDeclRange(tView, slotIndex);\n  return tView.data[slotIndex] as TDeferBlockDetails;\n}\n\n/** Stores a defer block static info in `TView.data`. */\nfunction setTDeferBlockDetails(\n    tView: TView, deferBlockIndex: number, deferBlockConfig: TDeferBlockDetails) {\n  const slotIndex = getDeferBlockDataIndex(deferBlockIndex);\n  ngDevMode && assertIndexInDeclRange(tView, slotIndex);\n  tView.data[slotIndex] = deferBlockConfig;\n}\n\nfunction getTemplateIndexForState(\n    newState: DeferBlockState, hostLView: LView, tNode: TNode): number|null {\n  const tView = hostLView[TVIEW];\n  const tDetails = getTDeferBlockDetails(tView, tNode);\n\n  switch (newState) {\n    case DeferBlockState.Complete:\n      return tDetails.primaryTmplIndex;\n    case DeferBlockState.Loading:\n      return tDetails.loadingTmplIndex;\n    case DeferBlockState.Error:\n      return tDetails.errorTmplIndex;\n    case DeferBlockState.Placeholder:\n      return tDetails.placeholderTmplIndex;\n    default:\n      ngDevMode && throwError(`Unexpected defer block state: ${newState}`);\n      return null;\n  }\n}\n\n/**\n * Transitions a defer block to the new state. Updates the  necessary\n * data structures and renders corresponding block.\n *\n * @param newState New state that should be applied to the defer block.\n * @param tNode TNode that represents a defer block.\n * @param lContainer Represents an instance of a defer block.\n */\nexport function renderDeferBlockState(\n    newState: DeferBlockState, tNode: TNode, lContainer: LContainer): void {\n  const hostLView = lContainer[PARENT];\n\n  // Check if this view is not destroyed. Since the loading process was async,\n  // the view might end up being destroyed by the time rendering happens.\n  if (isDestroyed(hostLView)) return;\n\n  // Make sure this TNode belongs to TView that represents host LView.\n  ngDevMode && assertTNodeForLView(tNode, hostLView);\n\n  const lDetails = getLDeferBlockDetails(hostLView, tNode);\n\n  ngDevMode && assertDefined(lDetails, 'Expected a defer block state defined');\n\n  const stateTmplIndex = getTemplateIndexForState(newState, hostLView, tNode);\n  // Note: we transition to the next state if the previous state was represented\n  // with a number that is less than the next state. For example, if the current\n  // state is \"loading\" (represented as `2`), we should not show a placeholder\n  // (represented as `1`).\n  if (lDetails[DEFER_BLOCK_STATE] < newState && stateTmplIndex !== null) {\n    lDetails[DEFER_BLOCK_STATE] = newState;\n    const hostTView = hostLView[TVIEW];\n    const adjustedIndex = stateTmplIndex + HEADER_OFFSET;\n    const tNode = getTNode(hostTView, adjustedIndex) as TContainerNode;\n\n    // There is only 1 view that can be present in an LContainer that\n    // represents a defer block, so always refer to the first one.\n    const viewIndex = 0;\n\n    removeLViewFromLContainer(lContainer, viewIndex);\n    const dehydratedView = findMatchingDehydratedView(lContainer, tNode.tView!.ssrId);\n    const embeddedLView = createAndRenderEmbeddedLView(hostLView, tNode, null, {dehydratedView});\n    addLViewToLContainer(\n        lContainer, embeddedLView, viewIndex, shouldAddViewToDom(tNode, dehydratedView));\n  }\n}\n\n/**\n * Trigger prefetching of dependencies for a defer block.\n *\n * @param tDetails Static information about this defer block.\n * @param lView LView of a host view.\n */\nexport function triggerPrefetching(tDetails: TDeferBlockDetails, lView: LView) {\n  if (lView[INJECTOR] && shouldTriggerDeferBlock(lView[INJECTOR]!)) {\n    triggerResourceLoading(tDetails, lView);\n  }\n}\n\n/**\n * Trigger loading of defer block dependencies if the process hasn't started yet.\n *\n * @param tDetails Static information about this defer block.\n * @param lView LView of a host view.\n */\nexport function triggerResourceLoading(tDetails: TDeferBlockDetails, lView: LView) {\n  const injector = lView[INJECTOR]!;\n  const tView = lView[TVIEW];\n\n  if (tDetails.loadingState !== DeferDependenciesLoadingState.NOT_STARTED) {\n    // If the loading status is different from initial one, it means that\n    // the loading of dependencies is in progress and there is nothing to do\n    // in this function. All details can be obtained from the `tDetails` object.\n    return;\n  }\n\n  const primaryBlockTNode = getPrimaryBlockTNode(tView, tDetails);\n\n  // Switch from NOT_STARTED -> IN_PROGRESS state.\n  tDetails.loadingState = DeferDependenciesLoadingState.IN_PROGRESS;\n\n  // Check if dependency function interceptor is configured.\n  const deferDependencyInterceptor =\n      injector.get(DEFER_BLOCK_DEPENDENCY_INTERCEPTOR, null, {optional: true});\n\n  const dependenciesFn = deferDependencyInterceptor ?\n      deferDependencyInterceptor.intercept(tDetails.dependencyResolverFn) :\n      tDetails.dependencyResolverFn;\n\n  // The `dependenciesFn` might be `null` when all dependencies within\n  // a given defer block were eagerly references elsewhere in a file,\n  // thus no dynamic `import()`s were produced.\n  if (!dependenciesFn) {\n    tDetails.loadingPromise = Promise.resolve().then(() => {\n      tDetails.loadingState = DeferDependenciesLoadingState.COMPLETE;\n    });\n    return;\n  }\n\n  // Defer block may have multiple prefetch triggers. Once the loading\n  // starts, invoke all clean functions, since they are no longer needed.\n  invokeTDetailsCleanup(injector, tDetails);\n\n  // Start downloading of defer block dependencies.\n  tDetails.loadingPromise = Promise.allSettled(dependenciesFn()).then(results => {\n    let failed = false;\n    const directiveDefs: DirectiveDefList = [];\n    const pipeDefs: PipeDefList = [];\n\n    for (const result of results) {\n      if (result.status === 'fulfilled') {\n        const dependency = result.value;\n        const directiveDef = getComponentDef(dependency) || getDirectiveDef(dependency);\n        if (directiveDef) {\n          directiveDefs.push(directiveDef);\n        } else {\n          const pipeDef = getPipeDef(dependency);\n          if (pipeDef) {\n            pipeDefs.push(pipeDef);\n          }\n        }\n      } else {\n        failed = true;\n        break;\n      }\n    }\n\n    // Loading is completed, we no longer need this Promise.\n    tDetails.loadingPromise = null;\n\n    if (failed) {\n      tDetails.loadingState = DeferDependenciesLoadingState.FAILED;\n    } else {\n      tDetails.loadingState = DeferDependenciesLoadingState.COMPLETE;\n\n      // Update directive and pipe registries to add newly downloaded dependencies.\n      const primaryBlockTView = primaryBlockTNode.tView!;\n      if (directiveDefs.length > 0) {\n        primaryBlockTView.directiveRegistry =\n            addDepsToRegistry<DirectiveDefList>(primaryBlockTView.directiveRegistry, directiveDefs);\n      }\n      if (pipeDefs.length > 0) {\n        primaryBlockTView.pipeRegistry =\n            addDepsToRegistry<PipeDefList>(primaryBlockTView.pipeRegistry, pipeDefs);\n      }\n    }\n  });\n}\n\n/**\n * Adds downloaded dependencies into a directive or a pipe registry,\n * making sure that a dependency doesn't yet exist in the registry.\n */\nfunction addDepsToRegistry<T extends DependencyDef[]>(currentDeps: T|null, newDeps: T): T {\n  if (!currentDeps || currentDeps.length === 0) {\n    return newDeps;\n  }\n\n  const currentDepSet = new Set(currentDeps);\n  for (const dep of newDeps) {\n    currentDepSet.add(dep);\n  }\n\n  // If `currentDeps` is the same length, there were no new deps and can\n  // return the original array.\n  return (currentDeps.length === currentDepSet.size) ? currentDeps : Array.from(currentDepSet) as T;\n}\n\n/** Utility function to render placeholder content (if present) */\nfunction renderPlaceholder(lView: LView, tNode: TNode) {\n  const lContainer = lView[tNode.index];\n  ngDevMode && assertLContainer(lContainer);\n\n  renderDeferBlockState(DeferBlockState.Placeholder, tNode, lContainer);\n}\n\n/**\n * Subscribes to the \"loading\" Promise and renders corresponding defer sub-block,\n * based on the loading results.\n *\n * @param lContainer Represents an instance of a defer block.\n * @param tNode Represents defer block info shared across all instances.\n */\nfunction renderDeferStateAfterResourceLoading(\n    tDetails: TDeferBlockDetails, tNode: TNode, lContainer: LContainer) {\n  ngDevMode &&\n      assertDefined(\n          tDetails.loadingPromise, 'Expected loading Promise to exist on this defer block');\n\n  tDetails.loadingPromise!.then(() => {\n    if (tDetails.loadingState === DeferDependenciesLoadingState.COMPLETE) {\n      ngDevMode && assertDeferredDependenciesLoaded(tDetails);\n\n      // Everything is loaded, show the primary block content\n      renderDeferBlockState(DeferBlockState.Complete, tNode, lContainer);\n\n    } else if (tDetails.loadingState === DeferDependenciesLoadingState.FAILED) {\n      renderDeferBlockState(DeferBlockState.Error, tNode, lContainer);\n    }\n  });\n}\n\n/** Retrieves a TNode that represents main content of a defer block. */\nfunction getPrimaryBlockTNode(tView: TView, tDetails: TDeferBlockDetails): TContainerNode {\n  const adjustedIndex = tDetails.primaryTmplIndex + HEADER_OFFSET;\n  return getTNode(tView, adjustedIndex) as TContainerNode;\n}\n\n/**\n * Attempts to trigger loading of defer block dependencies.\n * If the block is already in a loading, completed or an error state -\n * no additional actions are taken.\n */\nfunction triggerDeferBlock(lView: LView, tNode: TNode) {\n  const tView = lView[TVIEW];\n  const lContainer = lView[tNode.index];\n  const injector = lView[INJECTOR]!;\n  ngDevMode && assertLContainer(lContainer);\n\n  if (!shouldTriggerDeferBlock(injector)) return;\n\n  const tDetails = getTDeferBlockDetails(tView, tNode);\n\n  // Condition is triggered, try to render loading state and start downloading.\n  // Note: if a block is in a loading, completed or an error state, this call would be a noop.\n  renderDeferBlockState(DeferBlockState.Loading, tNode, lContainer);\n\n  switch (tDetails.loadingState) {\n    case DeferDependenciesLoadingState.NOT_STARTED:\n      triggerResourceLoading(tDetails, lView);\n\n      // The `loadingState` might have changed to \"loading\".\n      if ((tDetails.loadingState as DeferDependenciesLoadingState) ===\n          DeferDependenciesLoadingState.IN_PROGRESS) {\n        renderDeferStateAfterResourceLoading(tDetails, tNode, lContainer);\n      }\n      break;\n    case DeferDependenciesLoadingState.IN_PROGRESS:\n      renderDeferStateAfterResourceLoading(tDetails, tNode, lContainer);\n      break;\n    case DeferDependenciesLoadingState.COMPLETE:\n      ngDevMode && assertDeferredDependenciesLoaded(tDetails);\n      renderDeferBlockState(DeferBlockState.Complete, tNode, lContainer);\n      break;\n    case DeferDependenciesLoadingState.FAILED:\n      renderDeferBlockState(DeferBlockState.Error, tNode, lContainer);\n      break;\n    default:\n      if (ngDevMode) {\n        throwError('Unknown defer block state');\n      }\n  }\n}\n\n/**\n * Asserts whether all dependencies for a defer block are loaded.\n * Always run this function (in dev mode) before rendering a defer\n * block in completed state.\n */\nfunction assertDeferredDependenciesLoaded(tDetails: TDeferBlockDetails) {\n  assertEqual(\n      tDetails.loadingState, DeferDependenciesLoadingState.COMPLETE,\n      'Expecting all deferred dependencies to be loaded.');\n}\n\n/**\n * **INTERNAL**, avoid referencing it in application code.\n *\n * Describes a helper class that allows to intercept a call to retrieve current\n * dependency loading function and replace it with a different implementation.\n * This interceptor class is needed to allow testing blocks in different states\n * by simulating loading response.\n */\nexport interface DeferBlockDependencyInterceptor {\n  /**\n   * Invoked for each defer block when dependency loading function is accessed.\n   */\n  intercept(dependencyFn: DependencyResolverFn|null): DependencyResolverFn|null;\n\n  /**\n   * Allows to configure an interceptor function.\n   */\n  setInterceptor(interceptorFn: (current: DependencyResolverFn) => DependencyResolverFn): void;\n}\n\n/**\n * **INTERNAL**, avoid referencing it in application code.\n *\n * Injector token that allows to provide `DeferBlockDependencyInterceptor` class\n * implementation.\n */\nexport const DEFER_BLOCK_DEPENDENCY_INTERCEPTOR =\n    new InjectionToken<DeferBlockDependencyInterceptor>(\n        ngDevMode ? 'DEFER_BLOCK_DEPENDENCY_INTERCEPTOR' : '');\n\n/**\n * Determines if a given value matches the expected structure of a defer block\n *\n * We can safely rely on the primaryTmplIndex because every defer block requires\n * that a primary template exists. All the other template options are optional.\n */\nfunction isTDeferBlockDetails(value: unknown): value is TDeferBlockDetails {\n  return (typeof value === 'object') &&\n      (typeof (value as TDeferBlockDetails).primaryTmplIndex === 'number');\n}\n\n/**\n * Internal token used for configuring defer block behavior.\n */\nexport const DEFER_BLOCK_CONFIG =\n    new InjectionToken<DeferBlockConfig>(ngDevMode ? 'DEFER_BLOCK_CONFIG' : '');\n\n/**\n * Defer block instance for testing.\n */\nexport interface DeferBlockDetails {\n  lContainer: LContainer;\n  lView: LView;\n  tNode: TNode;\n  tDetails: TDeferBlockDetails;\n}\n\n/**\n * Retrieves all defer blocks in a given LView.\n *\n * @param lView lView with defer blocks\n * @param deferBlocks defer block aggregator array\n */\nexport function getDeferBlocks(lView: LView, deferBlocks: DeferBlockDetails[]) {\n  const tView = lView[TVIEW];\n  for (let i = HEADER_OFFSET; i < tView.bindingStartIndex; i++) {\n    if (isLContainer(lView[i])) {\n      const lContainer = lView[i];\n      // An LContainer may represent an instance of a defer block, in which case\n      // we store it as a result. Otherwise, keep iterating over LContainer views and\n      // look for defer blocks.\n      const isLast = i === tView.bindingStartIndex - 1;\n      if (!isLast) {\n        const tNode = tView.data[i] as TNode;\n        const tDetails = getTDeferBlockDetails(tView, tNode);\n        if (isTDeferBlockDetails(tDetails)) {\n          deferBlocks.push({lContainer, lView, tNode, tDetails});\n          // This LContainer represents a defer block, so we exit\n          // this iteration and don't inspect views in this LContainer.\n          continue;\n        }\n      }\n      for (let i = CONTAINER_HEADER_OFFSET; i < lContainer.length; i++) {\n        getDeferBlocks(lContainer[i] as LView, deferBlocks);\n      }\n    } else if (isLView(lView[i])) {\n      // This is a component, enter the `getDeferBlocks` recursively.\n      getDeferBlocks(lView[i], deferBlocks);\n    }\n  }\n}\n\n/**\n * Registers a cleanup function associated with a prefetching trigger\n * of a given defer block.\n */\nfunction registerTDetailsCleanup(\n    injector: Injector, tDetails: TDeferBlockDetails, key: string, cleanupFn: VoidFunction) {\n  injector.get(DeferBlockCleanupManager).add(tDetails, key, cleanupFn);\n}\n\n/**\n * Invokes all registered prefetch cleanup triggers\n * and removes all cleanup functions afterwards.\n */\nfunction invokeTDetailsCleanup(injector: Injector, tDetails: TDeferBlockDetails) {\n  injector.get(DeferBlockCleanupManager).cleanup(tDetails);\n}\n\n/**\n * Internal service to keep track of cleanup functions associated\n * with defer blocks. This class is used to manage cleanup functions\n * created for prefetching triggers.\n */\nclass DeferBlockCleanupManager {\n  private blocks = new Map<TDeferBlockDetails, Map<string, VoidFunction[]>>();\n\n  add(tDetails: TDeferBlockDetails, key: string, callback: VoidFunction) {\n    if (!this.blocks.has(tDetails)) {\n      this.blocks.set(tDetails, new Map());\n    }\n    const block = this.blocks.get(tDetails)!;\n    if (!block.has(key)) {\n      block.set(key, []);\n    }\n    const callbacks = block.get(key)!;\n    callbacks.push(callback);\n  }\n\n  has(tDetails: TDeferBlockDetails, key: string): boolean {\n    return !!this.blocks.get(tDetails)?.has(key);\n  }\n\n  cleanup(tDetails: TDeferBlockDetails) {\n    const block = this.blocks.get(tDetails);\n    if (block) {\n      for (const callbacks of Object.values(block)) {\n        for (const callback of callbacks) {\n          callback();\n        }\n      }\n      this.blocks.delete(tDetails);\n    }\n  }\n\n  ngOnDestroy() {\n    for (const [block] of this.blocks) {\n      this.cleanup(block);\n    }\n    this.blocks.clear();\n  }\n\n  /** @nocollapse */\n  static ɵprov = /** @pureOrBreakMyCode */ ɵɵdefineInjectable({\n    token: DeferBlockCleanupManager,\n    providedIn: 'root',\n    factory: () => new DeferBlockCleanupManager(),\n  });\n}\n\n/**\n * Use shims for the `requestIdleCallback` and `cancelIdleCallback` functions for\n * environments where those functions are not available (e.g. Node.js and Safari).\n *\n * Note: we wrap the `requestIdleCallback` call into a function, so that it can be\n * overridden/mocked in test environment and picked up by the runtime code.\n */\nconst _requestIdleCallback = () =>\n    typeof requestIdleCallback !== 'undefined' ? requestIdleCallback : setTimeout;\nconst _cancelIdleCallback = () =>\n    typeof requestIdleCallback !== 'undefined' ? cancelIdleCallback : clearTimeout;\n\n/**\n * Helper service to schedule `requestIdleCallback`s for batches of defer blocks,\n * to avoid calling `requestIdleCallback` for each defer block (e.g. if\n * defer blocks are defined inside a for loop).\n */\nclass OnIdleScheduler {\n  // Indicates whether current callbacks are being invoked.\n  executingCallbacks = false;\n\n  // Currently scheduled idle callback id.\n  idleId: number|null = null;\n\n  // Set of callbacks to be invoked next.\n  current = new Set<VoidFunction>();\n\n  // Set of callbacks collected while invoking current set of callbacks.\n  // Those callbacks are scheduled for the next idle period.\n  deferred = new Set<VoidFunction>();\n\n  ngZone = inject(NgZone);\n\n  requestIdleCallback = _requestIdleCallback().bind(globalThis);\n  cancelIdleCallback = _cancelIdleCallback().bind(globalThis);\n\n  add(callback: VoidFunction) {\n    const target = this.executingCallbacks ? this.deferred : this.current;\n    target.add(callback);\n    if (this.idleId === null) {\n      this.scheduleIdleCallback();\n    }\n  }\n\n  remove(callback: VoidFunction) {\n    this.current.delete(callback);\n    this.deferred.delete(callback);\n  }\n\n  private scheduleIdleCallback() {\n    const callback = () => {\n      this.cancelIdleCallback(this.idleId!);\n      this.idleId = null;\n\n      this.executingCallbacks = true;\n\n      for (const callback of this.current) {\n        callback();\n      }\n      this.current.clear();\n\n      this.executingCallbacks = false;\n\n      // If there are any callbacks added during an invocation\n      // of the current ones - make them \"current\" and schedule\n      // a new idle callback.\n      if (this.deferred.size > 0) {\n        for (const callback of this.deferred) {\n          this.current.add(callback);\n        }\n        this.deferred.clear();\n        this.scheduleIdleCallback();\n      }\n    };\n    // Ensure that the callback runs in the NgZone since\n    // the `requestIdleCallback` is not currently patched by Zone.js.\n    this.idleId = this.requestIdleCallback(() => this.ngZone.run(callback)) as number;\n  }\n\n  ngOnDestroy() {\n    if (this.idleId !== null) {\n      this.cancelIdleCallback(this.idleId);\n      this.idleId = null;\n    }\n    this.current.clear();\n    this.deferred.clear();\n  }\n\n  /** @nocollapse */\n  static ɵprov = /** @pureOrBreakMyCode */ ɵɵdefineInjectable({\n    token: OnIdleScheduler,\n    providedIn: 'root',\n    factory: () => new OnIdleScheduler(),\n  });\n}\n\n/**\n * Helper service to schedule `setTimeout`s for batches of defer blocks,\n * to avoid calling `setTimeout` for each defer block (e.g. if defer blocks\n * are created inside a for loop).\n */\nclass TimerScheduler {\n  // Indicates whether current callbacks are being invoked.\n  executingCallbacks = false;\n\n  // Currently scheduled `setTimeout` id.\n  timeoutId: number|null = null;\n\n  // When currently scheduled timer would fire.\n  invokeTimerAt: number|null = null;\n\n  // List of callbacks to be invoked.\n  // For each callback we also store a timestamp on when the callback\n  // should be invoked. We store timestamps and callback functions\n  // in a flat array to avoid creating new objects for each entry.\n  // [timestamp1, callback1, timestamp2, callback2, ...]\n  current: Array<number|VoidFunction> = [];\n\n  // List of callbacks collected while invoking current set of callbacks.\n  // Those callbacks are added to the \"current\" queue at the end of\n  // the current callback invocation. The shape of this list is the same\n  // as the shape of the `current` list.\n  deferred: Array<number|VoidFunction> = [];\n\n  add(delay: number, callback: VoidFunction) {\n    const target = this.executingCallbacks ? this.deferred : this.current;\n    this.addToQueue(target, Date.now() + delay, callback);\n    this.scheduleTimer();\n  }\n\n  remove(callback: VoidFunction) {\n    const callbackIndex = this.removeFromQueue(this.current, callback);\n    if (callbackIndex === -1) {\n      // Try cleaning up deferred queue only in case\n      // we didn't find a callback in the \"current\" queue.\n      this.removeFromQueue(this.deferred, callback);\n    }\n  }\n\n  private addToQueue(target: Array<number|VoidFunction>, invokeAt: number, callback: VoidFunction) {\n    let insertAtIndex = target.length;\n    for (let i = 0; i < target.length; i += 2) {\n      const invokeQueuedCallbackAt = target[i] as number;\n      if (invokeQueuedCallbackAt > invokeAt) {\n        // We've reached a first timer that is scheduled\n        // for a later time than what we are trying to insert.\n        // This is the location at which we need to insert,\n        // no need to iterate further.\n        insertAtIndex = i;\n        break;\n      }\n    }\n    arrayInsert2(target, insertAtIndex, invokeAt, callback);\n  }\n\n  private removeFromQueue(target: Array<number|VoidFunction>, callback: VoidFunction) {\n    let index = -1;\n    for (let i = 0; i < target.length; i += 2) {\n      const queuedCallback = target[i + 1];\n      if (queuedCallback === callback) {\n        index = i;\n        break;\n      }\n    }\n    if (index > -1) {\n      // Remove 2 elements: a timestamp slot and\n      // the following slot with a callback function.\n      arraySplice(target, index, 2);\n    }\n    return index;\n  }\n\n  private scheduleTimer() {\n    const callback = () => {\n      clearTimeout(this.timeoutId!);\n      this.timeoutId = null;\n\n      this.executingCallbacks = true;\n\n      // Invoke callbacks that were scheduled to run\n      // before the current time.\n      let now = Date.now();\n      let lastCallbackIndex: number|null = null;\n      for (let i = 0; i < this.current.length; i += 2) {\n        const invokeAt = this.current[i] as number;\n        const callback = this.current[i + 1] as VoidFunction;\n        if (invokeAt <= now) {\n          callback();\n          // Point at the invoked callback function, which is located\n          // after the timestamp.\n          lastCallbackIndex = i + 1;\n        } else {\n          // We've reached a timer that should not be invoked yet.\n          break;\n        }\n      }\n      if (lastCallbackIndex !== null) {\n        // If last callback index is `null` - no callbacks were invoked,\n        // so no cleanup is needed. Otherwise, remove invoked callbacks\n        // from the queue.\n        arraySplice(this.current, 0, lastCallbackIndex + 1);\n      }\n\n      this.executingCallbacks = false;\n\n      // If there are any callbacks added during an invocation\n      // of the current ones - move them over to the \"current\"\n      // queue.\n      if (this.deferred.length > 0) {\n        for (let i = 0; i < this.deferred.length; i += 2) {\n          const invokeAt = this.deferred[i] as number;\n          const callback = this.deferred[i + 1] as VoidFunction;\n          this.addToQueue(this.current, invokeAt, callback);\n        }\n        this.deferred.length = 0;\n      }\n      this.scheduleTimer();\n    };\n\n    // Avoid running timer callbacks more than once per\n    // average frame duration. This is needed for better\n    // batching and to avoid kicking off excessive change\n    // detection cycles.\n    const FRAME_DURATION_MS = 16;  // 1000ms / 60fps\n\n    if (this.current.length > 0) {\n      const now = Date.now();\n      // First element in the queue points at the timestamp\n      // of the first (earliest) event.\n      const invokeAt = this.current[0] as number;\n      if (!this.timeoutId ||\n          // Reschedule a timer in case a queue contains an item with\n          // an earlier timestamp and the delta is more than an average\n          // frame duration.\n          (this.invokeTimerAt && (this.invokeTimerAt - invokeAt > FRAME_DURATION_MS))) {\n        if (this.timeoutId !== null) {\n          // There was a timeout already, but an earlier event was added\n          // into the queue. In this case we drop an old timer and setup\n          // a new one with an updated (smaller) timeout.\n          clearTimeout(this.timeoutId);\n          this.timeoutId = null;\n        }\n        const timeout = Math.max(invokeAt - now, FRAME_DURATION_MS);\n        this.invokeTimerAt = invokeAt;\n        this.timeoutId = setTimeout(callback, timeout) as unknown as number;\n      }\n    }\n  }\n\n  ngOnDestroy() {\n    if (this.timeoutId !== null) {\n      clearTimeout(this.timeoutId);\n      this.timeoutId = null;\n    }\n    this.current.length = 0;\n    this.deferred.length = 0;\n  }\n\n  /** @nocollapse */\n  static ɵprov = /** @pureOrBreakMyCode */ ɵɵdefineInjectable({\n    token: TimerScheduler,\n    providedIn: 'root',\n    factory: () => new TimerScheduler(),\n  });\n}\n"]}