@angular/core 18.0.0-next.5 → 18.0.0-next.6

package/fesm2022/core.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v18.0.0-next.5
+ * @license Angular v18.0.0-next.6
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -7,6 +7,7 @@
 import { SIGNAL_NODE as SIGNAL_NODE$1, signalSetFn as signalSetFn$1, producerAccessed as producerAccessed$1, SIGNAL as SIGNAL$1, getActiveConsumer as getActiveConsumer$1, setActiveConsumer as setActiveConsumer$1, consumerDestroy as consumerDestroy$1, REACTIVE_NODE as REACTIVE_NODE$1, consumerBeforeComputation as consumerBeforeComputation$1, consumerAfterComputation as consumerAfterComputation$1, consumerPollProducersForChange as consumerPollProducersForChange$1, createSignal as createSignal$1, signalUpdateFn as signalUpdateFn$1, createComputed as createComputed$1, setThrowInvalidWriteToSignalError as setThrowInvalidWriteToSignalError$1, createWatch as createWatch$1 } from '@angular/core/primitives/signals';
 import { Subject, Subscription, BehaviorSubject } from 'rxjs';
 import { map, first } from 'rxjs/operators';
+import { Dispatcher, registerDispatcher } from '@angular/core/primitives/event-dispatch';
 
 /**
  * Base URL for the error details page.
@@ -6454,6 +6455,60 @@ class HostAttributeToken {
     }
 }
 
+/**
+ * A token that can be used to inject the tag name of the host node.
+ *
+ * @usageNotes
+ * ### Injecting a tag name that is known to exist
+ * ```typescript
+ * @Directive()
+ * class MyDir {
+ *   tagName: string = inject(HOST_TAG_NAME);
+ * }
+ * ```
+ *
+ * ### Optionally injecting a tag name
+ * ```typescript
+ * @Directive()
+ * class MyDir {
+ *   tagName: string | null = inject(HOST_TAG_NAME, {optional: true});
+ * }
+ * ```
+ * @publicApi
+ */
+const HOST_TAG_NAME = new InjectionToken(ngDevMode ? 'HOST_TAG_NAME' : '');
+// HOST_TAG_NAME should be resolved at the current node, similar to e.g. ElementRef,
+// so we manually specify __NG_ELEMENT_ID__ here, instead of using a factory.
+// tslint:disable-next-line:no-toplevel-property-access
+HOST_TAG_NAME.__NG_ELEMENT_ID__ = (flags) => {
+    const tNode = getCurrentTNode();
+    if (tNode === null) {
+        throw new RuntimeError(204 /* RuntimeErrorCode.INVALID_INJECTION_TOKEN */, ngDevMode &&
+            'HOST_TAG_NAME can only be injected in directives and components ' +
+                'during construction time (in a class constructor or as a class field initializer)');
+    }
+    if (tNode.type & 2 /* TNodeType.Element */) {
+        return tNode.value;
+    }
+    if (flags & InjectFlags.Optional) {
+        return null;
+    }
+    throw new RuntimeError(204 /* RuntimeErrorCode.INVALID_INJECTION_TOKEN */, ngDevMode &&
+        `HOST_TAG_NAME was used on ${getDevModeNodeName(tNode)} which doesn't have an underlying element in the DOM. ` +
+            `This is invalid, and so the dependency should be marked as optional.`);
+};
+function getDevModeNodeName(tNode) {
+    if (tNode.type & 8 /* TNodeType.ElementContainer */) {
+        return 'an <ng-container>';
+    }
+    else if (tNode.type & 4 /* TNodeType.Container */) {
+        return 'an <ng-template>';
+    }
+    else {
+        return 'a node';
+    }
+}
+
 /**
  * @module
  * @description
@@ -7295,6 +7350,20 @@ function getComponentViewByInstance(componentInstance) {
  * This property will be monkey-patched on elements, components and directives.
  */
 const MONKEY_PATCH_KEY_NAME = '__ngContext__';
+function attachLViewId(target, data) {
+    target[MONKEY_PATCH_KEY_NAME] = data[ID];
+}
+/**
+ * Returns the monkey-patch value data present on the target (which could be
+ * a component, directive or a DOM node).
+ */
+function readLView(target) {
+    const data = readPatchedData(target);
+    if (isLView(data)) {
+        return data;
+    }
+    return data ? data.lView : null;
+}
 /**
  * Assigns the given data to the given target (which could be a component,
  * directive or DOM node instance) using monkey-patching.
@@ -8605,6 +8674,11 @@ const PRESERVE_HOST_CONTENT = new InjectionToken((typeof ngDevMode === 'undefine
  * is enabled.
  */
 const IS_I18N_HYDRATION_ENABLED = new InjectionToken((typeof ngDevMode === 'undefined' || !!ngDevMode ? 'IS_I18N_HYDRATION_ENABLED' : ''));
+/**
+ * Internal token that indicates whether event replay support for SSR
+ * is enabled.
+ */
+const IS_EVENT_REPLAY_ENABLED = new InjectionToken((typeof ngDevMode === 'undefined' || !!ngDevMode ? 'IS_EVENT_REPLAY_ENABLED' : ''));
 
 /**
  * @fileoverview
@@ -15215,7 +15289,7 @@ function performanceMarkFeature(feature) {
  *
  * @returns a function to cancel the scheduled callback
  */
-function scheduleCallback(callback, useNativeTimers = true) {
+function scheduleCallbackWithRafRace(callback, useNativeTimers = true) {
     // Note: the `scheduleCallback` is used in the `NgZone` class, but we cannot use the
     // `inject` function. The `NgZone` instance may be created manually, and thus the injection
     // context will be unavailable. This might be enough to check whether `requestAnimationFrame` is
@@ -15249,6 +15323,17 @@ function scheduleCallback(callback, useNativeTimers = true) {
         executeCallback = false;
     };
 }
+function scheduleCallbackWithMicrotask(callback) {
+    let executeCallback = true;
+    queueMicrotask(() => {
+        if (executeCallback) {
+            callback();
+        }
+    });
+    return () => {
+        executeCallback = false;
+    };
+}
 
 function noop(...args) {
     // Do nothing.
@@ -15404,7 +15489,7 @@ class NgZone {
             !shouldCoalesceRunChangeDetection && shouldCoalesceEventChangeDetection;
         self.shouldCoalesceRunChangeDetection = shouldCoalesceRunChangeDetection;
         self.callbackScheduled = false;
-        self.scheduleCallback = scheduleCallback;
+        self.scheduleCallback = scheduleCallbackWithRafRace;
         forkInnerZoneWithAngularBehavior(self);
     }
     /**
@@ -15575,6 +15660,7 @@ function forkInnerZoneWithAngularBehavior(zone) {
         name: 'angular',
         properties: { 'isAngularZone': true },
         onInvokeTask: (delegate, current, target, task, applyThis, applyArgs) => {
+            // Prevent triggering change detection when the flag is detected.
             if (shouldBeIgnoredByZone(applyArgs)) {
                 return delegate.invokeTask(target, task, applyThis, applyArgs);
             }
@@ -15596,7 +15682,17 @@ function forkInnerZoneWithAngularBehavior(zone) {
                 return delegate.invoke(target, callback, applyThis, applyArgs, source);
             }
             finally {
-                if (zone.shouldCoalesceRunChangeDetection) {
+                if (zone.shouldCoalesceRunChangeDetection &&
+                    // Do not delay change detection when the task is the scheduler's tick.
+                    // We need to synchronously trigger the stability logic so that the
+                    // zone-based scheduler can prevent a duplicate ApplicationRef.tick
+                    // by first checking if the scheduler tick is running. This does seem a bit roundabout,
+                    // but we _do_ still want to trigger all the correct events when we exit the zone.run
+                    // (`onMicrotaskEmpty` and `onStable` _should_ emit; developers can have code which
+                    // relies on these events happening after change detection runs).
+                    // Note: `zone.callbackScheduled` is already in delayChangeDetectionForEventsDelegate
+                    // but is added here as well to prevent reads of applyArgs when not necessary
+                    !zone.callbackScheduled && !isSchedulerTick(applyArgs)) {
                     delayChangeDetectionForEventsDelegate();
                 }
                 onLeave(zone);
@@ -15673,6 +15769,12 @@ class NoopNgZone {
     }
 }
 function shouldBeIgnoredByZone(applyArgs) {
+    return hasApplyArgsData(applyArgs, '__ignore_ng_zone__');
+}
+function isSchedulerTick(applyArgs) {
+    return hasApplyArgsData(applyArgs, '__scheduler_tick__');
+}
+function hasApplyArgsData(applyArgs, key) {
     if (!Array.isArray(applyArgs)) {
         return false;
     }
@@ -15681,8 +15783,7 @@ function shouldBeIgnoredByZone(applyArgs) {
     if (applyArgs.length !== 1) {
         return false;
     }
-    // Prevent triggering change detection when the __ignore_ng_zone__ flag is detected.
-    return applyArgs[0].data?.['__ignore_ng_zone__'] === true;
+    return applyArgs[0]?.data?.[key] === true;
 }
 function getNgZone(ngZoneToUse = 'zone.js', options) {
     if (ngZoneToUse === 'noop') {
@@ -16736,7 +16837,7 @@ function createRootComponent(componentView, rootComponentDef, rootDirectives, ho
 function setRootNodeAttributes(hostRenderer, componentDef, hostRNode, rootSelectorOrNode) {
     if (rootSelectorOrNode) {
         // The placeholder will be replaced with the actual version at build time.
-        setUpAttributes(hostRenderer, hostRNode, ['ng-version', '18.0.0-next.5']);
+        setUpAttributes(hostRenderer, hostRNode, ['ng-version', '18.0.0-next.6']);
     }
     else {
         // If host element is created as a part of this function call (i.e. `rootSelectorOrNode`
@@ -18950,14 +19051,7 @@ function setClassMetadata(type, decorators, ctorParameters, propDecorators) {
 const ITS_JUST_ANGULAR = true;
 
 /**
- * *Internal* service that keeps track of pending tasks happening in the system.
- *
- * This information is needed to make sure that the serialization on the server
- * is delayed until all tasks in the queue (such as an initial navigation or a
- * pending HTTP request) are completed.
- *
- * Pending tasks continue to contribute to the stableness of `ApplicationRef`
- * throughout the lifetime of the application.
+ * Internal implementation of the pending tasks service.
  */
 class PendingTasks {
     constructor() {
@@ -18993,7 +19087,56 @@ class PendingTasks {
 }
 (() => { (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(PendingTasks, [{
         type: Injectable,
-        args: [{ providedIn: 'root' }]
+        args: [{
+                providedIn: 'root',
+            }]
+    }], null, null); })();
+/**
+ * Experimental service that keeps track of pending tasks contributing to the stableness of Angular
+ * application. While several existing Angular services (ex.: `HttpClient`) will internally manage
+ * tasks influencing stability, this API gives control over stability to library and application
+ * developers for specific cases not covered by Angular internals.
+ *
+ * The concept of stability comes into play in several important scenarios:
+ * - SSR process needs to wait for the application stability before serializing and sending rendered
+ * HTML;
+ * - tests might want to delay assertions until the application becomes stable;
+ *
+ * @usageNotes
+ * ```typescript
+ * const pendingTasks = inject(ExperimentalPendingTasks);
+ * const taskCleanup = pendingTasks.add();
+ * // do work that should block application's stability and then:
+ * taskCleanup();
+ * ```
+ *
+ * This API is experimental. Neither the shape, nor the underlying behavior is stable and can change
+ * in patch versions. We will iterate on the exact API based on the feedback and our understanding
+ * of the problem and solution space.
+ *
+ * @publicApi
+ * @experimental
+ */
+class ExperimentalPendingTasks {
+    constructor() {
+        this.internalPendingTasks = inject(PendingTasks);
+    }
+    /**
+     * Adds a new task that should block application's stability.
+     * @returns A cleanup function that removes a task when called.
+     */
+    add() {
+        const taskId = this.internalPendingTasks.add();
+        return () => this.internalPendingTasks.remove(taskId);
+    }
+    static { this.ɵfac = function ExperimentalPendingTasks_Factory(t) { return new (t || ExperimentalPendingTasks)(); }; }
+    static { this.ɵprov = /*@__PURE__*/ ɵɵdefineInjectable({ token: ExperimentalPendingTasks, factory: ExperimentalPendingTasks.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(ExperimentalPendingTasks, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root',
+            }]
     }], null, null); })();
 
 function isIterable(obj) {
@@ -20397,8 +20540,10 @@ function renderDeferBlockState(newState, tNode, lContainer, skipTimerScheduling
     const currentState = lDetails[DEFER_BLOCK_STATE];
     if (isValidStateChange(currentState, newState) &&
         isValidStateChange(lDetails[NEXT_DEFER_BLOCK_STATE] ?? -1, newState)) {
+        const injector = hostLView[INJECTOR];
         const tDetails = getTDeferBlockDetails(hostTView, tNode);
-        const needsScheduling = !skipTimerScheduling &&
+        // Skips scheduling on the server since it can delay the server response.
+        const needsScheduling = !skipTimerScheduling && isPlatformBrowser(injector) &&
             (getLoadingBlockAfter(tDetails) !== null ||
                 getMinimumDurationForState(tDetails, DeferBlockState.Loading) !== null ||
                 getMinimumDurationForState(tDetails, DeferBlockState.Placeholder));
@@ -20420,7 +20565,20 @@ function renderDeferBlockState(newState, tNode, lContainer, skipTimerScheduling
  */
 function isRouterOutletInjector(currentInjector) {
     return (currentInjector instanceof ChainedInjector) &&
-        (currentInjector.injector.__ngOutletInjector);
+        (typeof currentInjector.injector.__ngOutletInjector === 'function');
+}
+/**
+ * Creates an instance of the `OutletInjector` using a private factory
+ * function available on the `OutletInjector` class.
+ *
+ * @param parentOutletInjector Parent OutletInjector, which should be used
+ *                             to produce a new instance.
+ * @param parentInjector An Injector, which should be used as a parent one
+ *                       for a newly created `OutletInjector` instance.
+ */
+function createRouterOutletInjector(parentOutletInjector, parentInjector) {
+    const outletInjector = parentOutletInjector.injector;
+    return outletInjector.__ngOutletInjector(parentInjector);
 }
 /**
  * Applies changes to the DOM to reflect a given state.
@@ -20453,11 +20611,18 @@ function applyDeferBlockState(newState, lDetails, lContainer, tNode, hostLView)
                 // we can't inject it. Once the `OutletInjector` is replaced
                 // with the `EnvironmentInjector` in Router's code, this special
                 // handling can be removed.
-                const parentEnvInjector = isRouterOutletInjector(parentInjector) ?
-                    parentInjector :
-                    parentInjector.get(EnvironmentInjector);
+                const isParentOutletInjector = isRouterOutletInjector(parentInjector);
+                const parentEnvInjector = isParentOutletInjector ? parentInjector : parentInjector.get(EnvironmentInjector);
                 injector = parentEnvInjector.get(CachedInjectorService)
                     .getOrCreateInjector(tDetails, parentEnvInjector, providers, ngDevMode ? 'DeferBlock Injector' : '');
+                // Note: this is a continuation of the special case for Router's `OutletInjector`.
+                // Since the `OutletInjector` handles `ActivatedRoute` and `ChildrenOutletContexts`
+                // dynamically (i.e. their values are not really stored statically in an injector),
+                // we need to "wrap" a defer injector into another `OutletInjector`, so we retain
+                // the dynamic resolution of the mentioned tokens.
+                if (isParentOutletInjector) {
+                    injector = createRouterOutletInjector(parentInjector, injector);
+                }
             }
         }
         const dehydratedView = findMatchingDehydratedView(lContainer, activeBlockTNode.tView.ssrId);
@@ -20561,7 +20726,7 @@ function triggerResourceLoading(tDetails, lView, tNode) {
         // If the loading status is different from initial one, it means that
         // the loading of dependencies is in progress and there is nothing to do
         // in this function. All details can be obtained from the `tDetails` object.
-        return;
+        return tDetails.loadingPromise ?? Promise.resolve();
     }
     const lDetails = getLDeferBlockDetails(lView, tNode);
     const primaryBlockTNode = getPrimaryBlockTNode(tView, tDetails);
@@ -20589,7 +20754,7 @@ function triggerResourceLoading(tDetails, lView, tNode) {
             tDetails.loadingState = DeferDependenciesLoadingState.COMPLETE;
             pendingTasks.remove(taskId);
         });
-        return;
+        return tDetails.loadingPromise;
     }
     // Start downloading of defer block dependencies.
     tDetails.loadingPromise = Promise.allSettled(dependenciesFn()).then(results => {
@@ -20649,6 +20814,7 @@ function triggerResourceLoading(tDetails, lView, tNode) {
             }
         }
     });
+    return tDetails.loadingPromise;
 }
 /** Utility function to render placeholder content (if present) */
 function renderPlaceholder(lView, tNode) {
@@ -23155,6 +23321,15 @@ function valuesMatching(liveIdx, liveValue, newIdx, newValue, trackBy) {
     }
     return 0;
 }
+function recordDuplicateKeys(keyToIdx, key, idx) {
+    const idxSoFar = keyToIdx.get(key);
+    if (idxSoFar !== undefined) {
+        idxSoFar.add(idx);
+    }
+    else {
+        keyToIdx.set(key, new Set([idx]));
+    }
+}
 /**
  * The live collection reconciliation algorithm that perform various in-place operations, so it
  * reflects the content of the new (incoming) collection.
@@ -23183,12 +23358,16 @@ function reconcile(liveCollection, newCollection, trackByFn) {
     let liveKeysInTheFuture = undefined;
     let liveStartIdx = 0;
     let liveEndIdx = liveCollection.length - 1;
+    const duplicateKeys = ngDevMode ? new Map() : undefined;
     if (Array.isArray(newCollection)) {
         let newEndIdx = newCollection.length - 1;
         while (liveStartIdx <= liveEndIdx && liveStartIdx <= newEndIdx) {
             // compare from the beginning
             const liveStartValue = liveCollection.at(liveStartIdx);
             const newStartValue = newCollection[liveStartIdx];
+            if (ngDevMode) {
+                recordDuplicateKeys(duplicateKeys, trackByFn(liveStartIdx, newStartValue), liveStartIdx);
+            }
             const isStartMatching = valuesMatching(liveStartIdx, liveStartValue, liveStartIdx, newStartValue, trackByFn);
             if (isStartMatching !== 0) {
                 if (isStartMatching < 0) {
@@ -23201,6 +23380,9 @@ function reconcile(liveCollection, newCollection, trackByFn) {
             // TODO(perf): do _all_ the matching from the end
             const liveEndValue = liveCollection.at(liveEndIdx);
             const newEndValue = newCollection[newEndIdx];
+            if (ngDevMode) {
+                recordDuplicateKeys(duplicateKeys, trackByFn(newEndIdx, newEndValue), newEndIdx);
+            }
             const isEndMatching = valuesMatching(liveEndIdx, liveEndValue, newEndIdx, newEndValue, trackByFn);
             if (isEndMatching !== 0) {
                 if (isEndMatching < 0) {
@@ -23272,6 +23454,9 @@ function reconcile(liveCollection, newCollection, trackByFn) {
         while (!newIterationResult.done && liveStartIdx <= liveEndIdx) {
             const liveValue = liveCollection.at(liveStartIdx);
             const newValue = newIterationResult.value;
+            if (ngDevMode) {
+                recordDuplicateKeys(duplicateKeys, trackByFn(liveStartIdx, newValue), liveStartIdx);
+            }
             const isStartMatching = valuesMatching(liveStartIdx, liveValue, liveStartIdx, newValue, trackByFn);
             if (isStartMatching !== 0) {
                 // found a match - move on, but update value
@@ -23323,6 +23508,25 @@ function reconcile(liveCollection, newCollection, trackByFn) {
     detachedItems?.forEach(item => {
         liveCollection.destroy(item);
     });
+    // report duplicate keys (dev mode only)
+    if (ngDevMode) {
+        let duplicatedKeysMsg = [];
+        for (const [key, idxSet] of duplicateKeys) {
+            if (idxSet.size > 1) {
+                const idx = [...idxSet].sort((a, b) => a - b);
+                for (let i = 1; i < idx.length; i++) {
+                    duplicatedKeysMsg.push(`key "${stringifyForError(key)}" at index "${idx[i - 1]}" and "${idx[i]}"`);
+                }
+            }
+        }
+        if (duplicatedKeysMsg.length > 0) {
+            const message = formatRuntimeError(955 /* RuntimeErrorCode.LOOP_TRACK_DUPLICATE_KEYS */, 'The provided track expression resulted in duplicated keys for a given collection. ' +
+                'Adjust the tracking expression such that it uniquely identifies all the items in the collection. ' +
+                'Duplicated keys were: \n' + duplicatedKeysMsg.join(', \n') + '.');
+            // tslint:disable-next-line:no-console
+            console.warn(message);
+        }
+    }
 }
 function attachPreviouslyDetached(prevCollection, detachedItems, index, key) {
     if (detachedItems !== undefined && detachedItems.has(key)) {
@@ -23559,12 +23763,43 @@ function ɵɵrepeaterCreate(index, templateFn, decls, vars, tagName, attrsIndex,
         declareTemplate(lView, tView, index + 2, emptyTemplateFn, emptyDecls, emptyVars, emptyTagName, getConstant(tView.consts, emptyAttrsIndex));
     }
 }
+function isViewExpensiveToRecreate(lView) {
+    // assumption: anything more than a text node with a binding is considered "expensive"
+    return lView.length - HEADER_OFFSET > 2;
+}
+class OperationsCounter {
+    constructor() {
+        this.created = 0;
+        this.destroyed = 0;
+    }
+    reset() {
+        this.created = 0;
+        this.destroyed = 0;
+    }
+    recordCreate() {
+        this.created++;
+    }
+    recordDestroy() {
+        this.destroyed++;
+    }
+    /**
+     * A method indicating if the entire collection was re-created as part of the reconciliation pass.
+     * Used to warn developers about the usage of a tracking function that might result in excessive
+     * amount of view creation / destroy operations.
+     *
+     * @returns boolean value indicating if a live collection was re-created
+     */
+    wasReCreated(collectionLen) {
+        return collectionLen > 0 && this.created === this.destroyed && this.created === collectionLen;
+    }
+}
 class LiveCollectionLContainerImpl extends LiveCollection {
     constructor(lContainer, hostLView, templateTNode) {
         super();
         this.lContainer = lContainer;
         this.hostLView = hostLView;
         this.templateTNode = templateTNode;
+        this.operationsCounter = ngDevMode ? new OperationsCounter() : undefined;
         /**
          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
@@ -23590,16 +23825,19 @@ class LiveCollectionLContainerImpl extends LiveCollection {
     create(index, value) {
         const dehydratedView = findMatchingDehydratedView(this.lContainer, this.templateTNode.tView.ssrId);
         const embeddedLView = createAndRenderEmbeddedLView(this.hostLView, this.templateTNode, new RepeaterContext(this.lContainer, value, index), { dehydratedView });
+        this.operationsCounter?.recordCreate();
         return embeddedLView;
     }
     destroy(lView) {
         destroyLView(lView[TVIEW], lView);
+        this.operationsCounter?.recordDestroy();
     }
     updateValue(index, value) {
         this.getLView(index)[CONTEXT].$implicit = value;
     }
     reset() {
         this.needsIndexUpdate = false;
+        this.operationsCounter?.reset();
     }
     updateIndexes() {
         if (this.needsIndexUpdate) {
@@ -23626,9 +23864,9 @@ function ɵɵrepeater(collection) {
         const hostLView = getLView();
         const hostTView = hostLView[TVIEW];
         const metadata = hostLView[metadataSlotIdx];
+        const containerIndex = metadataSlotIdx + 1;
+        const lContainer = getLContainer(hostLView, containerIndex);
         if (metadata.liveCollection === undefined) {
-            const containerIndex = metadataSlotIdx + 1;
-            const lContainer = getLContainer(hostLView, containerIndex);
             const itemTemplateTNode = getExistingTNode(hostTView, containerIndex);
             metadata.liveCollection =
                 new LiveCollectionLContainerImpl(lContainer, hostLView, itemTemplateTNode);
@@ -23638,6 +23876,18 @@ function ɵɵrepeater(collection) {
         }
         const liveCollection = metadata.liveCollection;
         reconcile(liveCollection, collection, metadata.trackByFn);
+        // Warn developers about situations where the entire collection was re-created as part of the
+        // reconciliation pass. Note that this warning might be "overreacting" and report cases where
+        // the collection re-creation is the intended behavior. Still, the assumption is that most of
+        // the time it is undesired.
+        if (ngDevMode && metadata.trackByFn === ɵɵrepeaterTrackByIdentity &&
+            liveCollection.operationsCounter?.wasReCreated(liveCollection.length) &&
+            isViewExpensiveToRecreate(getExistingLViewFromLContainer(lContainer, 0))) {
+            const message = formatRuntimeError(956 /* RuntimeErrorCode.LOOP_TRACK_RECREATE */, `The configured tracking expression (track by identity) caused re-creation of the entire collection of size ${liveCollection.length}. ` +
+                'This is an expensive operation requiring destruction and subsequent creation of DOM nodes, directives, components etc. ' +
+                'Please review the "track expression" and make sure that it uniquely identifies items in a collection.');
+            console.warn(message);
+        }
         // moves in the container might caused context's index to get out of order, re-adjust if needed
         liveCollection.updateIndexes();
         // handle empty blocks
@@ -30309,7 +30559,7 @@ class Version {
 /**
  * @publicApi
  */
-const VERSION = new Version('18.0.0-next.5');
+const VERSION = new Version('18.0.0-next.6');
 
 class Console {
     log(message) {
@@ -32283,6 +32533,23 @@ function _lastDefined(args) {
 /** Flag to enable/disable the zoneless scheduler as default provider with zone scheduling. */
 const alwaysProvideZonelessScheduler = true;
 
+const CONSECUTIVE_MICROTASK_NOTIFICATION_LIMIT = 100;
+let consecutiveMicrotaskNotifications = 0;
+let stackFromLastFewNotifications = [];
+function trackMicrotaskNotificationForDebugging() {
+    consecutiveMicrotaskNotifications++;
+    if (CONSECUTIVE_MICROTASK_NOTIFICATION_LIMIT - consecutiveMicrotaskNotifications < 5) {
+        const stack = new Error().stack;
+        if (stack) {
+            stackFromLastFewNotifications.push(stack);
+        }
+    }
+    if (consecutiveMicrotaskNotifications === CONSECUTIVE_MICROTASK_NOTIFICATION_LIMIT) {
+        throw new RuntimeError(103 /* RuntimeErrorCode.INFINITE_CHANGE_DETECTION */, 'Angular could not stabilize because there were endless change notifications within the browser event loop. ' +
+            'The stack from the last several notifications: \n' +
+            stackFromLastFewNotifications.join('\n'));
+    }
+}
 class ChangeDetectionSchedulerImpl {
     constructor() {
         this.appRef = inject(ApplicationRef);
@@ -32295,6 +32562,7 @@ class ChangeDetectionSchedulerImpl {
         this.zonelessEnabled = inject(ZONELESS_ENABLED);
         this.disableScheduling = inject(ZONELESS_SCHEDULER_DISABLED, { optional: true }) ?? false;
         this.zoneIsDefined = typeof Zone !== 'undefined' && !!Zone.root.run;
+        this.schedulerTickApplyArgs = [{ data: { '__scheduler_tick__': true } }];
         this.afterTickSubscription = this.appRef.afterTick.subscribe(() => {
             // If the scheduler isn't running a tick but the application ticked, that means
             // someone called ApplicationRef.tick manually. In this case, we should cancel
@@ -32303,6 +32571,7 @@ class ChangeDetectionSchedulerImpl {
                 this.cleanup();
             }
         });
+        this.useMicrotaskScheduler = false;
         // TODO(atscott): These conditions will need to change when zoneless is the default
         // Instead, they should flip to checking if ZoneJS scheduling is provided
         this.disableScheduling ||= !this.zonelessEnabled &&
@@ -32318,6 +32587,16 @@ class ChangeDetectionSchedulerImpl {
         if (!this.shouldScheduleTick()) {
             return;
         }
+        if ((typeof ngDevMode === 'undefined' || ngDevMode)) {
+            if (this.useMicrotaskScheduler) {
+                trackMicrotaskNotificationForDebugging();
+            }
+            else {
+                consecutiveMicrotaskNotifications = 0;
+                stackFromLastFewNotifications.length = 0;
+            }
+        }
+        const scheduleCallback = this.useMicrotaskScheduler ? scheduleCallbackWithMicrotask : scheduleCallbackWithRafRace;
         this.pendingRenderTaskId = this.taskService.add();
         if (this.zoneIsDefined) {
             Zone.root.run(() => {
@@ -32363,15 +32642,30 @@ class ChangeDetectionSchedulerImpl {
         if (this.runningTick || this.appRef.destroyed) {
             return;
         }
+        const task = this.taskService.add();
         try {
             this.ngZone.run(() => {
                 this.runningTick = true;
                 this.appRef._tick(shouldRefreshViews);
-            });
+            }, undefined, this.schedulerTickApplyArgs);
+        }
+        catch (e) {
+            this.taskService.remove(task);
+            throw e;
         }
         finally {
             this.cleanup();
         }
+        // If we're notified of a change within 1 microtask of running change
+        // detection, run another round in the same event loop. This allows code
+        // which uses Promise.resolve (see NgModel) to avoid
+        // ExpressionChanged...Error to still be reflected in a single browser
+        // paint, even if that spans multiple rounds of change detection.
+        this.useMicrotaskScheduler = true;
+        scheduleCallbackWithMicrotask(() => {
+            this.useMicrotaskScheduler = false;
+            this.taskService.remove(task);
+        });
     }
     ngOnDestroy() {
         this.afterTickSubscription.unsubscribe();
@@ -32434,8 +32728,8 @@ class ChangeDetectionSchedulerImpl {
  * ```
  *
  * This API is experimental. Neither the shape, nor the underlying behavior is stable and can change
- * in patch versions. There are known feature gaps, including the lack of a public zoneless API
- * which prevents the application from serializing too early with SSR.
+ * in patch versions. There are known feature gaps and API ergonomic considerations. We will iterate
+ * on the exact API based on the feedback and our understanding of the problem and solution space.
  *
  * @publicApi
  * @experimental
@@ -34987,9 +35281,9 @@ const REACTIVE_NODE = {
  */
 function producerAccessed(node) {
     if (inNotificationPhase) {
-        throw new Error(typeof ngDevMode !== 'undefined' && ngDevMode ?
-            `Assertion error: signal read during notification phase` :
-            '');
+        throw new Error(typeof ngDevMode !== 'undefined' && ngDevMode
+            ? `Assertion error: signal read during notification phase`
+            : '');
     }
     if (activeConsumer === null) {
         // Accessed outside of a reactive context, so nothing to record.
@@ -35019,8 +35313,9 @@ function producerAccessed(node) {
         activeConsumer.producerNode[idx] = node;
         // If the active consumer is live, then add it as a live consumer. If not, then use 0 as a
         // placeholder value.
-        activeConsumer.producerIndexOfThis[idx] =
-            consumerIsLive(activeConsumer) ? producerAddLiveConsumer(node, activeConsumer, idx) : 0;
+        activeConsumer.producerIndexOfThis[idx] = consumerIsLive(activeConsumer)
+            ? producerAddLiveConsumer(node, activeConsumer, idx)
+            : 0;
     }
     activeConsumer.producerLastReadVersion[idx] = node.version;
 }
@@ -35110,7 +35405,9 @@ function consumerBeforeComputation(node) {
  */
 function consumerAfterComputation(node, prevConsumer) {
     setActiveConsumer(prevConsumer);
-    if (!node || node.producerNode === undefined || node.producerIndexOfThis === undefined ||
+    if (!node ||
+        node.producerNode === undefined ||
+        node.producerIndexOfThis === undefined ||
         node.producerLastReadVersion === undefined) {
         return;
     }
@@ -35168,8 +35465,10 @@ function consumerDestroy(node) {
         }
     }
     // Truncate all the arrays to drop all connection from this node to the graph.
-    node.producerNode.length = node.producerLastReadVersion.length = node.producerIndexOfThis.length =
-        0;
+    node.producerNode.length =
+        node.producerLastReadVersion.length =
+            node.producerIndexOfThis.length =
+                0;
     if (node.liveConsumerNode) {
         node.liveConsumerNode.length = node.liveConsumerIndexOfThis.length = 0;
     }
@@ -35309,7 +35608,9 @@ const COMPUTED_NODE = /* @__PURE__ */ (() => {
             finally {
                 consumerAfterComputation(node, prevConsumer);
             }
-            if (oldValue !== UNSET && oldValue !== ERRORED && newValue !== ERRORED &&
+            if (oldValue !== UNSET &&
+                oldValue !== ERRORED &&
+                newValue !== ERRORED &&
                 node.equal(oldValue, newValue)) {
                 // No change to `valueVersion` - old and new values are
                 // semantically equivalent.
@@ -35746,6 +36047,170 @@ function getDeferBlocks(lView, deferBlocks) {
     }
 }
 
+const EVENT_REPLAY_ENABLED_DEFAULT = false;
+const CONTRACT_PROPERTY = 'ngContracts';
+/**
+ * Returns a set of providers required to setup support for event replay.
+ * Requires hydration to be enabled separately.
+ */
+function withEventReplay() {
+    return [
+        {
+            provide: IS_EVENT_REPLAY_ENABLED,
+            useValue: true,
+        },
+        {
+            provide: APP_BOOTSTRAP_LISTENER,
+            useFactory: () => {
+                if (isPlatformBrowser()) {
+                    const injector = inject(Injector);
+                    const appRef = inject(ApplicationRef);
+                    return () => {
+                        // Kick off event replay logic once hydration for the initial part
+                        // of the application is completed. This timing is similar to the unclaimed
+                        // dehydrated views cleanup timing.
+                        whenStable(appRef).then(() => {
+                            const appId = injector.get(APP_ID);
+                            // This is set in packages/platform-server/src/utils.ts
+                            // Note: globalThis[CONTRACT_PROPERTY] may be undefined in case Event Replay feature
+                            // is enabled, but there are no events configured in an application.
+                            const eventContract = globalThis[CONTRACT_PROPERTY]?.[appId];
+                            if (eventContract) {
+                                const dispatcher = new Dispatcher();
+                                setEventReplayer(dispatcher);
+                                // Event replay is kicked off as a side-effect of executing this function.
+                                registerDispatcher(eventContract, dispatcher);
+                            }
+                        });
+                    };
+                }
+                return () => { }; // noop for the server code
+            },
+            multi: true,
+        }
+    ];
+}
+/**
+ * Extracts information about all DOM events (added in a template) registered on elements in a give
+ * LView. Maps collected events to a corresponding DOM element (an element is used as a key).
+ */
+function collectDomEventsInfo(tView, lView, eventTypesToReplay) {
+    const events = new Map();
+    const lCleanup = lView[CLEANUP];
+    const tCleanup = tView.cleanup;
+    if (!tCleanup || !lCleanup) {
+        return events;
+    }
+    for (let i = 0; i < tCleanup.length;) {
+        const firstParam = tCleanup[i++];
+        const secondParam = tCleanup[i++];
+        if (typeof firstParam !== 'string') {
+            continue;
+        }
+        const name = firstParam;
+        eventTypesToReplay.add(name);
+        const listenerElement = unwrapRNode(lView[secondParam]);
+        i++; // move the cursor to the next position (location of the listener idx)
+        const useCaptureOrIndx = tCleanup[i++];
+        // if useCaptureOrIndx is boolean then report it as is.
+        // if useCaptureOrIndx is positive number then it in unsubscribe method
+        // if useCaptureOrIndx is negative number then it is a Subscription
+        const isDomEvent = typeof useCaptureOrIndx === 'boolean' || useCaptureOrIndx >= 0;
+        if (!isDomEvent) {
+            continue;
+        }
+        if (!events.has(listenerElement)) {
+            events.set(listenerElement, [name]);
+        }
+        else {
+            events.get(listenerElement).push(name);
+        }
+    }
+    return events;
+}
+function setJSActionAttribute(tNode, rNode, nativeElementToEvents) {
+    if (tNode.type & 2 /* TNodeType.Element */) {
+        const nativeElement = unwrapRNode(rNode);
+        const events = nativeElementToEvents.get(nativeElement) ?? [];
+        const parts = events.map(event => `${event}:`);
+        if (parts.length > 0) {
+            nativeElement.setAttribute('jsaction', parts.join(';'));
+        }
+    }
+}
+/**
+ * Registers a function that should be invoked to replay events.
+ */
+function setEventReplayer(dispatcher) {
+    dispatcher.setEventReplayer(queue => {
+        for (const event of queue) {
+            handleEvent(event);
+        }
+    });
+}
+/**
+ * Finds an LView that a given DOM element belongs to.
+ */
+function getLViewByElement(target) {
+    let lView = readLView(target);
+    if (lView) {
+        return lView;
+    }
+    else {
+        // If this node doesn't have LView info attached, then we need to
+        // traverse upwards up the DOM to find the nearest element that
+        // has already been monkey patched with data.
+        let parent = target;
+        while (parent = parent.parentNode) {
+            lView = readLView(parent);
+            if (lView) {
+                // To prevent additional lookups, monkey-patch LView id onto this DOM node.
+                // TODO: consider patching all parent nodes that didn't have LView id, so that
+                // we can avoid lookups for more nodes.
+                attachLViewId(target, lView);
+                return lView;
+            }
+        }
+    }
+    return null;
+}
+function handleEvent(event) {
+    const nativeElement = event.getAction().element;
+    // Dispatch event via Angular's logic
+    if (nativeElement) {
+        const lView = getLViewByElement(nativeElement);
+        if (lView !== null) {
+            const tView = lView[TVIEW];
+            const eventName = event.getEventType();
+            const origEvent = event.getEvent();
+            const listeners = getEventListeners(tView, lView, nativeElement, eventName);
+            for (const listener of listeners) {
+                listener(origEvent);
+            }
+        }
+    }
+}
+function getEventListeners(tView, lView, nativeElement, eventName) {
+    const listeners = [];
+    const lCleanup = lView[CLEANUP];
+    const tCleanup = tView.cleanup;
+    if (tCleanup && lCleanup) {
+        for (let i = 0; i < tCleanup.length;) {
+            const storedEventName = tCleanup[i++];
+            const nativeElementIndex = tCleanup[i++];
+            if (typeof storedEventName === 'string') {
+                const listenerElement = unwrapRNode(lView[nativeElementIndex]);
+                const listener = lCleanup[tCleanup[i++]];
+                i++; // increment to the next position;
+                if (listenerElement === nativeElement && eventName === storedEventName) {
+                    listeners.push(listener);
+                }
+            }
+        }
+    }
+    return listeners;
+}
+
 /**
  * A collection that tracks all serialized views (`ngh` DOM annotations)
  * to avoid duplication. An attempt to add a duplicate view results in the
@@ -35854,6 +36319,7 @@ function annotateLContainerForHydration(lContainer, context) {
  *
  * @param appRef An instance of an ApplicationRef.
  * @param doc A reference to the current Document instance.
+ * @return event types that need to be replayed
  */
 function annotateForHydration(appRef, doc) {
     const injector = appRef.injector;
@@ -35861,6 +36327,8 @@ function annotateForHydration(appRef, doc) {
     const serializedViewCollection = new SerializedViewCollection();
     const corruptedTextNodes = new Map();
     const viewRefs = appRef._views;
+    const shouldReplayEvents = injector.get(IS_EVENT_REPLAY_ENABLED, EVENT_REPLAY_ENABLED_DEFAULT);
+    const eventTypesToReplay = new Set();
     for (const viewRef of viewRefs) {
         const lNode = getLNodeForHydration(viewRef);
         // An `lView` might be `null` if a `ViewRef` represents
@@ -35871,6 +36339,8 @@ function annotateForHydration(appRef, doc) {
                 corruptedTextNodes,
                 isI18nHydrationEnabled: isI18nHydrationEnabledVal,
                 i18nChildren: new Map(),
+                eventTypesToReplay,
+                shouldReplayEvents,
             };
             if (isLContainer(lNode)) {
                 annotateLContainerForHydration(lNode, context);
@@ -35889,6 +36359,7 @@ function annotateForHydration(appRef, doc) {
     const serializedViews = serializedViewCollection.getAll();
     const transferState = injector.get(TransferState);
     transferState.set(NGH_DATA_KEY, serializedViews);
+    return eventTypesToReplay.size > 0 ? eventTypesToReplay : undefined;
 }
 /**
  * Serializes the lContainer data into a list of SerializedView objects,
@@ -35998,10 +36469,16 @@ function serializeLView(lView, context) {
     const ngh = {};
     const tView = lView[TVIEW];
     const i18nChildren = getOrComputeI18nChildren(tView, context);
+    const nativeElementsToEventTypes = context.shouldReplayEvents ?
+        collectDomEventsInfo(tView, lView, context.eventTypesToReplay) :
+        null;
     // Iterate over DOM element references in an LView.
     for (let i = HEADER_OFFSET; i < tView.bindingStartIndex; i++) {
         const tNode = tView.data[i];
         const noOffsetIndex = i - HEADER_OFFSET;
+        if (nativeElementsToEventTypes) {
+            setJSActionAttribute(tNode, lView[i], nativeElementsToEventTypes);
+        }
         // Attempt to serialize any i18n data for the given slot. We do this first, as i18n
         // has its own process for serialization.
         const i18nData = trySerializeI18nBlock(lView, i, context);
@@ -37022,5 +37499,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, HostAttributeToken, HostBinding, HostListener, INJECTOR$1 as 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, OutputEmitterRef, 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, contentChild, contentChildren, createComponent, createEnvironmentInjector, createNgModule, createNgModuleRef, createPlatform, createPlatformFactory, defineInjectable, destroyPlatform, effect, enableProdMode, forwardRef, getDebugNode, getModuleFactory, getNgModuleById, getPlatform, importProvidersFrom, inject, input, isDevMode, isSignal, isStandalone, makeEnvironmentProviders, makeStateKey, mergeApplicationConfig, model, numberAttribute, output, platformCore, provideExperimentalZonelessChangeDetection, provideZoneChangeDetection, reflectComponentType, resolveForwardRef, runInInjectionContext, setTestabilityGetter, signal, untracked, viewChild, viewChildren, ALLOW_MULTIPLE_PLATFORMS as ɵALLOW_MULTIPLE_PLATFORMS, AfterRenderEventManager as ɵAfterRenderEventManager, CONTAINER_HEADER_OFFSET as ɵCONTAINER_HEADER_OFFSET, ChangeDetectionScheduler as ɵChangeDetectionScheduler, 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, ɵINPUT_SIGNAL_BRAND_WRITE_TYPE, IS_HYDRATION_DOM_REUSE_ENABLED as ɵIS_HYDRATION_DOM_REUSE_ENABLED, 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, PendingTasks as ɵPendingTasks, 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, ZONELESS_ENABLED as ɵZONELESS_ENABLED, _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, detectChangesInViewIfRequired as ɵdetectChangesInViewIfRequired, devModeEqual as ɵdevModeEqual, findLocaleData as ɵfindLocaleData, flushModuleScopingQueueAsMuchAsPossible as ɵflushModuleScopingQueueAsMuchAsPossible, formatRuntimeError as ɵformatRuntimeError, generateStandaloneInDeclarationsError as ɵgenerateStandaloneInDeclarationsError, getAsyncClassMetadataFn as ɵgetAsyncClassMetadataFn, getDebugNode as ɵgetDebugNode, getDeferBlocks as ɵgetDeferBlocks, getDirectives as ɵgetDirectives, getHostElement as ɵgetHostElement, getInjectableDef as ɵgetInjectableDef, getLContext as ɵgetLContext, getLocaleCurrencyCode as ɵgetLocaleCurrencyCode, getLocalePluralCase as ɵgetLocalePluralCase, getOutputDestroyRef as ɵgetOutputDestroyRef, 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, performanceMarkFeature as ɵperformanceMarkFeature, queueStateUpdate as ɵqueueStateUpdate, readHydrationInfo as ɵreadHydrationInfo, 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, ɵunwrapWritableSignal, whenStable as ɵwhenStable, withDomHydration as ɵwithDomHydration, withI18nSupport as ɵwithI18nSupport, ɵɵ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, ɵɵcontentQuerySignal, ɵɵ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, ɵɵngDeclareClassMetadataAsync, ɵɵ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, ɵɵqueryAdvance, ɵɵ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, ɵɵtwoWayBindingSet, ɵɵtwoWayListener, ɵɵtwoWayProperty, ɵɵvalidateIframeAttribute, ɵɵviewQuery, ɵɵviewQuerySignal };
+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, ExperimentalPendingTasks, HOST_TAG_NAME, Host, HostAttributeToken, HostBinding, HostListener, INJECTOR$1 as 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, OutputEmitterRef, 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, contentChild, contentChildren, createComponent, createEnvironmentInjector, createNgModule, createNgModuleRef, createPlatform, createPlatformFactory, defineInjectable, destroyPlatform, effect, enableProdMode, forwardRef, getDebugNode, getModuleFactory, getNgModuleById, getPlatform, importProvidersFrom, inject, input, isDevMode, isSignal, isStandalone, makeEnvironmentProviders, makeStateKey, mergeApplicationConfig, model, numberAttribute, output, platformCore, provideExperimentalZonelessChangeDetection, provideZoneChangeDetection, reflectComponentType, resolveForwardRef, runInInjectionContext, setTestabilityGetter, signal, untracked, viewChild, viewChildren, ALLOW_MULTIPLE_PLATFORMS as ɵALLOW_MULTIPLE_PLATFORMS, AfterRenderEventManager as ɵAfterRenderEventManager, CONTAINER_HEADER_OFFSET as ɵCONTAINER_HEADER_OFFSET, ChangeDetectionScheduler as ɵChangeDetectionScheduler, 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, ɵINPUT_SIGNAL_BRAND_WRITE_TYPE, IS_HYDRATION_DOM_REUSE_ENABLED as ɵIS_HYDRATION_DOM_REUSE_ENABLED, 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, PendingTasks as ɵPendingTasks, 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, ZONELESS_ENABLED as ɵZONELESS_ENABLED, _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, detectChangesInViewIfRequired as ɵdetectChangesInViewIfRequired, devModeEqual as ɵdevModeEqual, findLocaleData as ɵfindLocaleData, flushModuleScopingQueueAsMuchAsPossible as ɵflushModuleScopingQueueAsMuchAsPossible, formatRuntimeError as ɵformatRuntimeError, generateStandaloneInDeclarationsError as ɵgenerateStandaloneInDeclarationsError, getAsyncClassMetadataFn as ɵgetAsyncClassMetadataFn, getDebugNode as ɵgetDebugNode, getDeferBlocks as ɵgetDeferBlocks, getDirectives as ɵgetDirectives, getHostElement as ɵgetHostElement, getInjectableDef as ɵgetInjectableDef, getLContext as ɵgetLContext, getLocaleCurrencyCode as ɵgetLocaleCurrencyCode, getLocalePluralCase as ɵgetLocalePluralCase, getOutputDestroyRef as ɵgetOutputDestroyRef, 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, performanceMarkFeature as ɵperformanceMarkFeature, queueStateUpdate as ɵqueueStateUpdate, readHydrationInfo as ɵreadHydrationInfo, 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, ɵunwrapWritableSignal, whenStable as ɵwhenStable, withDomHydration as ɵwithDomHydration, withEventReplay as ɵwithEventReplay, withI18nSupport as ɵwithI18nSupport, ɵɵ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, ɵɵcontentQuerySignal, ɵɵ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, ɵɵngDeclareClassMetadataAsync, ɵɵ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, ɵɵqueryAdvance, ɵɵ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, ɵɵtwoWayBindingSet, ɵɵtwoWayListener, ɵɵtwoWayProperty, ɵɵvalidateIframeAttribute, ɵɵviewQuery, ɵɵviewQuerySignal };
 //# sourceMappingURL=core.mjs.map