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

package/fesm2022/core.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v17.0.0-next.8
+ * @license Angular v17.0.0-rc.1
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -673,6 +673,93 @@ function initNgDevMode() {
     return false;
 }
 
+/**
+ * Creates a token that can be used in a DI Provider.
+ *
+ * Use an `InjectionToken` whenever the type you are injecting is not reified (does not have a
+ * runtime representation) such as when injecting an interface, callable type, array or
+ * parameterized type.
+ *
+ * `InjectionToken` is parameterized on `T` which is the type of object which will be returned by
+ * the `Injector`. This provides an additional level of type safety.
+ *
+ * <div class="alert is-helpful">
+ *
+ * **Important Note**: Ensure that you use the same instance of the `InjectionToken` in both the
+ * provider and the injection call. Creating a new instance of `InjectionToken` in different places,
+ * even with the same description, will be treated as different tokens by Angular's DI system,
+ * leading to a `NullInjectorError`.
+ *
+ * </div>
+ *
+ * <code-example format="typescript" language="typescript" path="injection-token/src/main.ts"
+ * region="InjectionToken"></code-example>
+ *
+ * When creating an `InjectionToken`, you can optionally specify a factory function which returns
+ * (possibly by creating) a default value of the parameterized type `T`. This sets up the
+ * `InjectionToken` using this factory as a provider as if it was defined explicitly in the
+ * application's root injector. If the factory function, which takes zero arguments, needs to inject
+ * dependencies, it can do so using the [`inject`](api/core/inject) function.
+ * As you can see in the Tree-shakable InjectionToken example below.
+ *
+ * Additionally, if a `factory` is specified you can also specify the `providedIn` option, which
+ * overrides the above behavior and marks the token as belonging to a particular `@NgModule` (note:
+ * this option is now deprecated). As mentioned above, `'root'` is the default value for
+ * `providedIn`.
+ *
+ * The `providedIn: NgModule` and `providedIn: 'any'` options are deprecated.
+ *
+ * @usageNotes
+ * ### Basic Examples
+ *
+ * ### Plain InjectionToken
+ *
+ * {@example core/di/ts/injector_spec.ts region='InjectionToken'}
+ *
+ * ### Tree-shakable InjectionToken
+ *
+ * {@example core/di/ts/injector_spec.ts region='ShakableInjectionToken'}
+ *
+ * @publicApi
+ */
+class InjectionToken {
+    /**
+     * @param _desc   Description for the token,
+     *                used only for debugging purposes,
+     *                it should but does not need to be unique
+     * @param options Options for the token's usage, as described above
+     */
+    constructor(_desc, options) {
+        this._desc = _desc;
+        /** @internal */
+        this.ngMetadataName = 'InjectionToken';
+        this.ɵprov = undefined;
+        if (typeof options == 'number') {
+            (typeof ngDevMode === 'undefined' || ngDevMode) &&
+                assertLessThan(options, 0, 'Only negative numbers are supported here');
+            // This is a special hack to assign __NG_ELEMENT_ID__ to this instance.
+            // See `InjectorMarkers`
+            this.__NG_ELEMENT_ID__ = options;
+        }
+        else if (options !== undefined) {
+            this.ɵprov = ɵɵdefineInjectable({
+                token: this,
+                providedIn: options.providedIn || 'root',
+                factory: options.factory,
+            });
+        }
+    }
+    /**
+     * @internal
+     */
+    get multi() {
+        return this;
+    }
+    toString() {
+        return `InjectionToken ${this._desc}`;
+    }
+}
+
 let _injectorProfilerContext;
 function getInjectorProfilerContext() {
     !ngDevMode && throwError('getInjectorProfilerContext should never be called in production mode');
@@ -714,18 +801,35 @@ function injectorProfiler(event) {
  * Emits an InjectorProfilerEventType.ProviderConfigured to the injector profiler. The data in the
  * emitted event includes the raw provider, as well as the token that provider is providing.
  *
- * @param provider A provider object
+ * @param eventProvider A provider object
  */
-function emitProviderConfiguredEvent(provider, isViewProvider = false) {
+function emitProviderConfiguredEvent(eventProvider, isViewProvider = false) {
     !ngDevMode && throwError('Injector profiler should never be called in production mode');
+    let token;
+    // if the provider is a TypeProvider (typeof provider is function) then the token is the
+    // provider itself
+    if (typeof eventProvider === 'function') {
+        token = eventProvider;
+    }
+    // if the provider is an injection token, then the token is the injection token.
+    else if (eventProvider instanceof InjectionToken) {
+        token = eventProvider;
+    }
+    // in all other cases we can access the token via the `provide` property of the provider
+    else {
+        token = resolveForwardRef(eventProvider.provide);
+    }
+    let provider = eventProvider;
+    // Injection tokens may define their own default provider which gets attached to the token itself
+    // as `ɵprov`. In this case, we want to emit the provider that is attached to the token, not the
+    // token itself.
+    if (eventProvider instanceof InjectionToken) {
+        provider = eventProvider.ɵprov || eventProvider;
+    }
     injectorProfiler({
         type: 2 /* InjectorProfilerEventType.ProviderConfigured */,
         context: getInjectorProfilerContext(),
-        providerRecord: {
-            token: typeof provider === 'function' ? provider : resolveForwardRef(provider.provide),
-            provider,
-            isViewProvider
-        }
+        providerRecord: { token, provider, isViewProvider }
     });
 }
 /**
@@ -2107,9 +2211,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 +2248,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`.
@@ -2643,9 +2741,6 @@ function updateAncestorTraversalFlagsOnAttach(lView) {
  */
 function markAncestorsForTraversal(lView) {
     let parent = lView[PARENT];
-    if (parent === null) {
-        return;
-    }
     while (parent !== null) {
         // We stop adding markers to the ancestors once we reach one that already has the marker. This
         // is to avoid needlessly traversing all the way to the root when the marker already exists.
@@ -3576,9 +3671,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 +3702,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.
  *
@@ -5483,93 +5572,6 @@ function componentDefResolved(type) {
     componentDefPendingResolution.delete(type);
 }
 
-/**
- * Creates a token that can be used in a DI Provider.
- *
- * Use an `InjectionToken` whenever the type you are injecting is not reified (does not have a
- * runtime representation) such as when injecting an interface, callable type, array or
- * parameterized type.
- *
- * `InjectionToken` is parameterized on `T` which is the type of object which will be returned by
- * the `Injector`. This provides an additional level of type safety.
- *
- * <div class="alert is-helpful">
- *
- * **Important Note**: Ensure that you use the same instance of the `InjectionToken` in both the
- * provider and the injection call. Creating a new instance of `InjectionToken` in different places,
- * even with the same description, will be treated as different tokens by Angular's DI system,
- * leading to a `NullInjectorError`.
- *
- * </div>
- *
- * <code-example format="typescript" language="typescript" path="injection-token/src/main.ts"
- * region="InjectionToken"></code-example>
- *
- * When creating an `InjectionToken`, you can optionally specify a factory function which returns
- * (possibly by creating) a default value of the parameterized type `T`. This sets up the
- * `InjectionToken` using this factory as a provider as if it was defined explicitly in the
- * application's root injector. If the factory function, which takes zero arguments, needs to inject
- * dependencies, it can do so using the [`inject`](api/core/inject) function.
- * As you can see in the Tree-shakable InjectionToken example below.
- *
- * Additionally, if a `factory` is specified you can also specify the `providedIn` option, which
- * overrides the above behavior and marks the token as belonging to a particular `@NgModule` (note:
- * this option is now deprecated). As mentioned above, `'root'` is the default value for
- * `providedIn`.
- *
- * The `providedIn: NgModule` and `providedIn: 'any'` options are deprecated.
- *
- * @usageNotes
- * ### Basic Examples
- *
- * ### Plain InjectionToken
- *
- * {@example core/di/ts/injector_spec.ts region='InjectionToken'}
- *
- * ### Tree-shakable InjectionToken
- *
- * {@example core/di/ts/injector_spec.ts region='ShakableInjectionToken'}
- *
- * @publicApi
- */
-class InjectionToken {
-    /**
-     * @param _desc   Description for the token,
-     *                used only for debugging purposes,
-     *                it should but does not need to be unique
-     * @param options Options for the token's usage, as described above
-     */
-    constructor(_desc, options) {
-        this._desc = _desc;
-        /** @internal */
-        this.ngMetadataName = 'InjectionToken';
-        this.ɵprov = undefined;
-        if (typeof options == 'number') {
-            (typeof ngDevMode === 'undefined' || ngDevMode) &&
-                assertLessThan(options, 0, 'Only negative numbers are supported here');
-            // This is a special hack to assign __NG_ELEMENT_ID__ to this instance.
-            // See `InjectorMarkers`
-            this.__NG_ELEMENT_ID__ = options;
-        }
-        else if (options !== undefined) {
-            this.ɵprov = ɵɵdefineInjectable({
-                token: this,
-                providedIn: options.providedIn || 'root',
-                factory: options.factory,
-            });
-        }
-    }
-    /**
-     * @internal
-     */
-    get multi() {
-        return this;
-    }
-    toString() {
-        return `InjectionToken ${this._desc}`;
-    }
-}
-
 /**
  * A multi-provider token for initialization functions that will run upon construction of an
  * environment injector.
@@ -6014,6 +6016,11 @@ class R3Injector extends EnvironmentInjector {
                     if (def && this.injectableDefInScope(def)) {
                         // Found an injectable def and it's scoped to this injector. Pretend as if it was here
                         // all along.
+                        if (ngDevMode) {
+                            runInInjectorProfilerContext(this, token, () => {
+                                emitProviderConfiguredEvent(token);
+                            });
+                        }
                         record = makeRecord(injectableDefOrInjectorDefFactory(token), NOT_YET);
                     }
                     else {
@@ -6749,16 +6756,6 @@ const CSP_NONCE = new InjectionToken('CSP nonce', {
         return getDocument().body?.querySelector('[ngCspNonce]')?.getAttribute('ngCspNonce') || null;
     },
 });
-/**
- * Internal token to collect all SSR-related features enabled for this application.
- *
- * Note: the token is in `core` to let other packages register features (the `core`
- * package is imported in other packages).
- */
-const ENABLED_SSR_FEATURES = new InjectionToken((typeof ngDevMode === 'undefined' || ngDevMode) ? 'ENABLED_SSR_FEATURES' : '', {
-    providedIn: 'root',
-    factory: () => new Set(),
-});
 const IMAGE_CONFIG_DEFAULTS = {
     breakpoints: [16, 32, 48, 64, 96, 128, 256, 384, 640, 750, 828, 1080, 1200, 1920, 2048, 3840],
     disableImageSizeWarning: false,
@@ -7419,11 +7416,12 @@ function matchingSchemas(schemas, tagName) {
  * (component host node) to disable hydration for the content within that boundary.
  */
 const SKIP_HYDRATION_ATTR_NAME = 'ngSkipHydration';
+/** Lowercase name of the `ngSkipHydration` attribute used for case-insensitive comparisons. */
+const SKIP_HYDRATION_ATTR_NAME_LOWER_CASE = 'ngskiphydration';
 /**
  * Helper function to check if a given TNode has the 'ngSkipHydration' attribute.
  */
 function hasSkipHydrationAttrOnTNode(tNode) {
-    const SKIP_HYDRATION_ATTR_NAME_LOWER_CASE = SKIP_HYDRATION_ATTR_NAME.toLowerCase();
     const attrs = tNode.mergedAttrs;
     if (attrs === null)
         return false;
@@ -7457,15 +7455,14 @@ function hasInSkipHydrationBlockFlag(tNode) {
  * Helper function that determines if a given node is within a skip hydration block
  * by navigating up the TNode tree to see if any parent nodes have skip hydration
  * attribute.
- *
- * TODO(akushnir): this function should contain the logic of `hasInSkipHydrationBlockFlag`,
- * there is no need to traverse parent nodes when we have a TNode flag (which would also
- * make this lookup O(1)).
  */
 function isInSkipHydrationBlock(tNode) {
+    if (hasInSkipHydrationBlockFlag(tNode)) {
+        return true;
+    }
     let currentTNode = tNode.parent;
     while (currentTNode) {
-        if (hasSkipHydrationAttrOnTNode(currentTNode)) {
+        if (hasInSkipHydrationBlockFlag(tNode) || hasSkipHydrationAttrOnTNode(currentTNode)) {
             return true;
         }
         currentTNode = currentTNode.parent;
@@ -9997,7 +9994,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 +10426,7 @@ class Version {
 /**
  * @publicApi
  */
-const VERSION = new Version('17.0.0-next.8');
+const VERSION = new Version('17.0.0-rc.1');
 
 // This default value is when checking the hierarchy for a token.
 //
@@ -11410,6 +11407,34 @@ var AfterRenderPhase;
      */
     AfterRenderPhase[AfterRenderPhase["Read"] = 3] = "Read";
 })(AfterRenderPhase || (AfterRenderPhase = {}));
+/** `AfterRenderRef` that does nothing. */
+const NOOP_AFTER_RENDER_REF = {
+    destroy() { }
+};
+/**
+ * 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);
+    // Similarly to the public `afterNextRender` function, an internal one
+    // is only invoked in a browser.
+    if (!isPlatformBrowser(injector))
+        return;
+    const afterRenderEventManager = injector.get(AfterRenderEventManager);
+    afterRenderEventManager.internalCallbacks.push(callback);
+}
 /**
  * Register a callback to be invoked each time the application
  * finishes rendering.
@@ -11465,22 +11490,20 @@ function afterRender(callback, options) {
     !options && assertInInjectionContext(afterRender);
     const injector = options?.injector ?? inject(Injector);
     if (!isPlatformBrowser(injector)) {
-        return { destroy() { } };
+        return NOOP_AFTER_RENDER_REF;
     }
-    let destroy;
-    const unregisterFn = injector.get(DestroyRef).onDestroy(() => destroy?.());
+    performance.mark('mark_use_counter', { detail: { feature: 'NgAfterRender' } });
     const afterRenderEventManager = injector.get(AfterRenderEventManager);
     // Lazily initialize the handler implementation, if necessary. This is so that it can be
     // tree-shaken if `afterRender` and `afterNextRender` aren't used.
     const callbackHandler = afterRenderEventManager.handler ??= new AfterRenderCallbackHandlerImpl();
-    const ngZone = injector.get(NgZone);
-    const errorHandler = injector.get(ErrorHandler, null, { optional: true });
     const phase = options?.phase ?? AfterRenderPhase.MixedReadWrite;
-    const instance = new AfterRenderCallback(ngZone, errorHandler, phase, callback);
-    destroy = () => {
+    const destroy = () => {
         callbackHandler.unregister(instance);
         unregisterFn();
     };
+    const unregisterFn = injector.get(DestroyRef).onDestroy(destroy);
+    const instance = new AfterRenderCallback(injector, phase, callback);
     callbackHandler.register(instance);
     return { destroy };
 }
@@ -11537,25 +11560,23 @@ function afterNextRender(callback, options) {
     !options && assertInInjectionContext(afterNextRender);
     const injector = options?.injector ?? inject(Injector);
     if (!isPlatformBrowser(injector)) {
-        return { destroy() { } };
+        return NOOP_AFTER_RENDER_REF;
     }
-    let destroy;
-    const unregisterFn = injector.get(DestroyRef).onDestroy(() => destroy?.());
+    performance.mark('mark_use_counter', { detail: { feature: 'NgAfterNextRender' } });
     const afterRenderEventManager = injector.get(AfterRenderEventManager);
     // Lazily initialize the handler implementation, if necessary. This is so that it can be
     // tree-shaken if `afterRender` and `afterNextRender` aren't used.
     const callbackHandler = afterRenderEventManager.handler ??= new AfterRenderCallbackHandlerImpl();
-    const ngZone = injector.get(NgZone);
-    const errorHandler = injector.get(ErrorHandler, null, { optional: true });
     const phase = options?.phase ?? AfterRenderPhase.MixedReadWrite;
-    const instance = new AfterRenderCallback(ngZone, errorHandler, phase, () => {
-        destroy?.();
-        callback();
-    });
-    destroy = () => {
+    const destroy = () => {
         callbackHandler.unregister(instance);
         unregisterFn();
     };
+    const unregisterFn = injector.get(DestroyRef).onDestroy(destroy);
+    const instance = new AfterRenderCallback(injector, phase, () => {
+        destroy();
+        callback();
+    });
     callbackHandler.register(instance);
     return { destroy };
 }
@@ -11563,11 +11584,11 @@ function afterNextRender(callback, options) {
  * A wrapper around a function to be used as an after render callback.
  */
 class AfterRenderCallback {
-    constructor(zone, errorHandler, phase, callbackFn) {
-        this.zone = zone;
-        this.errorHandler = errorHandler;
+    constructor(injector, phase, callbackFn) {
         this.phase = phase;
         this.callbackFn = callbackFn;
+        this.zone = injector.get(NgZone);
+        this.errorHandler = injector.get(ErrorHandler, null, { optional: true });
     }
     invoke() {
         try {
@@ -11640,6 +11661,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 +11680,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 +11871,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
@@ -13512,6 +13538,10 @@ function collectNativeNodesInLContainer(lContainer, result) {
     }
 }
 
+/**
+ * The maximum number of times the change detection traversal will rerun before throwing an error.
+ */
+const MAXIMUM_REFRESH_RERUNS = 100;
 function detectChangesInternal(tView, lView, context, notifyErrorHandler = true) {
     const environment = lView[ENVIRONMENT];
     const rendererFactory = environment.rendererFactory;
@@ -13526,6 +13556,23 @@ function detectChangesInternal(tView, lView, context, notifyErrorHandler = true)
     }
     try {
         refreshView(tView, lView, tView.template, context);
+        let retries = 0;
+        // If after running change detection, this view still needs to be refreshed or there are
+        // descendants views that need to be refreshed due to re-dirtying during the change detection
+        // run, detect changes on the view again. We run change detection in `Targeted` mode to only
+        // refresh views with the `RefreshView` flag.
+        while (lView[FLAGS] & (1024 /* LViewFlags.RefreshView */ | 8192 /* LViewFlags.HasChildViewsToRefresh */)) {
+            if (retries === MAXIMUM_REFRESH_RERUNS) {
+                throw new RuntimeError(103 /* RuntimeErrorCode.INFINITE_CHANGE_DETECTION */, ngDevMode &&
+                    'Infinite change detection while trying to refresh views. ' +
+                        'There may be components which each cause the other to require a refresh, ' +
+                        'causing an infinite loop.');
+            }
+            retries++;
+            // Even if this view is detached, we still detect changes in targeted mode because this was
+            // the root of the change detection run.
+            detectChangesInView(lView, 1 /* ChangeDetectionMode.Targeted */);
+        }
     }
     catch (error) {
         if (notifyErrorHandler) {
@@ -13680,7 +13727,6 @@ function refreshView(tView, lView, templateFn, context) {
         if (!isInCheckNoChangesPass) {
             lView[FLAGS] &= ~(64 /* LViewFlags.Dirty */ | 8 /* LViewFlags.FirstLViewPass */);
         }
-        lView[FLAGS] &= ~1024 /* LViewFlags.RefreshView */;
     }
     catch (e) {
         // If refreshing a view causes an error, we need to remark the ancestors as needing traversal
@@ -13763,7 +13809,7 @@ function detectChangesInView(lView, mode) {
     const flags = lView[FLAGS];
     // Flag cleared before change detection runs so that the view can be re-marked for traversal if
     // necessary.
-    lView[FLAGS] &= ~8192 /* LViewFlags.HasChildViewsToRefresh */;
+    lView[FLAGS] &= ~(8192 /* LViewFlags.HasChildViewsToRefresh */ | 1024 /* LViewFlags.RefreshView */);
     if ((flags & (16 /* LViewFlags.CheckAlways */ | 64 /* LViewFlags.Dirty */) &&
         mode === 0 /* ChangeDetectionMode.Global */) ||
         flags & 1024 /* LViewFlags.RefreshView */) {
@@ -18264,6 +18310,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 +18353,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 +18401,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 +18436,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 +18467,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 +18505,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;
 }
@@ -18923,10 +18993,8 @@ function populateDehydratedViewsInLContainerImpl(lContainer, tNode, hostLView) {
     }
     const hydrationInfo = hostLView[HYDRATION];
     const noOffsetIndex = tNode.index - HEADER_OFFSET;
-    // TODO(akushnir): this should really be a single condition, refactor the code
-    // to use `hasInSkipHydrationBlockFlag` logic inside `isInSkipHydrationBlock`.
-    const skipHydration = isInSkipHydrationBlock(tNode) || hasInSkipHydrationBlockFlag(tNode);
-    const isNodeCreationMode = !hydrationInfo || skipHydration || isDisconnectedNode$1(hydrationInfo, noOffsetIndex);
+    const isNodeCreationMode = !hydrationInfo || isInSkipHydrationBlock(tNode) ||
+        isDisconnectedNode$1(hydrationInfo, noOffsetIndex);
     // Regular creation mode.
     if (isNodeCreationMode) {
         return false;
@@ -19150,9 +19218,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 +19266,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 +19282,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 +19302,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 +19332,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);
@@ -19362,6 +19440,8 @@ const NEXT_DEFER_BLOCK_STATE = 0;
 const DEFER_BLOCK_STATE = 1;
 const STATE_IS_FROZEN_UNTIL = 2;
 const LOADING_AFTER_CLEANUP_FN = 3;
+const TRIGGER_CLEANUP_FNS = 4;
+const PREFETCH_TRIGGER_CLEANUP_FNS = 5;
 /**
  * Options for configuring defer blocks behavior.
  * @publicApi
@@ -19380,6 +19460,155 @@ var DeferBlockBehavior;
     DeferBlockBehavior[DeferBlockBehavior["Playthrough"] = 1] = "Playthrough";
 })(DeferBlockBehavior || (DeferBlockBehavior = {}));
 
+/*!
+ * @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
+ * or a regular trigger of a defer block.
+ */
+function storeTriggerCleanupFn(type, lDetails, cleanupFn) {
+    const key = type === 1 /* TriggerType.Prefetch */ ? PREFETCH_TRIGGER_CLEANUP_FNS : TRIGGER_CLEANUP_FNS;
+    if (lDetails[key] === null) {
+        lDetails[key] = [];
+    }
+    lDetails[key].push(cleanupFn);
+}
+/**
+ * Invokes registered cleanup functions either for prefetch or for regular triggers.
+ */
+function invokeTriggerCleanupFns(type, lDetails) {
+    const key = type === 1 /* TriggerType.Prefetch */ ? PREFETCH_TRIGGER_CLEANUP_FNS : TRIGGER_CLEANUP_FNS;
+    const cleanupFns = lDetails[key];
+    if (cleanupFns !== null) {
+        for (const cleanupFn of cleanupFns) {
+            cleanupFn();
+        }
+        lDetails[key] = null;
+    }
+}
+/**
+ * Invokes registered cleanup functions for both prefetch and regular triggers.
+ */
+function invokeAllTriggerCleanupFns(lDetails) {
+    invokeTriggerCleanupFns(1 /* TriggerType.Prefetch */, lDetails);
+    invokeTriggerCleanupFns(0 /* TriggerType.Regular */, lDetails);
+}
+
+/**
+ * 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 +19625,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() {
@@ -19415,13 +19650,12 @@ class DeferEventEntry {
  * Registers an interaction trigger.
  * @param trigger Element that is the trigger.
  * @param callback Callback to be invoked when the trigger is interacted with.
- * @param injector Injector that can be used by the trigger to resolve DI tokens.
  */
-function onInteraction(trigger, callback, injector) {
+function onInteraction(trigger, callback) {
     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 +19668,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 () => {
@@ -19458,21 +19690,18 @@ function onInteraction(trigger, callback, injector) {
  * Registers a hover trigger.
  * @param trigger Element that is the trigger.
  * @param callback Callback to be invoked when the trigger is hovered over.
- * @param injector Injector that can be used by the trigger to resolve DI tokens.
  */
-function onHover(trigger, callback, injector) {
+function onHover(trigger, callback) {
     let entry = hoverTriggers.get(trigger);
     // If this is the first entry for this element, add the listener.
     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 +19722,442 @@ 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.
+ * @param type Trigger type to distinguish between regular and prefetch triggers.
+ */
+function registerDomTrigger(initialLView, tNode, triggerIndex, walkUpTimes, registerFn, callback, type) {
+    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;
+        }
+        const element = getTriggerElement(triggerLView, triggerIndex);
+        const cleanup = registerFn(element, () => {
+            if (initialLView !== triggerLView) {
+                removeLViewOnDestroy(triggerLView, cleanup);
+            }
+            callback();
+        }, injector);
+        // The trigger and deferred block might be in different LViews.
+        // For the main LView the cleanup would happen as a part of
+        // `storeTriggerCleanupFn` logic. For trigger LView we register
+        // a cleanup function there to remove event handlers in case an
+        // LView gets destroyed before a trigger is invoked.
+        if (initialLView !== triggerLView) {
+            storeLViewOnDestroy(triggerLView, cleanup);
+        }
+        storeTriggerCleanupFn(type, lDetails, 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.
+ */
+function onIdle(callback, lView) {
+    const injector = lView[INJECTOR$1];
+    const scheduler = injector.get(IdleScheduler);
+    const cleanupFn = () => scheduler.remove(callback);
+    scheduler.add(callback);
+    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.requestIdleCallbackFn = _requestIdleCallback().bind(globalThis);
+        this.cancelIdleCallbackFn = _cancelIdleCallback().bind(globalThis);
+    }
+    add(callback) {
+        const target = this.executingCallbacks ? this.deferred : this.current;
+        target.add(callback);
+        if (this.idleId === null) {
+            this.scheduleIdleCallback();
+        }
+    }
+    remove(callback) {
+        const { current, deferred } = this;
+        current.delete(callback);
+        deferred.delete(callback);
+        // If the last callback was removed and there is a pending
+        // idle callback - cancel it.
+        if (current.size === 0 && deferred.size === 0) {
+            this.cancelIdleCallback();
+        }
+    }
+    scheduleIdleCallback() {
+        const callback = () => {
+            this.cancelIdleCallback();
+            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.requestIdleCallbackFn(() => this.ngZone.run(callback));
+    }
+    cancelIdleCallback() {
+        if (this.idleId !== null) {
+            this.cancelIdleCallbackFn(this.idleId);
+            this.idleId = null;
+        }
+    }
+    ngOnDestroy() {
+        this.cancelIdleCallback();
+        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) => scheduleTimerTrigger(delay, callback, lView);
+}
+/**
+ * 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.
+ */
+function scheduleTimerTrigger(delay, callback, lView) {
+    const injector = lView[INJECTOR$1];
+    const scheduler = injector.get(TimerScheduler);
+    const cleanupFn = () => scheduler.remove(callback);
+    scheduler.add(delay, callback);
+    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 { current, deferred } = this;
+        const callbackIndex = this.removeFromQueue(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(deferred, callback);
+        }
+        // If the last callback was removed and there is a pending timeout - cancel it.
+        if (current.length === 0 && deferred.length === 0) {
+            this.clearTimeout();
+        }
+    }
+    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 = () => {
+            this.clearTimeout();
+            this.executingCallbacks = true;
+            // Clone the current state of the queue, since it might be altered
+            // as we invoke callbacks.
+            const current = [...this.current];
+            // Invoke callbacks that were scheduled to run before the current time.
+            const now = Date.now();
+            for (let i = 0; i < current.length; i += 2) {
+                const invokeAt = current[i];
+                const callback = current[i + 1];
+                if (invokeAt <= now) {
+                    callback();
+                }
+                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--;
+            // The state of the queue might've changed after callbacks invocation,
+            // run the cleanup logic based on the *current* state of the queue.
+            let lastCallbackIndex = -1;
+            for (let i = 0; i < this.current.length; i += 2) {
+                const invokeAt = this.current[i];
+                if (invokeAt <= now) {
+                    // Add +1 to account for a callback function that
+                    // goes after the timestamp in events array.
+                    lastCallbackIndex = i + 1;
+                }
+                else {
+                    // We've reached a timer that should not be invoked yet.
+                    break;
+                }
             }
-            if (this.observedViewportElements === 0) {
-                this.intersectionObserver?.disconnect();
-                this.intersectionObserver = null;
+            if (lastCallbackIndex >= 0) {
+                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 === null ||
+                // 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))) {
+                // 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.
+                this.clearTimeout();
+                const timeout = Math.max(invokeAt - now, FRAME_DURATION_MS);
+                this.invokeTimerAt = invokeAt;
+                this.timeoutId = setTimeout(callback, timeout);
+            }
+        }
     }
+    clearTimeout() {
+        if (this.timeoutId !== null) {
+            clearTimeout(this.timeoutId);
+            this.timeoutId = null;
+        }
+    }
+    ngOnDestroy() {
+        this.clearTimeout();
+        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.
  *
@@ -19616,6 +20222,7 @@ function ɵɵdefer(index, primaryTmplIndex, dependencyResolverFn, loadingTmplInd
     const adjustedIndex = index + HEADER_OFFSET;
     ɵɵtemplate(index, null, 0, 0);
     if (tView.firstCreatePass) {
+        performance.mark('mark_use_counter', { detail: { feature: 'NgDefer' } });
         const tDetails = {
             primaryTmplIndex,
             loadingTmplIndex: loadingTmplIndex ?? null,
@@ -19641,9 +20248,15 @@ function ɵɵdefer(index, primaryTmplIndex, dependencyResolverFn, loadingTmplInd
         null,
         DeferBlockInternalState.Initial,
         null,
-        null // LOADING_AFTER_CLEANUP_FN
+        null,
+        null,
+        null // PREFETCH_TRIGGER_CLEANUP_FNS
     ];
     setLDeferBlockDetails(lView, adjustedIndex, lDetails);
+    const cleanupTriggersFn = () => invokeAllTriggerCleanupFns(lDetails);
+    // When defer block is triggered - unsubscribe from LView destroy cleanup.
+    storeTriggerCleanupFn(0 /* TriggerType.Regular */, lDetails, () => removeLViewOnDestroy(lView, cleanupTriggersFn));
+    storeLViewOnDestroy(lView, cleanupTriggersFn);
 }
 /**
  * Loads defer block dependencies when a trigger value becomes truthy.
@@ -19685,7 +20298,7 @@ function ɵɵdeferPrefetchWhen(rawValue) {
         const tDetails = getTDeferBlockDetails(tView, tNode);
         if (value === true && tDetails.loadingState === DeferDependenciesLoadingState.NOT_STARTED) {
             // If loading has not been started yet, trigger it now.
-            triggerPrefetching(tDetails, lView);
+            triggerPrefetching(tDetails, lView, tNode);
         }
     }
 }
@@ -19701,7 +20314,7 @@ function ɵɵdeferOnIdle() {
  * @codeGenApi
  */
 function ɵɵdeferPrefetchOnIdle() {
-    scheduleDelayedPrefetching(onIdle, 0 /* DeferBlockTriggers.OnIdle */);
+    scheduleDelayedPrefetching(onIdle);
 }
 /**
  * Sets up logic to handle the `on immediate` deferred trigger.
@@ -19730,7 +20343,7 @@ function ɵɵdeferPrefetchOnImmediate() {
     const tView = lView[TVIEW];
     const tDetails = getTDeferBlockDetails(tView, tNode);
     if (tDetails.loadingState === DeferDependenciesLoadingState.NOT_STARTED) {
-        triggerResourceLoading(tDetails, lView);
+        triggerResourceLoading(tDetails, lView, tNode);
     }
 }
 /**
@@ -19747,7 +20360,7 @@ function ɵɵdeferOnTimer(delay) {
  * @codeGenApi
  */
 function ɵɵdeferPrefetchOnTimer(delay) {
-    scheduleDelayedPrefetching(onTimer(delay), 1 /* DeferBlockTriggers.OnTimer */);
+    scheduleDelayedPrefetching(onTimer(delay));
 }
 /**
  * Creates runtime data structures for the `on hover` deferred trigger.
@@ -19759,7 +20372,7 @@ function ɵɵdeferOnHover(triggerIndex, walkUpTimes) {
     const lView = getLView();
     const tNode = getCurrentTNode();
     renderPlaceholder(lView, tNode);
-    registerDomTrigger(lView, tNode, triggerIndex, walkUpTimes, onHover, () => triggerDeferBlock(lView, tNode));
+    registerDomTrigger(lView, tNode, triggerIndex, walkUpTimes, onHover, () => triggerDeferBlock(lView, tNode), 0 /* TriggerType.Regular */);
 }
 /**
  * Creates runtime data structures for the `prefetch on hover` deferred trigger.
@@ -19773,7 +20386,7 @@ function ɵɵdeferPrefetchOnHover(triggerIndex, walkUpTimes) {
     const tView = lView[TVIEW];
     const tDetails = getTDeferBlockDetails(tView, tNode);
     if (tDetails.loadingState === DeferDependenciesLoadingState.NOT_STARTED) {
-        registerDomTrigger(lView, tNode, triggerIndex, walkUpTimes, onHover, () => triggerPrefetching(tDetails, lView));
+        registerDomTrigger(lView, tNode, triggerIndex, walkUpTimes, onHover, () => triggerPrefetching(tDetails, lView, tNode), 1 /* TriggerType.Prefetch */);
     }
 }
 /**
@@ -19786,7 +20399,7 @@ function ɵɵdeferOnInteraction(triggerIndex, walkUpTimes) {
     const lView = getLView();
     const tNode = getCurrentTNode();
     renderPlaceholder(lView, tNode);
-    registerDomTrigger(lView, tNode, triggerIndex, walkUpTimes, onInteraction, () => triggerDeferBlock(lView, tNode));
+    registerDomTrigger(lView, tNode, triggerIndex, walkUpTimes, onInteraction, () => triggerDeferBlock(lView, tNode), 0 /* TriggerType.Regular */);
 }
 /**
  * Creates runtime data structures for the `prefetch on interaction` deferred trigger.
@@ -19800,7 +20413,7 @@ function ɵɵdeferPrefetchOnInteraction(triggerIndex, walkUpTimes) {
     const tView = lView[TVIEW];
     const tDetails = getTDeferBlockDetails(tView, tNode);
     if (tDetails.loadingState === DeferDependenciesLoadingState.NOT_STARTED) {
-        registerDomTrigger(lView, tNode, triggerIndex, walkUpTimes, onInteraction, () => triggerPrefetching(tDetails, lView));
+        registerDomTrigger(lView, tNode, triggerIndex, walkUpTimes, onInteraction, () => triggerPrefetching(tDetails, lView, tNode), 1 /* TriggerType.Prefetch */);
     }
 }
 /**
@@ -19813,7 +20426,7 @@ function ɵɵdeferOnViewport(triggerIndex, walkUpTimes) {
     const lView = getLView();
     const tNode = getCurrentTNode();
     renderPlaceholder(lView, tNode);
-    registerDomTrigger(lView, tNode, triggerIndex, walkUpTimes, onViewport, () => triggerDeferBlock(lView, tNode));
+    registerDomTrigger(lView, tNode, triggerIndex, walkUpTimes, onViewport, () => triggerDeferBlock(lView, tNode), 0 /* TriggerType.Regular */);
 }
 /**
  * Creates runtime data structures for the `prefetch on viewport` deferred trigger.
@@ -19827,7 +20440,7 @@ function ɵɵdeferPrefetchOnViewport(triggerIndex, walkUpTimes) {
     const tView = lView[TVIEW];
     const tDetails = getTDeferBlockDetails(tView, tNode);
     if (tDetails.loadingState === DeferDependenciesLoadingState.NOT_STARTED) {
-        registerDomTrigger(lView, tNode, triggerIndex, walkUpTimes, onViewport, () => triggerPrefetching(tDetails, lView));
+        registerDomTrigger(lView, tNode, triggerIndex, walkUpTimes, onViewport, () => triggerPrefetching(tDetails, lView, tNode), 1 /* TriggerType.Prefetch */);
     }
 }
 /********** Helper functions **********/
@@ -19838,253 +20451,26 @@ function scheduleDelayedTrigger(scheduleFn) {
     const lView = getLView();
     const tNode = getCurrentTNode();
     renderPlaceholder(lView, tNode);
-    scheduleFn(() => triggerDeferBlock(lView, tNode), lView, true /* withLViewCleanup */);
+    const cleanupFn = scheduleFn(() => triggerDeferBlock(lView, tNode), lView);
+    const lDetails = getLDeferBlockDetails(lView, tNode);
+    storeTriggerCleanupFn(0 /* TriggerType.Regular */, lDetails, cleanupFn);
 }
 /**
  * Schedules prefetching for `on idle` and `on timer` triggers.
  *
  * @param scheduleFn A function that does the scheduling.
- * @param trigger A trigger that initiated scheduling.
  */
-function scheduleDelayedPrefetching(scheduleFn, trigger) {
+function scheduleDelayedPrefetching(scheduleFn) {
     const lView = getLView();
     const tNode = getCurrentTNode();
     const tView = lView[TVIEW];
     const tDetails = getTDeferBlockDetails(tView, tNode);
     if (tDetails.loadingState === DeferDependenciesLoadingState.NOT_STARTED) {
-        // Prevent scheduling more than one prefetch init call
-        // for each defer block. For this reason we use only a trigger
-        // identifier in a key, so all instances would use the same key.
-        const key = String(trigger);
-        const injector = lView[INJECTOR$1];
-        const manager = injector.get(DeferBlockCleanupManager);
-        if (!manager.has(tDetails, key)) {
-            // In case of prefetching, we intentionally avoid cancelling resource loading if
-            // an underlying LView get destroyed (thus passing `null` as a second argument),
-            // because there might be other LViews (that represent embedded views) that
-            // depend on resource loading.
-            const prefetch = () => triggerPrefetching(tDetails, lView);
-            const cleanupFn = scheduleFn(prefetch, lView, false /* withLViewCleanup */);
-            registerTDetailsCleanup(injector, tDetails, key, cleanupFn);
-        }
-    }
-}
-/**
- * Helper function to get the LView in which a deferred block's trigger is rendered.
- * @param deferredHostLView LView in which the deferred block is defined.
- * @param deferredTNode TNode defining the deferred block.
- * @param walkUpTimes Number of times to go up in the view hierarchy to find the trigger's view.
- *   A negative value means that the trigger is inside the block's placeholder, while an undefined
- *   value means that the trigger is in the same LView as the deferred block.
- */
-function getTriggerLView(deferredHostLView, deferredTNode, walkUpTimes) {
-    // The trigger is in the same view, we don't need to traverse.
-    if (walkUpTimes == null) {
-        return deferredHostLView;
-    }
-    // A positive value or zero means that the trigger is in a parent view.
-    if (walkUpTimes >= 0) {
-        return walkUpViews(walkUpTimes, deferredHostLView);
-    }
-    // If the value is negative, it means that the trigger is inside the placeholder.
-    const deferredContainer = deferredHostLView[deferredTNode.index];
-    ngDevMode && assertLContainer(deferredContainer);
-    const triggerLView = deferredContainer[CONTAINER_HEADER_OFFSET] ?? null;
-    // We need to null check, because the placeholder might not have been rendered yet.
-    if (ngDevMode && triggerLView !== null) {
-        const lDetails = getLDeferBlockDetails(deferredHostLView, deferredTNode);
-        const renderedState = lDetails[DEFER_BLOCK_STATE];
-        assertEqual(renderedState, DeferBlockState.Placeholder, 'Expected a placeholder to be rendered in this defer block.');
-        assertLView(triggerLView);
-    }
-    return triggerLView;
-}
-/**
- * Gets the element that a deferred block's trigger is pointing to.
- * @param triggerLView LView in which the trigger is defined.
- * @param triggerIndex Index at which the trigger element should've been rendered.
- */
-function getTriggerElement(triggerLView, triggerIndex) {
-    const element = getNativeByIndex(HEADER_OFFSET + triggerIndex, triggerLView);
-    ngDevMode && assertElement(element);
-    return element;
-}
-/**
- * Registers a DOM-node based trigger.
- * @param initialLView LView in which the defer block is rendered.
- * @param tNode TNode representing the defer block.
- * @param triggerIndex Index at which to find the trigger element.
- * @param walkUpTimes Number of times to go up/down in the view hierarchy to find the trigger.
- * @param registerFn Function that will register the DOM events.
- * @param callback Callback to be invoked when the trigger receives the event that should render
- *     the deferred block.
- */
-function registerDomTrigger(initialLView, tNode, triggerIndex, walkUpTimes, registerFn, callback) {
-    const injector = initialLView[INJECTOR$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;
+        const lDetails = getLDeferBlockDetails(lView, tNode);
+        const prefetch = () => triggerPrefetching(tDetails, lView, tNode);
+        const cleanupFn = scheduleFn(prefetch, lView);
+        storeTriggerCleanupFn(1 /* TriggerType.Prefetch */, lDetails, cleanupFn);
     }
-    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
@@ -20093,8 +20479,12 @@ function getLoadingBlockAfter(tDetails) {
  * @param newState New state that should be applied to the defer block.
  * @param tNode TNode that represents a defer block.
  * @param lContainer Represents an instance of a defer block.
+ * @param skipTimerScheduling Indicates that `@loading` and `@placeholder` block
+ *   should be rendered immediately, even if they have `after` or `minimum` config
+ *   options setup. This flag to needed for testing APIs to transition defer block
+ *   between states via `DeferFixture.render` method.
  */
-function renderDeferBlockState(newState, tNode, lContainer) {
+function renderDeferBlockState(newState, tNode, lContainer, skipTimerScheduling = false) {
     const hostLView = lContainer[PARENT];
     const hostTView = hostLView[TVIEW];
     // Check if this view is not destroyed. Since the loading process was async,
@@ -20109,14 +20499,20 @@ function renderDeferBlockState(newState, tNode, lContainer) {
     if (isValidStateChange(currentState, newState) &&
         isValidStateChange(lDetails[NEXT_DEFER_BLOCK_STATE] ?? -1, newState)) {
         const tDetails = getTDeferBlockDetails(hostTView, tNode);
-        const needsScheduling = getLoadingBlockAfter(tDetails) !== null ||
-            getMinimumDurationForState(tDetails, DeferBlockState.Loading) !== null ||
-            getMinimumDurationForState(tDetails, DeferBlockState.Placeholder);
+        const needsScheduling = !skipTimerScheduling &&
+            (getLoadingBlockAfter(tDetails) !== null ||
+                getMinimumDurationForState(tDetails, DeferBlockState.Loading) !== null ||
+                getMinimumDurationForState(tDetails, DeferBlockState.Placeholder));
         if (ngDevMode && needsScheduling) {
             assertDefined(applyDeferBlockStateWithSchedulingImpl, 'Expected scheduling function to be defined');
         }
         const applyStateFn = needsScheduling ? applyDeferBlockStateWithSchedulingImpl : applyDeferBlockState;
-        applyStateFn(newState, lDetails, lContainer, tNode, hostLView);
+        try {
+            applyStateFn(newState, lDetails, lContainer, tNode, hostLView);
+        }
+        catch (error) {
+            handleError(hostLView, error);
+        }
     }
 }
 /**
@@ -20196,7 +20592,7 @@ function scheduleDeferBlockUpdate(timeout, lDetails, tNode, lContainer, hostLVie
             renderDeferBlockState(nextState, tNode, lContainer);
         }
     };
-    return scheduleTimerTrigger(timeout, callback, hostLView, true);
+    return scheduleTimerTrigger(timeout, callback, hostLView);
 }
 /**
  * Checks whether we can transition to the next state.
@@ -20216,9 +20612,9 @@ function isValidStateChange(currentState, newState) {
  * @param tDetails Static information about this defer block.
  * @param lView LView of a host view.
  */
-function triggerPrefetching(tDetails, lView) {
+function triggerPrefetching(tDetails, lView, tNode) {
     if (lView[INJECTOR$1] && shouldTriggerDeferBlock(lView[INJECTOR$1])) {
-        triggerResourceLoading(tDetails, lView);
+        triggerResourceLoading(tDetails, lView, tNode);
     }
 }
 /**
@@ -20227,7 +20623,7 @@ function triggerPrefetching(tDetails, lView) {
  * @param tDetails Static information about this defer block.
  * @param lView LView of a host view.
  */
-function triggerResourceLoading(tDetails, lView) {
+function triggerResourceLoading(tDetails, lView, tNode) {
     const injector = lView[INJECTOR$1];
     const tView = lView[TVIEW];
     if (tDetails.loadingState !== DeferDependenciesLoadingState.NOT_STARTED) {
@@ -20236,14 +20632,20 @@ function triggerResourceLoading(tDetails, lView) {
         // in this function. All details can be obtained from the `tDetails` object.
         return;
     }
+    const lDetails = getLDeferBlockDetails(lView, tNode);
     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;
+    // Prefetching is triggered, cleanup all registered prefetch triggers.
+    invokeTriggerCleanupFns(1 /* TriggerType.Prefetch */, lDetails);
+    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.
@@ -20253,9 +20655,6 @@ function triggerResourceLoading(tDetails, lView) {
         });
         return;
     }
-    // Defer block may have multiple prefetch triggers. Once the loading
-    // starts, invoke all clean functions, since they are no longer needed.
-    invokeTDetailsCleanup(injector, tDetails);
     // Start downloading of defer block dependencies.
     tDetails.loadingPromise = Promise.allSettled(dependenciesFn()).then(results => {
         let failed = false;
@@ -20284,6 +20683,14 @@ function triggerResourceLoading(tDetails, lView) {
         tDetails.loadingPromise = null;
         if (failed) {
             tDetails.loadingState = DeferDependenciesLoadingState.FAILED;
+            if (tDetails.errorTmplIndex === null) {
+                const templateLocation = getTemplateLocationDetails(lView);
+                const error = new RuntimeError(750 /* RuntimeErrorCode.DEFER_LOADING_FAILED */, ngDevMode &&
+                    'Loading dependencies for `@defer` block failed, ' +
+                        `but no \`@error\` block was configured${templateLocation}. ` +
+                        'Consider using the `@error` block to render an error state.');
+                handleError(lView, error);
+            }
         }
         else {
             tDetails.loadingState = DeferDependenciesLoadingState.COMPLETE;
@@ -20300,22 +20707,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 +20734,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 -
@@ -20360,11 +20746,14 @@ function triggerDeferBlock(lView, tNode) {
     ngDevMode && assertLContainer(lContainer);
     if (!shouldTriggerDeferBlock(injector))
         return;
+    const lDetails = getLDeferBlockDetails(lView, tNode);
     const tDetails = getTDeferBlockDetails(tView, tNode);
+    // Defer block is triggered, cleanup all registered trigger functions.
+    invokeAllTriggerCleanupFns(lDetails);
     switch (tDetails.loadingState) {
         case DeferDependenciesLoadingState.NOT_STARTED:
             renderDeferBlockState(DeferBlockState.Loading, tNode, lContainer);
-            triggerResourceLoading(tDetails, lView);
+            triggerResourceLoading(tDetails, lView, tNode);
             // The `loadingState` might have changed to "loading".
             if (tDetails.loadingState ===
                 DeferDependenciesLoadingState.IN_PROGRESS) {
@@ -20388,366 +20777,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 +21375,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).
@@ -28775,7 +28801,7 @@ const ITS_JUST_ANGULAR = true;
  * ```
  *
  * ### Example with standalone application
- *
+ * ```
  *  function initializeAppFactory(httpClient: HttpClient): () => Observable<any> {
  *   return () => httpClient.get("https://someUrl.com/api/user")
  *     .pipe(
@@ -28794,6 +28820,7 @@ const ITS_JUST_ANGULAR = true;
  *     },
  *   ],
  * });
+ * ```
  *
  * @publicApi
  */
@@ -29708,6 +29735,11 @@ function getProviderImportsContainer(injector) {
     if (defTypeRef === null) {
         return null;
     }
+    // In standalone applications, the root environment injector created by bootstrapApplication
+    // may have no associated "instance".
+    if (defTypeRef.instance === null) {
+        return null;
+    }
     return defTypeRef.instance.constructor;
 }
 /**
@@ -29889,12 +29921,25 @@ function walkProviderTreeToDiscoverImportPaths(providerToPath, visitedContainers
  * @returns an array of objects representing the providers of the given injector
  */
 function getEnvironmentInjectorProviders(injector) {
+    const providerRecords = getFrameworkDIDebugData().resolverToProviders.get(injector) ?? [];
+    // platform injector has no provider imports container so can we skip trying to
+    // find import paths
+    if (isPlatformInjector(injector)) {
+        return providerRecords;
+    }
     const providerImportsContainer = getProviderImportsContainer(injector);
     if (providerImportsContainer === null) {
+        // There is a special case where the bootstrapped component does not
+        // import any NgModules. In this case the environment injector connected to
+        // that component is the root injector, which does not have a provider imports
+        // container (and thus no concept of module import paths). Therefore we simply
+        // return the provider records as is.
+        if (isRootInjector(injector)) {
+            return providerRecords;
+        }
         throwError('Could not determine where injector providers were configured.');
     }
     const providerToPath = getProviderImportPaths(providerImportsContainer);
-    const providerRecords = getFrameworkDIDebugData().resolverToProviders.get(injector) ?? [];
     return providerRecords.map(providerRecord => {
         let importPath = providerToPath.get(providerRecord.provider) ?? [providerImportsContainer];
         const def = getComponentDef(providerImportsContainer);
@@ -29907,6 +29952,12 @@ function getEnvironmentInjectorProviders(injector) {
         return { ...providerRecord, importPath };
     });
 }
+function isPlatformInjector(injector) {
+    return injector instanceof R3Injector && injector.scopes.has('platform');
+}
+function isRootInjector(injector) {
+    return injector instanceof R3Injector && injector.scopes.has('root');
+}
 /**
  * Gets the providers configured on an injector.
  *
@@ -30528,6 +30579,7 @@ function isBoundToModule(cf) {
 /**
  * A token for third-party components that can register themselves with NgProbe.
  *
+ * @deprecated
  * @publicApi
  */
 class NgProbeToken {
@@ -30564,10 +30616,10 @@ function createOrReusePlatformInjector(providers = []) {
     // is already bootstrapped and no additional actions are required.
     if (_platformInjector)
         return _platformInjector;
+    publishDefaultGlobalUtils();
     // Otherwise, setup a new platform injector and run platform initializers.
     const injector = createPlatformInjector(providers);
     _platformInjector = injector;
-    publishDefaultGlobalUtils();
     publishSignalConfiguration();
     runPlatformInitializers(injector);
     return injector;
@@ -31362,7 +31414,7 @@ function internalProvideZoneChangeDetection(ngZoneFactory) {
  * `BootstrapOptions` instead.
  *
  * @usageNotes
- * ```typescript=
+ * ```typescript
  * bootstrapApplication(MyApp, {providers: [
  *   provideZoneChangeDetection({eventCoalescing: true}),
  * ]});
@@ -31753,6 +31805,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 +31851,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 +33831,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 +34403,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);
@@ -34376,7 +34459,7 @@ function withDomHydration() {
                     }
                 }
                 if (isEnabled) {
-                    inject(ENABLED_SSR_FEATURES).add('hydration');
+                    performance.mark('mark_use_counter', { detail: { feature: 'NgHydration' } });
                 }
                 return isEnabled;
             },
@@ -34764,7 +34847,7 @@ if (typeof ngDevMode !== 'undefined' && ngDevMode) {
     // This helper is to give a reasonable error message to people upgrading to v9 that have not yet
     // installed `@angular/localize` in their app.
     // tslint:disable-next-line: no-toplevel-property-access
-    _global.$localize = _global.$localize || function () {
+    _global.$localize ??= function () {
         throw new Error('It looks like your application or one of its dependencies is using i18n.\n' +
             'Angular 9 introduced a global `$localize()` function that needs to be loaded.\n' +
             'Please run `ng add @angular/localize` from the Angular CLI.\n' +
@@ -34790,5 +34873,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, 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