@angular/core 17.0.0-next.8 → 17.0.0-rc.0

package/fesm2022/core.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v17.0.0-next.8
+ * @license Angular v17.0.0-rc.0
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -2107,9 +2107,6 @@ const REACTIVE_HOST_BINDING_CONSUMER = 24;
  * there should be no need to refer to `HEADER_OFFSET` anywhere else.
  */
 const HEADER_OFFSET = 25;
-// Note: This hack is necessary so we don't erroneously get a circular dependency
-// failure based on types.
-const unusedValueExportToPlacateAjd$4 = 1;
 
 /**
  * Special location which allows easy identification of type. If we have an array which was
@@ -2147,9 +2144,6 @@ const DEHYDRATED_VIEWS = 10;
  * remove views from the DOM when they are no longer required.
  */
 const CONTAINER_HEADER_OFFSET = 11;
-// Note: This hack is necessary so we don't erroneously get a circular dependency
-// failure based on types.
-const unusedValueExportToPlacateAjd$3 = 1;
 
 /**
  * True if `value` is `LView`.
@@ -3576,9 +3570,6 @@ class NodeInjectorFactory {
 function isFactory(obj) {
     return obj instanceof NodeInjectorFactory;
 }
-// Note: This hack is necessary so we don't erroneously get a circular dependency
-// failure based on types.
-const unusedValueExportToPlacateAjd$2 = 1;
 
 /**
  * Converts `TNodeType` into human readable text.
@@ -3610,9 +3601,6 @@ function isTNodeShape(value) {
             typeof value.insertBeforeIndex === 'number' ||
             Array.isArray(value.insertBeforeIndex));
 }
-// Note: This hack is necessary so we don't erroneously get a circular dependency
-// failure based on types.
-const unusedValueExportToPlacateAjd$1 = 1;
 /**
  * Returns `true` if the `TNode` has a directive which has `@Input()` for `class` binding.
  *
@@ -9997,7 +9985,7 @@ const DISCONNECTED_NODES = 'd';
  * The name of the key used in the TransferState collection,
  * where hydration information is located.
  */
-const TRANSFER_STATE_TOKEN_ID = '__ɵnghData__';
+const TRANSFER_STATE_TOKEN_ID = '__nghData__';
 /**
  * Lookup key used to reference DOM hydration data (ngh) in `TransferState`.
  */
@@ -10429,7 +10417,7 @@ class Version {
 /**
  * @publicApi
  */
-const VERSION = new Version('17.0.0-next.8');
+const VERSION = new Version('17.0.0-rc.0');
 
 // This default value is when checking the hierarchy for a token.
 //
@@ -11410,6 +11398,26 @@ var AfterRenderPhase;
      */
     AfterRenderPhase[AfterRenderPhase["Read"] = 3] = "Read";
 })(AfterRenderPhase || (AfterRenderPhase = {}));
+/**
+ * Register a callback to run once before any userspace `afterRender` or
+ * `afterNextRender` callbacks.
+ *
+ * This function should almost always be used instead of `afterRender` or
+ * `afterNextRender` for implementing framework functionality. Consider:
+ *
+ *   1.) `AfterRenderPhase.EarlyRead` is intended to be used for implementing
+ *       custom layout. If the framework itself mutates the DOM after *any*
+ *       `AfterRenderPhase.EarlyRead` callbacks are run, the phase can no
+ *       longer reliably serve its purpose.
+ *
+ *   2.) Importing `afterRender` in the framework can reduce the ability for it
+ *       to be tree-shaken, and the framework shouldn't need much of the behavior.
+ */
+function internalAfterNextRender(callback, options) {
+    const injector = options?.injector ?? inject(Injector);
+    const afterRenderEventManager = injector.get(AfterRenderEventManager);
+    afterRenderEventManager.internalCallbacks.push(callback);
+}
 /**
  * Register a callback to be invoked each time the application
  * finishes rendering.
@@ -11640,6 +11648,8 @@ class AfterRenderEventManager {
         this.renderDepth = 0;
         /* @internal */
         this.handler = null;
+        /* @internal */
+        this.internalCallbacks = [];
     }
     /**
      * Mark the beginning of a render operation (i.e. CD cycle).
@@ -11657,12 +11667,20 @@ class AfterRenderEventManager {
         ngDevMode && assertGreaterThan(this.renderDepth, 0, 'renderDepth must be greater than 0');
         this.renderDepth--;
         if (this.renderDepth === 0) {
+            // Note: internal callbacks power `internalAfterNextRender`. Since internal callbacks
+            // are fairly trivial, they are kept separate so that `AfterRenderCallbackHandlerImpl`
+            // can still be tree-shaken unless used by the application.
+            for (const callback of this.internalCallbacks) {
+                callback();
+            }
+            this.internalCallbacks.length = 0;
             this.handler?.execute();
         }
     }
     ngOnDestroy() {
         this.handler?.destroy();
         this.handler = null;
+        this.internalCallbacks.length = 0;
     }
     /** @nocollapse */
     static { this.ɵprov = ɵɵdefineInjectable({
@@ -11840,11 +11858,6 @@ function getExpressionChangedErrorDetails(lView, bindingIndex, oldValue, newValu
 }
 
 let currentConsumer = null;
-function setLViewForConsumer(node, lView) {
-    (typeof ngDevMode === 'undefined' || ngDevMode) &&
-        assertEqual(node.lView, null, 'Consumer already associated with a view.');
-    node.lView = lView;
-}
 /**
  * Create a new template consumer pointing at the specified LView.
  * Sometimes, a previously created consumer may be reused, in order to save on allocations. In that
@@ -18264,6 +18277,17 @@ class LiveCollection {
         this.attach(newIdx, this.detach(prevIndex));
     }
 }
+function valuesMatching(liveIdx, liveValue, newIdx, newValue, trackBy) {
+    if (liveIdx === newIdx && Object.is(liveValue, newValue)) {
+        // matching and no value identity to update
+        return 1;
+    }
+    else if (Object.is(trackBy(liveIdx, liveValue), trackBy(newIdx, newValue))) {
+        // matching but requires value identity update
+        return -1;
+    }
+    return 0;
+}
 /**
  * The live collection reconciliation algorithm that perform various in-place operations, so it
  * reflects the content of the new (incoming) collection.
@@ -18296,40 +18320,47 @@ function reconcile(liveCollection, newCollection, trackByFn) {
         let newEndIdx = newCollection.length - 1;
         while (liveStartIdx <= liveEndIdx && liveStartIdx <= newEndIdx) {
             // compare from the beginning
-            const liveStartKey = liveCollection.key(liveStartIdx);
+            const liveStartValue = liveCollection.at(liveStartIdx);
             const newStartValue = newCollection[liveStartIdx];
-            const newStartKey = trackByFn(liveStartIdx, newStartValue);
-            if (Object.is(liveStartKey, newStartKey)) {
-                liveCollection.updateValue(liveStartIdx, newStartValue);
+            const isStartMatching = valuesMatching(liveStartIdx, liveStartValue, liveStartIdx, newStartValue, trackByFn);
+            if (isStartMatching !== 0) {
+                if (isStartMatching < 0) {
+                    liveCollection.updateValue(liveStartIdx, newStartValue);
+                }
                 liveStartIdx++;
                 continue;
             }
             // compare from the end
             // TODO(perf): do _all_ the matching from the end
-            const liveEndKey = liveCollection.key(liveEndIdx);
-            const newEndItem = newCollection[newEndIdx];
-            const newEndKey = trackByFn(newEndIdx, newEndItem);
-            if (Object.is(liveEndKey, newEndKey)) {
-                liveCollection.updateValue(liveEndIdx, newEndItem);
+            const liveEndValue = liveCollection.at(liveEndIdx);
+            const newEndValue = newCollection[newEndIdx];
+            const isEndMatching = valuesMatching(liveEndIdx, liveEndValue, newEndIdx, newEndValue, trackByFn);
+            if (isEndMatching !== 0) {
+                if (isEndMatching < 0) {
+                    liveCollection.updateValue(liveEndIdx, newEndValue);
+                }
                 liveEndIdx--;
                 newEndIdx--;
                 continue;
             }
-            // Detect swap / moves:
-            if (Object.is(newStartKey, liveEndKey) && Object.is(newEndKey, liveStartKey)) {
-                // swap on both ends;
-                liveCollection.swap(liveStartIdx, liveEndIdx);
-                liveCollection.updateValue(liveStartIdx, newStartValue);
-                liveCollection.updateValue(liveEndIdx, newEndItem);
-                newEndIdx--;
-                liveStartIdx++;
-                liveEndIdx--;
-                continue;
-            }
-            else if (Object.is(newStartKey, liveEndKey)) {
-                // the new item is the same as the live item with the end pointer - this is a move forward
-                // to an earlier index;
-                liveCollection.move(liveEndIdx, liveStartIdx);
+            // Detect swap and moves:
+            const liveStartKey = trackByFn(liveStartIdx, liveStartValue);
+            const liveEndKey = trackByFn(liveEndIdx, liveEndValue);
+            const newStartKey = trackByFn(liveStartIdx, newStartValue);
+            if (Object.is(newStartKey, liveEndKey)) {
+                const newEndKey = trackByFn(newEndIdx, newEndValue);
+                // detect swap on both ends;
+                if (Object.is(newEndKey, liveStartKey)) {
+                    liveCollection.swap(liveStartIdx, liveEndIdx);
+                    liveCollection.updateValue(liveEndIdx, newEndValue);
+                    newEndIdx--;
+                    liveEndIdx--;
+                }
+                else {
+                    // the new item is the same as the live item with the end pointer - this is a move forward
+                    // to an earlier index;
+                    liveCollection.move(liveEndIdx, liveStartIdx);
+                }
                 liveCollection.updateValue(liveStartIdx, newStartValue);
                 liveStartIdx++;
                 continue;
@@ -18337,7 +18368,8 @@ function reconcile(liveCollection, newCollection, trackByFn) {
             // Fallback to the slow path: we need to learn more about the content of the live and new
             // collections.
             detachedItems ??= new MultiMap();
-            liveKeysInTheFuture ??= initLiveItemsInTheFuture(liveCollection, liveStartIdx, liveEndIdx);
+            liveKeysInTheFuture ??=
+                initLiveItemsInTheFuture(liveCollection, liveStartIdx, liveEndIdx, trackByFn);
             // Check if I'm inserting a previously detached item: if so, attach it here
             if (attachPreviouslyDetached(liveCollection, detachedItems, liveStartIdx, newStartKey)) {
                 liveCollection.updateValue(liveStartIdx, newStartValue);
@@ -18371,19 +18403,23 @@ function reconcile(liveCollection, newCollection, trackByFn) {
         const newCollectionIterator = newCollection[Symbol.iterator]();
         let newIterationResult = newCollectionIterator.next();
         while (!newIterationResult.done && liveStartIdx <= liveEndIdx) {
+            const liveValue = liveCollection.at(liveStartIdx);
             const newValue = newIterationResult.value;
-            const newKey = trackByFn(liveStartIdx, newValue);
-            const liveKey = liveCollection.key(liveStartIdx);
-            if (Object.is(liveKey, newKey)) {
-                // found a match - move on
-                liveCollection.updateValue(liveStartIdx, newValue);
+            const isStartMatching = valuesMatching(liveStartIdx, liveValue, liveStartIdx, newValue, trackByFn);
+            if (isStartMatching !== 0) {
+                // found a match - move on, but update value
+                if (isStartMatching < 0) {
+                    liveCollection.updateValue(liveStartIdx, newValue);
+                }
                 liveStartIdx++;
                 newIterationResult = newCollectionIterator.next();
             }
             else {
                 detachedItems ??= new MultiMap();
-                liveKeysInTheFuture ??= initLiveItemsInTheFuture(liveCollection, liveStartIdx, liveEndIdx);
+                liveKeysInTheFuture ??=
+                    initLiveItemsInTheFuture(liveCollection, liveStartIdx, liveEndIdx, trackByFn);
                 // Check if I'm inserting a previously detached item: if so, attach it here
+                const newKey = trackByFn(liveStartIdx, newValue);
                 if (attachPreviouslyDetached(liveCollection, detachedItems, liveStartIdx, newKey)) {
                     liveCollection.updateValue(liveStartIdx, newValue);
                     liveStartIdx++;
@@ -18398,6 +18434,7 @@ function reconcile(liveCollection, newCollection, trackByFn) {
                 }
                 else {
                     // it is a move forward - detach the current item without advancing in collections
+                    const liveKey = trackByFn(liveStartIdx, liveValue);
                     detachedItems.set(liveKey, liveCollection.detach(liveStartIdx));
                     liveEndIdx--;
                 }
@@ -18435,10 +18472,10 @@ function createOrAttach(liveCollection, detachedItems, trackByFn, index, value)
         liveCollection.updateValue(index, value);
     }
 }
-function initLiveItemsInTheFuture(liveCollection, start, end) {
+function initLiveItemsInTheFuture(liveCollection, start, end, trackByFn) {
     const keys = new Set();
     for (let i = start; i <= end; i++) {
-        keys.add(liveCollection.key(i));
+        keys.add(trackByFn(i, liveCollection.at(i)));
     }
     return keys;
 }
@@ -19150,9 +19187,10 @@ function ɵɵrepeaterTrackByIdentity(_, value) {
     return value;
 }
 class RepeaterMetadata {
-    constructor(hasEmptyBlock, trackByFn) {
+    constructor(hasEmptyBlock, trackByFn, liveCollection) {
         this.hasEmptyBlock = hasEmptyBlock;
         this.trackByFn = trackByFn;
+        this.liveCollection = liveCollection;
     }
 }
 /**
@@ -19197,12 +19235,11 @@ function ɵɵrepeaterCreate(index, templateFn, decls, vars, trackByFn, trackByUs
     }
 }
 class LiveCollectionLContainerImpl extends LiveCollection {
-    constructor(lContainer, hostLView, templateTNode, trackByFn) {
+    constructor(lContainer, hostLView, templateTNode) {
         super();
         this.lContainer = lContainer;
         this.hostLView = hostLView;
         this.templateTNode = templateTNode;
-        this.trackByFn = trackByFn;
         /**
          Property indicating if indexes in the repeater context need to be updated following the live
          collection changes. Index updates are necessary if and only if views are inserted / removed in
@@ -19214,10 +19251,7 @@ class LiveCollectionLContainerImpl extends LiveCollection {
         return this.lContainer.length - CONTAINER_HEADER_OFFSET;
     }
     at(index) {
-        return getExistingLViewFromLContainer(this.lContainer, index);
-    }
-    key(index) {
-        return this.trackByFn(index, this.at(index)[CONTEXT].$implicit);
+        return this.getLView(index)[CONTEXT].$implicit;
     }
     attach(index, lView) {
         const dehydratedView = lView[HYDRATION];
@@ -19237,15 +19271,21 @@ class LiveCollectionLContainerImpl extends LiveCollection {
         destroyLView(lView[TVIEW], lView);
     }
     updateValue(index, value) {
-        this.at(index)[CONTEXT].$implicit = value;
+        this.getLView(index)[CONTEXT].$implicit = value;
+    }
+    reset() {
+        this.needsIndexUpdate = false;
     }
     updateIndexes() {
         if (this.needsIndexUpdate) {
             for (let i = 0; i < this.length; i++) {
-                this.at(i)[CONTEXT].$index = i;
+                this.getLView(i)[CONTEXT].$index = i;
             }
         }
     }
+    getLView(index) {
+        return getExistingLViewFromLContainer(this.lContainer, index);
+    }
 }
 /**
  * The repeater instruction does update-time diffing of a provided collection (against the
@@ -19261,17 +19301,24 @@ function ɵɵrepeater(metadataSlotIdx, collection) {
     const hostLView = getLView();
     const hostTView = hostLView[TVIEW];
     const metadata = hostLView[HEADER_OFFSET + metadataSlotIdx];
-    const containerIndex = metadataSlotIdx + 1;
-    const lContainer = getLContainer(hostLView, HEADER_OFFSET + containerIndex);
-    const itemTemplateTNode = getExistingTNode(hostTView, containerIndex);
-    const liveCollection = new LiveCollectionLContainerImpl(lContainer, hostLView, itemTemplateTNode, metadata.trackByFn);
+    if (metadata.liveCollection === undefined) {
+        const containerIndex = metadataSlotIdx + 1;
+        const lContainer = getLContainer(hostLView, HEADER_OFFSET + containerIndex);
+        const itemTemplateTNode = getExistingTNode(hostTView, containerIndex);
+        metadata.liveCollection =
+            new LiveCollectionLContainerImpl(lContainer, hostLView, itemTemplateTNode);
+    }
+    else {
+        metadata.liveCollection.reset();
+    }
+    const liveCollection = metadata.liveCollection;
     reconcile(liveCollection, collection, metadata.trackByFn);
     // moves in the container might caused context's index to get out of order, re-adjust if needed
     liveCollection.updateIndexes();
     // handle empty blocks
     if (metadata.hasEmptyBlock) {
         const bindingIndex = nextBindingIndex();
-        const isCollectionEmpty = lContainer.length - CONTAINER_HEADER_OFFSET === 0;
+        const isCollectionEmpty = liveCollection.length === 0;
         if (bindingUpdated(hostLView, bindingIndex, isCollectionEmpty)) {
             const emptyTemplateIndex = metadataSlotIdx + 2;
             const lContainerForEmpty = getLContainer(hostLView, HEADER_OFFSET + emptyTemplateIndex);
@@ -19308,6 +19355,75 @@ function getExistingTNode(tView, index) {
     return tNode;
 }
 
+/*!
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/**
+ * 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(),
+    }); }
+}
+
 /**
  * Describes the state of defer block dependency loading.
  */
@@ -19380,6 +19496,128 @@ var DeferBlockBehavior;
     DeferBlockBehavior[DeferBlockBehavior["Playthrough"] = 1] = "Playthrough";
 })(DeferBlockBehavior || (DeferBlockBehavior = {}));
 
+/**
+ * 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();
+        removeLViewOnDestroy(lView, cleanup);
+    };
+    storeLViewOnDestroy(lView, cleanup);
+    return wrappedCallback;
+}
+/**
+ * Calculates a data slot index for defer block info (either static or
+ * instance-specific), given an index of a defer instruction.
+ */
+function getDeferBlockDataIndex(deferBlockIndex) {
+    // Instance state is located at the *next* position
+    // after the defer block slot in an LView or TView.data.
+    return deferBlockIndex + 1;
+}
+/** Retrieves a defer block state from an LView, given a TNode that represents a block. */
+function getLDeferBlockDetails(lView, tNode) {
+    const tView = lView[TVIEW];
+    const slotIndex = getDeferBlockDataIndex(tNode.index);
+    ngDevMode && assertIndexInDeclRange(tView, slotIndex);
+    return lView[slotIndex];
+}
+/** Stores a defer block instance state in LView. */
+function setLDeferBlockDetails(lView, deferBlockIndex, lDetails) {
+    const tView = lView[TVIEW];
+    const slotIndex = getDeferBlockDataIndex(deferBlockIndex);
+    ngDevMode && assertIndexInDeclRange(tView, slotIndex);
+    lView[slotIndex] = lDetails;
+}
+/** Retrieves static info about a defer block, given a TView and a TNode that represents a block. */
+function getTDeferBlockDetails(tView, tNode) {
+    const slotIndex = getDeferBlockDataIndex(tNode.index);
+    ngDevMode && assertIndexInDeclRange(tView, slotIndex);
+    return tView.data[slotIndex];
+}
+/** Stores a defer block static info in `TView.data`. */
+function setTDeferBlockDetails(tView, deferBlockIndex, deferBlockConfig) {
+    const slotIndex = getDeferBlockDataIndex(deferBlockIndex);
+    ngDevMode && assertIndexInDeclRange(tView, slotIndex);
+    tView.data[slotIndex] = deferBlockConfig;
+}
+function getTemplateIndexForState(newState, hostLView, tNode) {
+    const tView = hostLView[TVIEW];
+    const tDetails = getTDeferBlockDetails(tView, tNode);
+    switch (newState) {
+        case DeferBlockState.Complete:
+            return tDetails.primaryTmplIndex;
+        case DeferBlockState.Loading:
+            return tDetails.loadingTmplIndex;
+        case DeferBlockState.Error:
+            return tDetails.errorTmplIndex;
+        case DeferBlockState.Placeholder:
+            return tDetails.placeholderTmplIndex;
+        default:
+            ngDevMode && throwError(`Unexpected defer block state: ${newState}`);
+            return null;
+    }
+}
+/**
+ * Returns a minimum amount of time that a given state should be rendered for,
+ * taking into account `minimum` parameter value. If the `minimum` value is
+ * not specified - returns `null`.
+ */
+function getMinimumDurationForState(tDetails, currentState) {
+    if (currentState === DeferBlockState.Placeholder) {
+        return tDetails.placeholderBlockConfig?.[MINIMUM_SLOT] ?? null;
+    }
+    else if (currentState === DeferBlockState.Loading) {
+        return tDetails.loadingBlockConfig?.[MINIMUM_SLOT] ?? null;
+    }
+    return null;
+}
+/** Retrieves the value of the `after` parameter on the @loading block. */
+function getLoadingBlockAfter(tDetails) {
+    return tDetails.loadingBlockConfig?.[LOADING_AFTER_SLOT] ?? null;
+}
+/**
+ * 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);
+}
+/** Retrieves a TNode that represents main content of a defer block. */
+function getPrimaryBlockTNode(tView, tDetails) {
+    const adjustedIndex = tDetails.primaryTmplIndex + HEADER_OFFSET;
+    return getTNode(tView, adjustedIndex);
+}
+/**
+ * Asserts whether all dependencies for a defer block are loaded.
+ * Always run this function (in dev mode) before rendering a defer
+ * block in completed state.
+ */
+function assertDeferredDependenciesLoaded(tDetails) {
+    assertEqual(tDetails.loadingState, DeferDependenciesLoadingState.COMPLETE, 'Expecting all deferred dependencies to be loaded.');
+}
+/**
+ * Determines if a given value matches the expected structure of a defer block
+ *
+ * We can safely rely on the primaryTmplIndex because every defer block requires
+ * that a primary template exists. All the other template options are optional.
+ */
+function isTDeferBlockDetails(value) {
+    return (typeof value === 'object') &&
+        (typeof value.primaryTmplIndex === 'number');
+}
+
 /*!
  * @license
  * Copyright Google LLC All Rights Reserved.
@@ -19396,10 +19634,16 @@ const eventListenerOptions = {
 const hoverTriggers = new WeakMap();
 /** Keeps track of the currently-registered `on interaction` triggers. */
 const interactionTriggers = new WeakMap();
+/** Currently-registered `viewport` triggers. */
+const viewportTriggers = new WeakMap();
 /** Names of the events considered as interaction events. */
 const interactionEventNames = ['click', 'keydown'];
 /** Names of the events considered as hover events. */
 const hoverEventNames = ['mouseenter', 'focusin'];
+/** `IntersectionObserver` used to observe `viewport` triggers. */
+let intersectionObserver = null;
+/** Number of elements currently observed with `viewport` triggers. */
+let observedViewportElements = 0;
 /** Object keeping track of registered callbacks for a deferred block trigger. */
 class DeferEventEntry {
     constructor() {
@@ -19421,7 +19665,7 @@ function onInteraction(trigger, callback, injector) {
     let entry = interactionTriggers.get(trigger);
     // If this is the first entry for this element, add the listeners.
     if (!entry) {
-        // Note that using managing events centrally like this lends itself well to using global
+        // Note that managing events centrally like this lends itself well to using global
         // event delegation. It currently does delegation at the element level, rather than the
         // document level, because:
         // 1. Global delegation is the most effective when there are a lot of events being registered
@@ -19434,13 +19678,11 @@ function onInteraction(trigger, callback, injector) {
         // are referencing it.
         entry = new DeferEventEntry();
         interactionTriggers.set(trigger, entry);
-        // Ensure that the handler runs in the NgZone since it gets
-        // registered in `afterRender` which runs outside.
-        injector.get(NgZone).run(() => {
-            for (const name of interactionEventNames) {
-                trigger.addEventListener(name, entry.listener, eventListenerOptions);
-            }
-        });
+        // Ensure that the handler runs in the NgZone
+        ngDevMode && NgZone.assertInAngularZone();
+        for (const name of interactionEventNames) {
+            trigger.addEventListener(name, entry.listener, eventListenerOptions);
+        }
     }
     entry.callbacks.add(callback);
     return () => {
@@ -19466,13 +19708,11 @@ function onHover(trigger, callback, injector) {
     if (!entry) {
         entry = new DeferEventEntry();
         hoverTriggers.set(trigger, entry);
-        // Ensure that the handler runs in the NgZone since it gets
-        // registered in `afterRender` which runs outside.
-        injector.get(NgZone).run(() => {
-            for (const name of hoverEventNames) {
-                trigger.addEventListener(name, entry.listener, eventListenerOptions);
-            }
-        });
+        // Ensure that the handler runs in the NgZone
+        ngDevMode && NgZone.assertInAngularZone();
+        for (const name of hoverEventNames) {
+            trigger.addEventListener(name, entry.listener, eventListenerOptions);
+        }
     }
     entry.callbacks.add(callback);
     return () => {
@@ -19493,65 +19733,427 @@ function onHover(trigger, callback, injector) {
  * @param injector Injector that can be used by the trigger to resolve DI tokens.
  */
 function onViewport(trigger, callback, injector) {
-    return injector.get(DeferIntersectionManager).register(trigger, callback);
+    const ngZone = injector.get(NgZone);
+    let entry = viewportTriggers.get(trigger);
+    intersectionObserver = intersectionObserver || ngZone.runOutsideAngular(() => {
+        return new IntersectionObserver(entries => {
+            for (const current of entries) {
+                // Only invoke the callbacks if the specific element is intersecting.
+                if (current.isIntersecting && viewportTriggers.has(current.target)) {
+                    ngZone.run(viewportTriggers.get(current.target).listener);
+                }
+            }
+        });
+    });
+    if (!entry) {
+        entry = new DeferEventEntry();
+        ngZone.runOutsideAngular(() => intersectionObserver.observe(trigger));
+        viewportTriggers.set(trigger, entry);
+        observedViewportElements++;
+    }
+    entry.callbacks.add(callback);
+    return () => {
+        // It's possible that a different cleanup callback fully removed this element already.
+        if (!viewportTriggers.has(trigger)) {
+            return;
+        }
+        entry.callbacks.delete(callback);
+        if (entry.callbacks.size === 0) {
+            intersectionObserver?.unobserve(trigger);
+            viewportTriggers.delete(trigger);
+            observedViewportElements--;
+        }
+        if (observedViewportElements === 0) {
+            intersectionObserver?.disconnect();
+            intersectionObserver = null;
+        }
+    };
+}
+/**
+ * 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$1];
+    function pollDomTrigger() {
+        // If the initial view was destroyed, we don't need to do anything.
+        if (isDestroyed(initialLView)) {
+            return;
+        }
+        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) {
+            return;
+        }
+        const triggerLView = getTriggerLView(initialLView, tNode, walkUpTimes);
+        // Keep polling until we resolve the trigger's LView.
+        if (!triggerLView) {
+            internalAfterNextRender(pollDomTrigger, { injector });
+            return;
+        }
+        // It's possible that the trigger's view was destroyed before we resolved the trigger element.
+        if (isDestroyed(triggerLView)) {
+            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);
+        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);
+        }
+    }
+    // Begin polling for the trigger.
+    internalAfterNextRender(pollDomTrigger, { injector });
 }
-/** Keeps track of the registered `viewport` triggers. */
-class DeferIntersectionManager {
+
+/**
+ * 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 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$1];
+    const scheduler = injector.get(IdleScheduler);
+    const cleanupFn = () => scheduler.remove(callback);
+    const wrappedCallback = withLViewCleanup ? wrapWithLViewCleanup(callback, lView, cleanupFn) : callback;
+    scheduler.add(wrappedCallback);
+    return cleanupFn;
+}
+/**
+ * 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 IdleScheduler {
+    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: DeferIntersectionManager,
+        token: IdleScheduler,
         providedIn: 'root',
-        factory: () => new DeferIntersectionManager(inject(NgZone)),
+        factory: () => new IdleScheduler(),
     }); }
-    constructor(ngZone) {
-        this.ngZone = ngZone;
-        /** `IntersectionObserver` used to observe `viewport` triggers. */
-        this.intersectionObserver = null;
-        /** Number of elements currently observed with `viewport` triggers. */
-        this.observedViewportElements = 0;
-        /** Currently-registered `viewport` triggers. */
-        this.viewportTriggers = new WeakMap();
-        this.intersectionCallback = entries => {
-            for (const current of entries) {
-                // Only invoke the callbacks if the specific element is intersecting.
-                if (current.isIntersecting && this.viewportTriggers.has(current.target)) {
-                    this.ngZone.run(this.viewportTriggers.get(current.target).listener);
-                }
+}
+
+/**
+ * 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$1];
+    const scheduler = injector.get(TimerScheduler);
+    const cleanupFn = () => scheduler.remove(callback);
+    const wrappedCallback = withLViewCleanup ? wrapWithLViewCleanup(callback, lView, cleanupFn) : callback;
+    scheduler.add(delay, wrappedCallback);
+    return cleanupFn;
+}
+/**
+ * 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);
     }
-    register(trigger, callback) {
-        let entry = this.viewportTriggers.get(trigger);
-        if (!this.intersectionObserver) {
-            this.intersectionObserver =
-                this.ngZone.runOutsideAngular(() => new IntersectionObserver(this.intersectionCallback));
+    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 (!entry) {
-            entry = new DeferEventEntry();
-            this.ngZone.runOutsideAngular(() => this.intersectionObserver.observe(trigger));
-            this.viewportTriggers.set(trigger, entry);
-            this.observedViewportElements++;
+        if (index > -1) {
+            // Remove 2 elements: a timestamp slot and
+            // the following slot with a callback function.
+            arraySplice(target, index, 2);
         }
-        entry.callbacks.add(callback);
-        return () => {
-            // It's possible that a different cleanup callback fully removed this element already.
-            if (!this.viewportTriggers.has(trigger)) {
-                return;
+        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;
+                }
             }
-            entry.callbacks.delete(callback);
-            if (entry.callbacks.size === 0) {
-                this.intersectionObserver?.unobserve(trigger);
-                this.viewportTriggers.delete(trigger);
-                this.observedViewportElements--;
+            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);
             }
-            if (this.observedViewportElements === 0) {
-                this.intersectionObserver?.disconnect();
-                this.intersectionObserver = null;
+            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(),
+    }); }
 }
 
+/**
+ * **INTERNAL**, avoid referencing it in application code.
+ *
+ * Injector token that allows to provide `DeferBlockDependencyInterceptor` class
+ * implementation.
+ */
+const DEFER_BLOCK_DEPENDENCY_INTERCEPTOR = new InjectionToken('DEFER_BLOCK_DEPENDENCY_INTERCEPTOR');
+/**
+ * **INTERNAL**, token used for configuring defer block behavior.
+ */
+const DEFER_BLOCK_CONFIG = new InjectionToken(ngDevMode ? 'DEFER_BLOCK_CONFIG' : '');
 /**
  * Returns whether defer blocks should be triggered.
  *
@@ -19869,223 +20471,6 @@ function scheduleDelayedPrefetching(scheduleFn, trigger) {
         }
     }
 }
-/**
- * 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$1];
-    // 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 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$1];
-    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$1];
-    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();
-        removeLViewOnDestroy(lView, cleanup);
-    };
-    storeLViewOnDestroy(lView, cleanup);
-    return wrappedCallback;
-}
-/**
- * Calculates a data slot index for defer block info (either static or
- * instance-specific), given an index of a defer instruction.
- */
-function getDeferBlockDataIndex(deferBlockIndex) {
-    // Instance state is located at the *next* position
-    // after the defer block slot in an LView or TView.data.
-    return deferBlockIndex + 1;
-}
-/** Retrieves a defer block state from an LView, given a TNode that represents a block. */
-function getLDeferBlockDetails(lView, tNode) {
-    const tView = lView[TVIEW];
-    const slotIndex = getDeferBlockDataIndex(tNode.index);
-    ngDevMode && assertIndexInDeclRange(tView, slotIndex);
-    return lView[slotIndex];
-}
-/** Stores a defer block instance state in LView. */
-function setLDeferBlockDetails(lView, deferBlockIndex, lDetails) {
-    const tView = lView[TVIEW];
-    const slotIndex = getDeferBlockDataIndex(deferBlockIndex);
-    ngDevMode && assertIndexInDeclRange(tView, slotIndex);
-    lView[slotIndex] = lDetails;
-}
-/** Retrieves static info about a defer block, given a TView and a TNode that represents a block. */
-function getTDeferBlockDetails(tView, tNode) {
-    const slotIndex = getDeferBlockDataIndex(tNode.index);
-    ngDevMode && assertIndexInDeclRange(tView, slotIndex);
-    return tView.data[slotIndex];
-}
-/** Stores a defer block static info in `TView.data`. */
-function setTDeferBlockDetails(tView, deferBlockIndex, deferBlockConfig) {
-    const slotIndex = getDeferBlockDataIndex(deferBlockIndex);
-    ngDevMode && assertIndexInDeclRange(tView, slotIndex);
-    tView.data[slotIndex] = deferBlockConfig;
-}
-function getTemplateIndexForState(newState, hostLView, tNode) {
-    const tView = hostLView[TVIEW];
-    const tDetails = getTDeferBlockDetails(tView, tNode);
-    switch (newState) {
-        case DeferBlockState.Complete:
-            return tDetails.primaryTmplIndex;
-        case DeferBlockState.Loading:
-            return tDetails.loadingTmplIndex;
-        case DeferBlockState.Error:
-            return tDetails.errorTmplIndex;
-        case DeferBlockState.Placeholder:
-            return tDetails.placeholderTmplIndex;
-        default:
-            ngDevMode && throwError(`Unexpected defer block state: ${newState}`);
-            return null;
-    }
-}
-/**
- * Returns a minimum amount of time that a given state should be rendered for,
- * taking into account `minimum` parameter value. If the `minimum` value is
- * not specified - returns `null`.
- */
-function getMinimumDurationForState(tDetails, currentState) {
-    if (currentState === DeferBlockState.Placeholder) {
-        return tDetails.placeholderBlockConfig?.[MINIMUM_SLOT] ?? null;
-    }
-    else if (currentState === DeferBlockState.Loading) {
-        return tDetails.loadingBlockConfig?.[MINIMUM_SLOT] ?? null;
-    }
-    return null;
-}
-/** Retrieves the value of the `after` parameter on the @loading block. */
-function getLoadingBlockAfter(tDetails) {
-    return tDetails.loadingBlockConfig?.[LOADING_AFTER_SLOT] ?? null;
-}
 /**
  * Transitions a defer block to the new state. Updates the  necessary
  * data structures and renders corresponding block.
@@ -20239,11 +20624,14 @@ function triggerResourceLoading(tDetails, lView) {
     const primaryBlockTNode = getPrimaryBlockTNode(tView, tDetails);
     // Switch from NOT_STARTED -> IN_PROGRESS state.
     tDetails.loadingState = DeferDependenciesLoadingState.IN_PROGRESS;
-    // Check if dependency function interceptor is configured.
-    const deferDependencyInterceptor = injector.get(DEFER_BLOCK_DEPENDENCY_INTERCEPTOR, null, { optional: true });
-    const dependenciesFn = deferDependencyInterceptor ?
-        deferDependencyInterceptor.intercept(tDetails.dependencyResolverFn) :
-        tDetails.dependencyResolverFn;
+    let dependenciesFn = tDetails.dependencyResolverFn;
+    if (ngDevMode) {
+        // Check if dependency function interceptor is configured.
+        const deferDependencyInterceptor = injector.get(DEFER_BLOCK_DEPENDENCY_INTERCEPTOR, null, { optional: true });
+        if (deferDependencyInterceptor) {
+            dependenciesFn = deferDependencyInterceptor.intercept(dependenciesFn);
+        }
+    }
     // The `dependenciesFn` might be `null` when all dependencies within
     // a given defer block were eagerly references elsewhere in a file,
     // thus no dynamic `import()`s were produced.
@@ -20300,22 +20688,6 @@ function triggerResourceLoading(tDetails, lView) {
         }
     });
 }
-/**
- * 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 lContainer = lView[tNode.index];
@@ -20343,11 +20715,6 @@ function renderDeferStateAfterResourceLoading(tDetails, tNode, lContainer) {
         }
     });
 }
-/** Retrieves a TNode that represents main content of a defer block. */
-function getPrimaryBlockTNode(tView, tDetails) {
-    const adjustedIndex = tDetails.primaryTmplIndex + HEADER_OFFSET;
-    return getTNode(tView, adjustedIndex);
-}
 /**
  * Attempts to trigger loading of defer block dependencies.
  * If the block is already in a loading, completed or an error state -
@@ -20388,366 +20755,6 @@ function triggerDeferBlock(lView, tNode) {
             }
     }
 }
-/**
- * Asserts whether all dependencies for a defer block are loaded.
- * Always run this function (in dev mode) before rendering a defer
- * block in completed state.
- */
-function assertDeferredDependenciesLoaded(tDetails) {
-    assertEqual(tDetails.loadingState, DeferDependenciesLoadingState.COMPLETE, 'Expecting all deferred dependencies to be loaded.');
-}
-/**
- * **INTERNAL**, avoid referencing it in application code.
- *
- * Injector token that allows to provide `DeferBlockDependencyInterceptor` class
- * implementation.
- */
-const DEFER_BLOCK_DEPENDENCY_INTERCEPTOR = new InjectionToken(ngDevMode ? 'DEFER_BLOCK_DEPENDENCY_INTERCEPTOR' : '');
-/**
- * Determines if a given value matches the expected structure of a defer block
- *
- * We can safely rely on the primaryTmplIndex because every defer block requires
- * that a primary template exists. All the other template options are optional.
- */
-function isTDeferBlockDetails(value) {
-    return (typeof value === 'object') &&
-        (typeof value.primaryTmplIndex === 'number');
-}
-/**
- * Internal token used for configuring defer block behavior.
- */
-const DEFER_BLOCK_CONFIG = new InjectionToken(ngDevMode ? 'DEFER_BLOCK_CONFIG' : '');
-/**
- * Retrieves all defer blocks in a given LView.
- *
- * @param lView lView with defer blocks
- * @param deferBlocks defer block aggregator array
- */
-function getDeferBlocks(lView, deferBlocks) {
-    const tView = lView[TVIEW];
-    for (let i = HEADER_OFFSET; i < tView.bindingStartIndex; i++) {
-        if (isLContainer(lView[i])) {
-            const lContainer = lView[i];
-            // An LContainer may represent an instance of a defer block, in which case
-            // we store it as a result. Otherwise, keep iterating over LContainer views and
-            // look for defer blocks.
-            const isLast = i === tView.bindingStartIndex - 1;
-            if (!isLast) {
-                const tNode = tView.data[i];
-                const tDetails = getTDeferBlockDetails(tView, tNode);
-                if (isTDeferBlockDetails(tDetails)) {
-                    deferBlocks.push({ lContainer, lView, tNode, tDetails });
-                    // This LContainer represents a defer block, so we exit
-                    // this iteration and don't inspect views in this LContainer.
-                    continue;
-                }
-            }
-            for (let i = CONTAINER_HEADER_OFFSET; i < lContainer.length; i++) {
-                getDeferBlocks(lContainer[i], deferBlocks);
-            }
-        }
-        else if (isLView(lView[i])) {
-            // This is a component, enter the `getDeferBlocks` recursively.
-            getDeferBlocks(lView[i], deferBlocks);
-        }
-    }
-}
-/**
- * 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(),
-    }); }
-}
 
 function elementStartFirstCreatePass(index, tView, lView, name, attrsIndex, localRefsIndex) {
     ngDevMode && assertFirstCreatePass(tView);
@@ -21346,9 +21353,6 @@ var I18nCreateOpCode;
      */
     I18nCreateOpCode[I18nCreateOpCode["COMMENT"] = 2] = "COMMENT";
 })(I18nCreateOpCode || (I18nCreateOpCode = {}));
-// Note: This hack is necessary so we don't erroneously get a circular dependency
-// failure based on types.
-const unusedValueExportToPlacateAjd = 1;
 
 /**
  * The locale id that the application is currently using (for translations and ICU expressions).
@@ -30528,6 +30532,7 @@ function isBoundToModule(cf) {
 /**
  * A token for third-party components that can register themselves with NgProbe.
  *
+ * @deprecated
  * @publicApi
  */
 class NgProbeToken {
@@ -31753,6 +31758,7 @@ class DebugElement extends DebugNode {
     /**
      *  A map of attribute names to attribute values for an element.
      */
+    // TODO: replace null by undefined in the return type
     get attributes() {
         const attributes = {};
         const element = this.nativeElement;
@@ -31798,16 +31804,11 @@ class DebugElement extends DebugNode {
     }
     /**
      * The inline styles of the DOM element.
-     *
-     * Will be `null` if there is no `style` property on the underlying DOM element.
-     *
-     * @see [ElementCSSInlineStyle](https://developer.mozilla.org/en-US/docs/Web/API/ElementCSSInlineStyle/style)
      */
+    // TODO: replace null by undefined in the return type
     get styles() {
-        if (this.nativeElement && this.nativeElement.style) {
-            return this.nativeElement.style;
-        }
-        return {};
+        const element = this.nativeElement;
+        return (element?.style ?? {});
     }
     /**
      * A map containing the class names on the element as keys.
@@ -33783,6 +33784,42 @@ function setAlternateWeakRefImpl(impl) {
     // TODO: remove this function
 }
 
+/**
+ * Retrieves all defer blocks in a given LView.
+ *
+ * @param lView lView with defer blocks
+ * @param deferBlocks defer block aggregator array
+ */
+function getDeferBlocks(lView, deferBlocks) {
+    const tView = lView[TVIEW];
+    for (let i = HEADER_OFFSET; i < tView.bindingStartIndex; i++) {
+        if (isLContainer(lView[i])) {
+            const lContainer = lView[i];
+            // An LContainer may represent an instance of a defer block, in which case
+            // we store it as a result. Otherwise, keep iterating over LContainer views and
+            // look for defer blocks.
+            const isLast = i === tView.bindingStartIndex - 1;
+            if (!isLast) {
+                const tNode = tView.data[i];
+                const tDetails = getTDeferBlockDetails(tView, tNode);
+                if (isTDeferBlockDetails(tDetails)) {
+                    deferBlocks.push({ lContainer, lView, tNode, tDetails });
+                    // This LContainer represents a defer block, so we exit
+                    // this iteration and don't inspect views in this LContainer.
+                    continue;
+                }
+            }
+            for (let i = CONTAINER_HEADER_OFFSET; i < lContainer.length; i++) {
+                getDeferBlocks(lContainer[i], deferBlocks);
+            }
+        }
+        else if (isLView(lView[i])) {
+            // This is a component, enter the `getDeferBlocks` recursively.
+            getDeferBlocks(lView[i], deferBlocks);
+        }
+    }
+}
+
 /**
  * A collection that tracks all serialized views (`ngh` DOM annotations)
  * to avoid duplication. An attempt to add a duplicate view results in the
@@ -34319,7 +34356,6 @@ function printHydrationStats(injector) {
     const message = `Angular hydrated ${ngDevMode.hydratedComponents} component(s) ` +
         `and ${ngDevMode.hydratedNodes} node(s), ` +
         `${ngDevMode.componentsSkippedHydration} component(s) were skipped. ` +
-        `Note: this feature is in Developer Preview mode. ` +
         `Learn more at https://angular.io/guide/hydration.`;
     // tslint:disable-next-line:no-console
     console.log(message);
@@ -34790,5 +34826,5 @@ if (typeof ngDevMode !== 'undefined' && ngDevMode) {
  * Generated bundle index. Do not edit.
  */
 
-export { ANIMATION_MODULE_TYPE, APP_BOOTSTRAP_LISTENER, APP_ID, APP_INITIALIZER, AfterRenderPhase, ApplicationInitStatus, ApplicationModule, ApplicationRef, Attribute, COMPILER_OPTIONS, CSP_NONCE, CUSTOM_ELEMENTS_SCHEMA, ChangeDetectionStrategy, ChangeDetectorRef, Compiler, CompilerFactory, Component, ComponentFactory$1 as ComponentFactory, ComponentFactoryResolver$1 as ComponentFactoryResolver, ComponentRef$1 as ComponentRef, ContentChild, ContentChildren, DEFAULT_CURRENCY_CODE, DebugElement, DebugEventListener, DebugNode, DefaultIterableDiffer, DestroyRef, Directive, ENVIRONMENT_INITIALIZER, ElementRef, EmbeddedViewRef, EnvironmentInjector, ErrorHandler, EventEmitter, Host, HostBinding, HostListener, INJECTOR, Inject, InjectFlags, Injectable, InjectionToken, Injector, Input, IterableDiffers, KeyValueDiffers, LOCALE_ID, MissingTranslationStrategy, ModuleWithComponentFactories, NO_ERRORS_SCHEMA, NgModule, NgModuleFactory$1 as NgModuleFactory, NgModuleRef$1 as NgModuleRef, NgProbeToken, NgZone, Optional, Output, PACKAGE_ROOT_URL, PLATFORM_ID, PLATFORM_INITIALIZER, Pipe, PlatformRef, Query, QueryList, Renderer2, RendererFactory2, RendererStyleFlags2, Sanitizer, SecurityContext, Self, SimpleChange, SkipSelf, TRANSLATIONS, TRANSLATIONS_FORMAT, TemplateRef, Testability, TestabilityRegistry, TransferState, Type, VERSION, Version, ViewChild, ViewChildren, ViewContainerRef, ViewEncapsulation$1 as ViewEncapsulation, ViewRef, afterNextRender, afterRender, asNativeElements, assertInInjectionContext, assertNotInReactiveContext, assertPlatform, booleanAttribute, computed, createComponent, createEnvironmentInjector, createNgModule, createNgModuleRef, createPlatform, createPlatformFactory, defineInjectable, destroyPlatform, effect, enableProdMode, forwardRef, getDebugNode, getModuleFactory, getNgModuleById, getPlatform, importProvidersFrom, inject, isDevMode, isSignal, isStandalone, makeEnvironmentProviders, makeStateKey, mergeApplicationConfig, numberAttribute, platformCore, provideZoneChangeDetection, reflectComponentType, resolveForwardRef, runInInjectionContext, setTestabilityGetter, signal, untracked, ALLOW_MULTIPLE_PLATFORMS as ɵALLOW_MULTIPLE_PLATFORMS, AfterRenderEventManager as ɵAfterRenderEventManager, CONTAINER_HEADER_OFFSET as ɵCONTAINER_HEADER_OFFSET, ComponentFactory$1 as ɵComponentFactory, Console as ɵConsole, DEFAULT_LOCALE_ID as ɵDEFAULT_LOCALE_ID, DEFER_BLOCK_CONFIG as ɵDEFER_BLOCK_CONFIG, DEFER_BLOCK_DEPENDENCY_INTERCEPTOR as ɵDEFER_BLOCK_DEPENDENCY_INTERCEPTOR, DeferBlockBehavior as ɵDeferBlockBehavior, DeferBlockState as ɵDeferBlockState, ENABLED_SSR_FEATURES as ɵENABLED_SSR_FEATURES, EffectScheduler as ɵEffectScheduler, IMAGE_CONFIG as ɵIMAGE_CONFIG, IMAGE_CONFIG_DEFAULTS as ɵIMAGE_CONFIG_DEFAULTS, INJECTOR_SCOPE as ɵINJECTOR_SCOPE, IS_HYDRATION_DOM_REUSE_ENABLED as ɵIS_HYDRATION_DOM_REUSE_ENABLED, InitialRenderPendingTasks as ɵInitialRenderPendingTasks, LContext as ɵLContext, LifecycleHooksFeature as ɵLifecycleHooksFeature, LocaleDataIndex as ɵLocaleDataIndex, NG_COMP_DEF as ɵNG_COMP_DEF, NG_DIR_DEF as ɵNG_DIR_DEF, NG_ELEMENT_ID as ɵNG_ELEMENT_ID, NG_INJ_DEF as ɵNG_INJ_DEF, NG_MOD_DEF as ɵNG_MOD_DEF, NG_PIPE_DEF as ɵNG_PIPE_DEF, NG_PROV_DEF as ɵNG_PROV_DEF, NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR as ɵNOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR, NO_CHANGE as ɵNO_CHANGE, NgModuleFactory as ɵNgModuleFactory, NoopNgZone as ɵNoopNgZone, ReflectionCapabilities as ɵReflectionCapabilities, ComponentFactory as ɵRender3ComponentFactory, ComponentRef as ɵRender3ComponentRef, NgModuleRef as ɵRender3NgModuleRef, RuntimeError as ɵRuntimeError, SSR_CONTENT_INTEGRITY_MARKER as ɵSSR_CONTENT_INTEGRITY_MARKER, TESTABILITY as ɵTESTABILITY, TESTABILITY_GETTER as ɵTESTABILITY_GETTER, USE_RUNTIME_DEPS_TRACKER_FOR_JIT as ɵUSE_RUNTIME_DEPS_TRACKER_FOR_JIT, ViewRef$1 as ɵViewRef, XSS_SECURITY_URL as ɵXSS_SECURITY_URL, ZoneAwareQueueingScheduler as ɵZoneAwareQueueingScheduler, _sanitizeHtml as ɵ_sanitizeHtml, _sanitizeUrl as ɵ_sanitizeUrl, allowSanitizationBypassAndThrow as ɵallowSanitizationBypassAndThrow, annotateForHydration as ɵannotateForHydration, bypassSanitizationTrustHtml as ɵbypassSanitizationTrustHtml, bypassSanitizationTrustResourceUrl as ɵbypassSanitizationTrustResourceUrl, bypassSanitizationTrustScript as ɵbypassSanitizationTrustScript, bypassSanitizationTrustStyle as ɵbypassSanitizationTrustStyle, bypassSanitizationTrustUrl as ɵbypassSanitizationTrustUrl, clearResolutionOfComponentResourcesQueue as ɵclearResolutionOfComponentResourcesQueue, compileComponent as ɵcompileComponent, compileDirective as ɵcompileDirective, compileNgModule as ɵcompileNgModule, compileNgModuleDefs as ɵcompileNgModuleDefs, compileNgModuleFactory as ɵcompileNgModuleFactory, compilePipe as ɵcompilePipe, convertToBitFlags as ɵconvertToBitFlags, createInjector as ɵcreateInjector, defaultIterableDiffers as ɵdefaultIterableDiffers, defaultKeyValueDiffers as ɵdefaultKeyValueDiffers, depsTracker as ɵdepsTracker, detectChanges as ɵdetectChanges, devModeEqual as ɵdevModeEqual, findLocaleData as ɵfindLocaleData, flushModuleScopingQueueAsMuchAsPossible as ɵflushModuleScopingQueueAsMuchAsPossible, formatRuntimeError as ɵformatRuntimeError, generateStandaloneInDeclarationsError as ɵgenerateStandaloneInDeclarationsError, getAsyncClassMetadata as ɵgetAsyncClassMetadata, getDebugNode as ɵgetDebugNode, getDeferBlocks as ɵgetDeferBlocks, getDirectives as ɵgetDirectives, getHostElement as ɵgetHostElement, getInjectableDef as ɵgetInjectableDef, getLContext as ɵgetLContext, getLocaleCurrencyCode as ɵgetLocaleCurrencyCode, getLocalePluralCase as ɵgetLocalePluralCase, getSanitizationBypassType as ɵgetSanitizationBypassType, ɵgetUnknownElementStrictMode, ɵgetUnknownPropertyStrictMode, _global as ɵglobal, injectChangeDetectorRef as ɵinjectChangeDetectorRef, internalCreateApplication as ɵinternalCreateApplication, isBoundToModule as ɵisBoundToModule, isComponentDefPendingResolution as ɵisComponentDefPendingResolution, isEnvironmentProviders as ɵisEnvironmentProviders, isInjectable as ɵisInjectable, isNgModule as ɵisNgModule, isPromise as ɵisPromise, isSubscribable as ɵisSubscribable, noSideEffects as ɵnoSideEffects, patchComponentDefWithScope as ɵpatchComponentDefWithScope, publishDefaultGlobalUtils$1 as ɵpublishDefaultGlobalUtils, publishGlobalUtil as ɵpublishGlobalUtil, registerLocaleData as ɵregisterLocaleData, renderDeferBlockState as ɵrenderDeferBlockState, resetCompiledComponents as ɵresetCompiledComponents, resetJitOptions as ɵresetJitOptions, resolveComponentResources as ɵresolveComponentResources, restoreComponentResolutionQueue as ɵrestoreComponentResolutionQueue, setAllowDuplicateNgModuleIdsForTest as ɵsetAllowDuplicateNgModuleIdsForTest, setAlternateWeakRefImpl as ɵsetAlternateWeakRefImpl, ɵsetClassDebugInfo, setClassMetadata as ɵsetClassMetadata, setClassMetadataAsync as ɵsetClassMetadataAsync, setCurrentInjector as ɵsetCurrentInjector, setDocument as ɵsetDocument, setInjectorProfilerContext as ɵsetInjectorProfilerContext, setLocaleId as ɵsetLocaleId, ɵsetUnknownElementStrictMode, ɵsetUnknownPropertyStrictMode, store as ɵstore, stringify as ɵstringify, transitiveScopesFor as ɵtransitiveScopesFor, triggerResourceLoading as ɵtriggerResourceLoading, truncateMiddle as ɵtruncateMiddle, unregisterAllLocaleData as ɵunregisterLocaleData, unwrapSafeValue as ɵunwrapSafeValue, whenStable as ɵwhenStable, withDomHydration as ɵwithDomHydration, ɵɵCopyDefinitionFeature, FactoryTarget as ɵɵFactoryTarget, ɵɵHostDirectivesFeature, ɵɵInheritDefinitionFeature, ɵɵInputTransformsFeature, ɵɵNgOnChangesFeature, ɵɵProvidersFeature, ɵɵStandaloneFeature, ɵɵadvance, ɵɵattribute, ɵɵattributeInterpolate1, ɵɵattributeInterpolate2, ɵɵattributeInterpolate3, ɵɵattributeInterpolate4, ɵɵattributeInterpolate5, ɵɵattributeInterpolate6, ɵɵattributeInterpolate7, ɵɵattributeInterpolate8, ɵɵattributeInterpolateV, ɵɵclassMap, ɵɵclassMapInterpolate1, ɵɵclassMapInterpolate2, ɵɵclassMapInterpolate3, ɵɵclassMapInterpolate4, ɵɵclassMapInterpolate5, ɵɵclassMapInterpolate6, ɵɵclassMapInterpolate7, ɵɵclassMapInterpolate8, ɵɵclassMapInterpolateV, ɵɵclassProp, ɵɵcomponentInstance, ɵɵconditional, ɵɵcontentQuery, ɵɵdefer, ɵɵdeferEnableTimerScheduling, ɵɵdeferOnHover, ɵɵdeferOnIdle, ɵɵdeferOnImmediate, ɵɵdeferOnInteraction, ɵɵdeferOnTimer, ɵɵdeferOnViewport, ɵɵdeferPrefetchOnHover, ɵɵdeferPrefetchOnIdle, ɵɵdeferPrefetchOnImmediate, ɵɵdeferPrefetchOnInteraction, ɵɵdeferPrefetchOnTimer, ɵɵdeferPrefetchOnViewport, ɵɵdeferPrefetchWhen, ɵɵdeferWhen, ɵɵdefineComponent, ɵɵdefineDirective, ɵɵdefineInjectable, ɵɵdefineInjector, ɵɵdefineNgModule, ɵɵdefinePipe, ɵɵdirectiveInject, ɵɵdisableBindings, ɵɵelement, ɵɵelementContainer, ɵɵelementContainerEnd, ɵɵelementContainerStart, ɵɵelementEnd, ɵɵelementStart, ɵɵenableBindings, ɵɵgetComponentDepsFactory, ɵɵgetCurrentView, ɵɵgetInheritedFactory, ɵɵhostProperty, ɵɵi18n, ɵɵi18nApply, ɵɵi18nAttributes, ɵɵi18nEnd, ɵɵi18nExp, ɵɵi18nPostprocess, ɵɵi18nStart, ɵɵinject, ɵɵinjectAttribute, ɵɵinvalidFactory, ɵɵinvalidFactoryDep, ɵɵlistener, ɵɵloadQuery, ɵɵnamespaceHTML, ɵɵnamespaceMathML, ɵɵnamespaceSVG, ɵɵnextContext, ɵɵngDeclareClassMetadata, ɵɵngDeclareComponent, ɵɵngDeclareDirective, ɵɵngDeclareFactory, ɵɵngDeclareInjectable, ɵɵngDeclareInjector, ɵɵngDeclareNgModule, ɵɵngDeclarePipe, ɵɵpipe, ɵɵpipeBind1, ɵɵpipeBind2, ɵɵpipeBind3, ɵɵpipeBind4, ɵɵpipeBindV, ɵɵprojection, ɵɵprojectionDef, ɵɵproperty, ɵɵpropertyInterpolate, ɵɵpropertyInterpolate1, ɵɵpropertyInterpolate2, ɵɵpropertyInterpolate3, ɵɵpropertyInterpolate4, ɵɵpropertyInterpolate5, ɵɵpropertyInterpolate6, ɵɵpropertyInterpolate7, ɵɵpropertyInterpolate8, ɵɵpropertyInterpolateV, ɵɵpureFunction0, ɵɵpureFunction1, ɵɵpureFunction2, ɵɵpureFunction3, ɵɵpureFunction4, ɵɵpureFunction5, ɵɵpureFunction6, ɵɵpureFunction7, ɵɵpureFunction8, ɵɵpureFunctionV, ɵɵqueryRefresh, ɵɵreference, registerNgModuleType as ɵɵregisterNgModuleType, ɵɵrepeater, ɵɵrepeaterCreate, ɵɵrepeaterTrackByIdentity, ɵɵrepeaterTrackByIndex, ɵɵresetView, ɵɵresolveBody, ɵɵresolveDocument, ɵɵresolveWindow, ɵɵrestoreView, ɵɵsanitizeHtml, ɵɵsanitizeResourceUrl, ɵɵsanitizeScript, ɵɵsanitizeStyle, ɵɵsanitizeUrl, ɵɵsanitizeUrlOrResourceUrl, ɵɵsetComponentScope, ɵɵsetNgModuleScope, ɵɵstyleMap, ɵɵstyleMapInterpolate1, ɵɵstyleMapInterpolate2, ɵɵstyleMapInterpolate3, ɵɵstyleMapInterpolate4, ɵɵstyleMapInterpolate5, ɵɵstyleMapInterpolate6, ɵɵstyleMapInterpolate7, ɵɵstyleMapInterpolate8, ɵɵstyleMapInterpolateV, ɵɵstyleProp, ɵɵstylePropInterpolate1, ɵɵstylePropInterpolate2, ɵɵstylePropInterpolate3, ɵɵstylePropInterpolate4, ɵɵstylePropInterpolate5, ɵɵstylePropInterpolate6, ɵɵstylePropInterpolate7, ɵɵstylePropInterpolate8, ɵɵstylePropInterpolateV, ɵɵsyntheticHostListener, ɵɵsyntheticHostProperty, ɵɵtemplate, ɵɵtemplateRefExtractor, ɵɵtext, ɵɵtextInterpolate, ɵɵtextInterpolate1, ɵɵtextInterpolate2, ɵɵtextInterpolate3, ɵɵtextInterpolate4, ɵɵtextInterpolate5, ɵɵtextInterpolate6, ɵɵtextInterpolate7, ɵɵtextInterpolate8, ɵɵtextInterpolateV, ɵɵtrustConstantHtml, ɵɵtrustConstantResourceUrl, ɵɵvalidateIframeAttribute, ɵɵviewQuery };
+export { ANIMATION_MODULE_TYPE, APP_BOOTSTRAP_LISTENER, APP_ID, APP_INITIALIZER, AfterRenderPhase, ApplicationInitStatus, ApplicationModule, ApplicationRef, Attribute, COMPILER_OPTIONS, CSP_NONCE, CUSTOM_ELEMENTS_SCHEMA, ChangeDetectionStrategy, ChangeDetectorRef, Compiler, CompilerFactory, Component, ComponentFactory$1 as ComponentFactory, ComponentFactoryResolver$1 as ComponentFactoryResolver, ComponentRef$1 as ComponentRef, ContentChild, ContentChildren, DEFAULT_CURRENCY_CODE, DebugElement, DebugEventListener, DebugNode, DefaultIterableDiffer, DestroyRef, Directive, ENVIRONMENT_INITIALIZER, ElementRef, EmbeddedViewRef, EnvironmentInjector, ErrorHandler, EventEmitter, Host, HostBinding, HostListener, INJECTOR, Inject, InjectFlags, Injectable, InjectionToken, Injector, Input, IterableDiffers, KeyValueDiffers, LOCALE_ID, MissingTranslationStrategy, ModuleWithComponentFactories, NO_ERRORS_SCHEMA, NgModule, NgModuleFactory$1 as NgModuleFactory, NgModuleRef$1 as NgModuleRef, NgProbeToken, NgZone, Optional, Output, PACKAGE_ROOT_URL, PLATFORM_ID, PLATFORM_INITIALIZER, Pipe, PlatformRef, Query, QueryList, Renderer2, RendererFactory2, RendererStyleFlags2, Sanitizer, SecurityContext, Self, SimpleChange, SkipSelf, TRANSLATIONS, TRANSLATIONS_FORMAT, TemplateRef, Testability, TestabilityRegistry, TransferState, Type, VERSION, Version, ViewChild, ViewChildren, ViewContainerRef, ViewEncapsulation$1 as ViewEncapsulation, ViewRef, afterNextRender, afterRender, asNativeElements, assertInInjectionContext, assertNotInReactiveContext, assertPlatform, booleanAttribute, computed, createComponent, createEnvironmentInjector, createNgModule, createNgModuleRef, createPlatform, createPlatformFactory, defineInjectable, destroyPlatform, effect, enableProdMode, forwardRef, getDebugNode, getModuleFactory, getNgModuleById, getPlatform, importProvidersFrom, inject, isDevMode, isSignal, isStandalone, makeEnvironmentProviders, makeStateKey, mergeApplicationConfig, numberAttribute, platformCore, provideZoneChangeDetection, reflectComponentType, resolveForwardRef, runInInjectionContext, setTestabilityGetter, signal, untracked, ALLOW_MULTIPLE_PLATFORMS as ɵALLOW_MULTIPLE_PLATFORMS, AfterRenderEventManager as ɵAfterRenderEventManager, CONTAINER_HEADER_OFFSET as ɵCONTAINER_HEADER_OFFSET, ComponentFactory$1 as ɵComponentFactory, Console as ɵConsole, DEFAULT_LOCALE_ID as ɵDEFAULT_LOCALE_ID, DEFER_BLOCK_CONFIG as ɵDEFER_BLOCK_CONFIG, DEFER_BLOCK_DEPENDENCY_INTERCEPTOR as ɵDEFER_BLOCK_DEPENDENCY_INTERCEPTOR, DeferBlockBehavior as ɵDeferBlockBehavior, DeferBlockState as ɵDeferBlockState, ENABLED_SSR_FEATURES as ɵENABLED_SSR_FEATURES, EffectScheduler as ɵEffectScheduler, IMAGE_CONFIG as ɵIMAGE_CONFIG, IMAGE_CONFIG_DEFAULTS as ɵIMAGE_CONFIG_DEFAULTS, INJECTOR_SCOPE as ɵINJECTOR_SCOPE, IS_HYDRATION_DOM_REUSE_ENABLED as ɵIS_HYDRATION_DOM_REUSE_ENABLED, InitialRenderPendingTasks as ɵInitialRenderPendingTasks, LContext as ɵLContext, LifecycleHooksFeature as ɵLifecycleHooksFeature, LocaleDataIndex as ɵLocaleDataIndex, NG_COMP_DEF as ɵNG_COMP_DEF, NG_DIR_DEF as ɵNG_DIR_DEF, NG_ELEMENT_ID as ɵNG_ELEMENT_ID, NG_INJ_DEF as ɵNG_INJ_DEF, NG_MOD_DEF as ɵNG_MOD_DEF, NG_PIPE_DEF as ɵNG_PIPE_DEF, NG_PROV_DEF as ɵNG_PROV_DEF, NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR as ɵNOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR, NO_CHANGE as ɵNO_CHANGE, NgModuleFactory as ɵNgModuleFactory, NoopNgZone as ɵNoopNgZone, ReflectionCapabilities as ɵReflectionCapabilities, ComponentFactory as ɵRender3ComponentFactory, ComponentRef as ɵRender3ComponentRef, NgModuleRef as ɵRender3NgModuleRef, RuntimeError as ɵRuntimeError, SSR_CONTENT_INTEGRITY_MARKER as ɵSSR_CONTENT_INTEGRITY_MARKER, TESTABILITY as ɵTESTABILITY, TESTABILITY_GETTER as ɵTESTABILITY_GETTER, USE_RUNTIME_DEPS_TRACKER_FOR_JIT as ɵUSE_RUNTIME_DEPS_TRACKER_FOR_JIT, ViewRef$1 as ɵViewRef, XSS_SECURITY_URL as ɵXSS_SECURITY_URL, ZoneAwareQueueingScheduler as ɵZoneAwareQueueingScheduler, _sanitizeHtml as ɵ_sanitizeHtml, _sanitizeUrl as ɵ_sanitizeUrl, allowSanitizationBypassAndThrow as ɵallowSanitizationBypassAndThrow, annotateForHydration as ɵannotateForHydration, bypassSanitizationTrustHtml as ɵbypassSanitizationTrustHtml, bypassSanitizationTrustResourceUrl as ɵbypassSanitizationTrustResourceUrl, bypassSanitizationTrustScript as ɵbypassSanitizationTrustScript, bypassSanitizationTrustStyle as ɵbypassSanitizationTrustStyle, bypassSanitizationTrustUrl as ɵbypassSanitizationTrustUrl, clearResolutionOfComponentResourcesQueue as ɵclearResolutionOfComponentResourcesQueue, compileComponent as ɵcompileComponent, compileDirective as ɵcompileDirective, compileNgModule as ɵcompileNgModule, compileNgModuleDefs as ɵcompileNgModuleDefs, compileNgModuleFactory as ɵcompileNgModuleFactory, compilePipe as ɵcompilePipe, convertToBitFlags as ɵconvertToBitFlags, createInjector as ɵcreateInjector, defaultIterableDiffers as ɵdefaultIterableDiffers, defaultKeyValueDiffers as ɵdefaultKeyValueDiffers, depsTracker as ɵdepsTracker, detectChanges as ɵdetectChanges, devModeEqual as ɵdevModeEqual, findLocaleData as ɵfindLocaleData, flushModuleScopingQueueAsMuchAsPossible as ɵflushModuleScopingQueueAsMuchAsPossible, formatRuntimeError as ɵformatRuntimeError, generateStandaloneInDeclarationsError as ɵgenerateStandaloneInDeclarationsError, getAsyncClassMetadata as ɵgetAsyncClassMetadata, getDebugNode as ɵgetDebugNode, getDeferBlocks as ɵgetDeferBlocks, getDirectives as ɵgetDirectives, getHostElement as ɵgetHostElement, getInjectableDef as ɵgetInjectableDef, getLContext as ɵgetLContext, getLocaleCurrencyCode as ɵgetLocaleCurrencyCode, getLocalePluralCase as ɵgetLocalePluralCase, getSanitizationBypassType as ɵgetSanitizationBypassType, ɵgetUnknownElementStrictMode, ɵgetUnknownPropertyStrictMode, _global as ɵglobal, injectChangeDetectorRef as ɵinjectChangeDetectorRef, internalAfterNextRender as ɵinternalAfterNextRender, internalCreateApplication as ɵinternalCreateApplication, isBoundToModule as ɵisBoundToModule, isComponentDefPendingResolution as ɵisComponentDefPendingResolution, isEnvironmentProviders as ɵisEnvironmentProviders, isInjectable as ɵisInjectable, isNgModule as ɵisNgModule, isPromise as ɵisPromise, isSubscribable as ɵisSubscribable, noSideEffects as ɵnoSideEffects, patchComponentDefWithScope as ɵpatchComponentDefWithScope, publishDefaultGlobalUtils$1 as ɵpublishDefaultGlobalUtils, publishGlobalUtil as ɵpublishGlobalUtil, registerLocaleData as ɵregisterLocaleData, renderDeferBlockState as ɵrenderDeferBlockState, resetCompiledComponents as ɵresetCompiledComponents, resetJitOptions as ɵresetJitOptions, resolveComponentResources as ɵresolveComponentResources, restoreComponentResolutionQueue as ɵrestoreComponentResolutionQueue, setAllowDuplicateNgModuleIdsForTest as ɵsetAllowDuplicateNgModuleIdsForTest, setAlternateWeakRefImpl as ɵsetAlternateWeakRefImpl, ɵsetClassDebugInfo, setClassMetadata as ɵsetClassMetadata, setClassMetadataAsync as ɵsetClassMetadataAsync, setCurrentInjector as ɵsetCurrentInjector, setDocument as ɵsetDocument, setInjectorProfilerContext as ɵsetInjectorProfilerContext, setLocaleId as ɵsetLocaleId, ɵsetUnknownElementStrictMode, ɵsetUnknownPropertyStrictMode, store as ɵstore, stringify as ɵstringify, transitiveScopesFor as ɵtransitiveScopesFor, triggerResourceLoading as ɵtriggerResourceLoading, truncateMiddle as ɵtruncateMiddle, unregisterAllLocaleData as ɵunregisterLocaleData, unwrapSafeValue as ɵunwrapSafeValue, whenStable as ɵwhenStable, withDomHydration as ɵwithDomHydration, ɵɵCopyDefinitionFeature, FactoryTarget as ɵɵFactoryTarget, ɵɵHostDirectivesFeature, ɵɵInheritDefinitionFeature, ɵɵInputTransformsFeature, ɵɵNgOnChangesFeature, ɵɵProvidersFeature, ɵɵStandaloneFeature, ɵɵadvance, ɵɵattribute, ɵɵattributeInterpolate1, ɵɵattributeInterpolate2, ɵɵattributeInterpolate3, ɵɵattributeInterpolate4, ɵɵattributeInterpolate5, ɵɵattributeInterpolate6, ɵɵattributeInterpolate7, ɵɵattributeInterpolate8, ɵɵattributeInterpolateV, ɵɵclassMap, ɵɵclassMapInterpolate1, ɵɵclassMapInterpolate2, ɵɵclassMapInterpolate3, ɵɵclassMapInterpolate4, ɵɵclassMapInterpolate5, ɵɵclassMapInterpolate6, ɵɵclassMapInterpolate7, ɵɵclassMapInterpolate8, ɵɵclassMapInterpolateV, ɵɵclassProp, ɵɵcomponentInstance, ɵɵconditional, ɵɵcontentQuery, ɵɵdefer, ɵɵdeferEnableTimerScheduling, ɵɵdeferOnHover, ɵɵdeferOnIdle, ɵɵdeferOnImmediate, ɵɵdeferOnInteraction, ɵɵdeferOnTimer, ɵɵdeferOnViewport, ɵɵdeferPrefetchOnHover, ɵɵdeferPrefetchOnIdle, ɵɵdeferPrefetchOnImmediate, ɵɵdeferPrefetchOnInteraction, ɵɵdeferPrefetchOnTimer, ɵɵdeferPrefetchOnViewport, ɵɵdeferPrefetchWhen, ɵɵdeferWhen, ɵɵdefineComponent, ɵɵdefineDirective, ɵɵdefineInjectable, ɵɵdefineInjector, ɵɵdefineNgModule, ɵɵdefinePipe, ɵɵdirectiveInject, ɵɵdisableBindings, ɵɵelement, ɵɵelementContainer, ɵɵelementContainerEnd, ɵɵelementContainerStart, ɵɵelementEnd, ɵɵelementStart, ɵɵenableBindings, ɵɵgetComponentDepsFactory, ɵɵgetCurrentView, ɵɵgetInheritedFactory, ɵɵhostProperty, ɵɵi18n, ɵɵi18nApply, ɵɵi18nAttributes, ɵɵi18nEnd, ɵɵi18nExp, ɵɵi18nPostprocess, ɵɵi18nStart, ɵɵinject, ɵɵinjectAttribute, ɵɵinvalidFactory, ɵɵinvalidFactoryDep, ɵɵlistener, ɵɵloadQuery, ɵɵnamespaceHTML, ɵɵnamespaceMathML, ɵɵnamespaceSVG, ɵɵnextContext, ɵɵngDeclareClassMetadata, ɵɵngDeclareComponent, ɵɵngDeclareDirective, ɵɵngDeclareFactory, ɵɵngDeclareInjectable, ɵɵngDeclareInjector, ɵɵngDeclareNgModule, ɵɵngDeclarePipe, ɵɵpipe, ɵɵpipeBind1, ɵɵpipeBind2, ɵɵpipeBind3, ɵɵpipeBind4, ɵɵpipeBindV, ɵɵprojection, ɵɵprojectionDef, ɵɵproperty, ɵɵpropertyInterpolate, ɵɵpropertyInterpolate1, ɵɵpropertyInterpolate2, ɵɵpropertyInterpolate3, ɵɵpropertyInterpolate4, ɵɵpropertyInterpolate5, ɵɵpropertyInterpolate6, ɵɵpropertyInterpolate7, ɵɵpropertyInterpolate8, ɵɵpropertyInterpolateV, ɵɵpureFunction0, ɵɵpureFunction1, ɵɵpureFunction2, ɵɵpureFunction3, ɵɵpureFunction4, ɵɵpureFunction5, ɵɵpureFunction6, ɵɵpureFunction7, ɵɵpureFunction8, ɵɵpureFunctionV, ɵɵqueryRefresh, ɵɵreference, registerNgModuleType as ɵɵregisterNgModuleType, ɵɵrepeater, ɵɵrepeaterCreate, ɵɵrepeaterTrackByIdentity, ɵɵrepeaterTrackByIndex, ɵɵresetView, ɵɵresolveBody, ɵɵresolveDocument, ɵɵresolveWindow, ɵɵrestoreView, ɵɵsanitizeHtml, ɵɵsanitizeResourceUrl, ɵɵsanitizeScript, ɵɵsanitizeStyle, ɵɵsanitizeUrl, ɵɵsanitizeUrlOrResourceUrl, ɵɵsetComponentScope, ɵɵsetNgModuleScope, ɵɵstyleMap, ɵɵstyleMapInterpolate1, ɵɵstyleMapInterpolate2, ɵɵstyleMapInterpolate3, ɵɵstyleMapInterpolate4, ɵɵstyleMapInterpolate5, ɵɵstyleMapInterpolate6, ɵɵstyleMapInterpolate7, ɵɵstyleMapInterpolate8, ɵɵstyleMapInterpolateV, ɵɵstyleProp, ɵɵstylePropInterpolate1, ɵɵstylePropInterpolate2, ɵɵstylePropInterpolate3, ɵɵstylePropInterpolate4, ɵɵstylePropInterpolate5, ɵɵstylePropInterpolate6, ɵɵstylePropInterpolate7, ɵɵstylePropInterpolate8, ɵɵstylePropInterpolateV, ɵɵsyntheticHostListener, ɵɵsyntheticHostProperty, ɵɵtemplate, ɵɵtemplateRefExtractor, ɵɵtext, ɵɵtextInterpolate, ɵɵtextInterpolate1, ɵɵtextInterpolate2, ɵɵtextInterpolate3, ɵɵtextInterpolate4, ɵɵtextInterpolate5, ɵɵtextInterpolate6, ɵɵtextInterpolate7, ɵɵtextInterpolate8, ɵɵtextInterpolateV, ɵɵtrustConstantHtml, ɵɵtrustConstantResourceUrl, ɵɵvalidateIframeAttribute, ɵɵviewQuery };
 //# sourceMappingURL=core.mjs.map