@angular/core 21.0.0-next.2 → 21.0.0-next.4

package/fesm2022/debug_node.mjs

@@ -1,10 +1,10 @@
 /**
- * @license Angular v21.0.0-next.2
+ * @license Angular v21.0.0-next.4
  * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */
 
-import { attachInjectFlag, _global, ɵɵdefineInjectable as __defineInjectable, ɵɵdefineInjector as __defineInjector, ɵɵinject as __inject, ɵɵinvalidFactoryDep as __invalidFactoryDep, resolveForwardRef, newArray, EMPTY_OBJ, assertString, assertNotEqual, FLAGS, assertEqual, isInCheckNoChangesMode, PREORDER_HOOK_FLAGS, assertFirstCreatePass, assertDefined, throwError, assertNumber, assertGreaterThan, HEADER_OFFSET, DECLARATION_VIEW, NG_FACTORY_DEF, isForwardRef, getFactoryDef, assertIndexInRange, assertTNodeForLView, enterDI, runInInjectorProfilerContext, getCurrentTNode, getLView, emitInjectorToCreateInstanceEvent, emitInstanceCreatedByInjectorEvent, throwProviderNotFoundError, leaveDI, assertNodeInjector, stringifyForError, cyclicDependencyErrorWithDetails, cyclicDependencyError, setInjectorProfilerContext, setInjectImplementation, assertDirectiveDef, NG_ELEMENT_ID, convertToBitFlags, isRootView, T_HOST, TVIEW, injectRootLimpMode, isComponentDef, EMBEDDED_VIEW_INJECTOR, INJECTOR$1 as INJECTOR, DECLARATION_COMPONENT_VIEW, isComponentHost, RuntimeError, NG_PROV_DEF, getClosureSafeProperty, getNativeByTNode, flatten, arrayEquals, ID, isLView, assertDomNode, unwrapRNode, getComponentLViewByIndex, CONTEXT, EMPTY_ARRAY, assertLView, HOST, CHILD_HEAD, NEXT, isLContainer, getLViewParent, Injector, CLEANUP, getComponentDef, getDirectiveDef, InjectionToken, inject, isInSkipHydrationBlock as isInSkipHydrationBlock$1, HYDRATION, isContentQueryHost, setCurrentQueryIndex, XSS_SECURITY_URL, renderStringify, ENVIRONMENT, makeEnvironmentProviders, isDirectiveHost, formatRuntimeError, resetPreOrderHookFlags, PARENT, RENDERER, CHILD_TAIL, assertSame, assertFirstUpdatePass, getSelectedIndex, getTView, assertIndexInDeclRange, setSelectedIndex, assertLContainer, MOVED_VIEWS, isDestroyed, REACTIVE_TEMPLATE_CONSUMER, DECLARATION_LCONTAINER, QUERIES, assertNotReactive, ON_DESTROY_HOOKS, assertFunction, EFFECTS, assertProjectionSlots, NATIVE, assertParentView, CONTAINER_HEADER_OFFSET, assertNotSame, setCurrentDirectiveIndex, setCurrentTNode, getElementDepthCount, increaseElementDepthCount, wasLastNodeCreated, isCurrentTNodeParent, setCurrentTNodeAsNotParent, assertHasParent, INTERNAL_APPLICATION_ERROR_HANDLER, stringify, getCurrentDirectiveIndex, unwrapLView, isCreationMode, enterView, leaveView, AFTER_RENDER_SEQUENCES_TO_ADD, markAncestorsForTraversal, markViewForRefresh, setIsRefreshingViews, isExhaustiveCheckNoChanges, requiresRefreshOrTraversal, setIsInCheckNoChangesMode, CheckNoChangesMode, setBindingIndex, EFFECTS_TO_SCHEDULE, viewAttachedToChangeDetector, setBindingRootForHostBindings, isRefreshingViews, removeFromArray, addToArray, updateAncestorTraversalFlagsOnAttach, storeLViewOnDestroy, VIEW_REFS, assertGreaterThanOrEqual, isInI18nBlock, assertTNodeForTView, getCurrentParentTNode, getCurrentTNodePlaceholderOk, assertTNode, assertTIcu, assertNumberInRange, DEHYDRATED_VIEWS, getNgModuleDef, getPipeDef as getPipeDef$1, getNgModuleDefOrThrow, isStandalone, concatStringsWithSpace, assertInjectImplementationNotEqual, emitInjectEvent, getConstant, assertLessThan, getOrCreateTViewCleanup, getOrCreateLViewCleanup, assertNotDefined, nextBindingIndex, getSelectedTNode, getDirectiveDefOrThrow, getTNode, assertComponentType, debugStringifyTypeForError, ChangeDetectionScheduler, EnvironmentInjector, SVG_NAMESPACE, MATH_ML_NAMESPACE, viewAttachedToContainer, storeCleanupWithContext, signal, createInjectorWithoutInjectorInstances, R3Injector, getNullInjector, internalImportProvidersFrom, initNgDevMode, fillProperties, getBindingsEnabled, lastNodeWasCreated, NgZone, ErrorHandler, assertNotInReactiveContext, assertInInjectionContext, DestroyRef, ViewContext, removeLViewOnDestroy, walkUpViews, getNativeByIndex, assertElement, arrayInsert2, arraySplice, setInjectorProfiler, NullInjector, ENVIRONMENT_INITIALIZER, INJECTOR_DEF_TYPES, walkProviderTree, getInjectorDef, deepForEach, isTypeProvider, isSignal, isInInjectionContext, runInInjectionContext, ZONELESS_ENABLED, EffectScheduler, PendingTasksInternal, PendingTasks, getAnimationElementRemovalRegistry, assertTNodeCreationIndex, isSkipHydrationRootTNode, leaveSkipHydrationBlock, decreaseElementDepthCount, getNamespace, enterSkipHydrationBlock, getCurrentDirectiveDef, assertIndexInExpandoRange, getBindingIndex, assertOneOf, setInI18nBlock, nextContextImpl, getCurrentQueryIndex, getContextLView, load, keyValueArrayIndexOf, keyValueArraySet, keyValueArrayGet, incrementBindingIndex, isWritableSignal, store, providerToFactory, emitProviderConfiguredEvent, isClassProvider, setAnimationElementRemovalRegistry, getBindingRoot, NG_COMP_DEF, ɵɵresetView as __resetView, ɵɵnamespaceHTML as __namespaceHTML, ɵɵnamespaceMathML as __namespaceMathML, ɵɵnamespaceSVG as __namespaceSVG, ɵɵenableBindings as __enableBindings, ɵɵdisableBindings as __disableBindings, ɵɵrestoreView as __restoreView, forwardRef, NG_MOD_DEF, NG_INJ_DEF, NG_DIR_DEF, NG_PIPE_DEF, SCHEDULE_IN_ROOT_ZONE, SCHEDULE_IN_ROOT_ZONE_DEFAULT, ZONELESS_SCHEDULER_DISABLED, angularZoneInstanceIdProperty, NoopNgZone, scheduleCallbackWithMicrotask, PROVIDED_ZONELESS, scheduleCallbackWithRafRace, getNativeByTNodeOrNull } from './root_effect_scheduler.mjs';
+import { attachInjectFlag, _global, ɵɵdefineInjectable as __defineInjectable, ɵɵdefineInjector as __defineInjector, ɵɵinject as __inject, ɵɵinvalidFactoryDep as __invalidFactoryDep, resolveForwardRef, newArray, EMPTY_OBJ, assertString, assertNotEqual, FLAGS, assertEqual, isInCheckNoChangesMode, PREORDER_HOOK_FLAGS, assertFirstCreatePass, assertDefined, throwError, assertNumber, assertGreaterThan, HEADER_OFFSET, DECLARATION_VIEW, NG_FACTORY_DEF, isForwardRef, getFactoryDef, assertIndexInRange, assertTNodeForLView, enterDI, runInInjectorProfilerContext, getCurrentTNode, getLView, emitInjectorToCreateInstanceEvent, emitInstanceCreatedByInjectorEvent, throwProviderNotFoundError, leaveDI, assertNodeInjector, stringifyForError, cyclicDependencyErrorWithDetails, cyclicDependencyError, setInjectorProfilerContext, setInjectImplementation, assertDirectiveDef, NG_ELEMENT_ID, convertToBitFlags, isRootView, T_HOST, TVIEW, injectRootLimpMode, isComponentDef, EMBEDDED_VIEW_INJECTOR, INJECTOR$1 as INJECTOR, DECLARATION_COMPONENT_VIEW, isComponentHost, RuntimeError, NG_PROV_DEF, getClosureSafeProperty, getNativeByTNode, flatten, arrayEquals, ID, isLView, assertDomNode, unwrapRNode, getComponentLViewByIndex, CONTEXT, EMPTY_ARRAY, assertLView, HOST, CHILD_HEAD, NEXT, isLContainer, getLViewParent, Injector, CLEANUP, getComponentDef, getDirectiveDef, InjectionToken, inject, isInSkipHydrationBlock as isInSkipHydrationBlock$1, HYDRATION, isContentQueryHost, setCurrentQueryIndex, XSS_SECURITY_URL, renderStringify, ENVIRONMENT, makeEnvironmentProviders, isDirectiveHost, formatRuntimeError, resetPreOrderHookFlags, PARENT, RENDERER, CHILD_TAIL, assertSame, assertFirstUpdatePass, getSelectedIndex, getTView, assertIndexInDeclRange, setSelectedIndex, assertLContainer, MOVED_VIEWS, isDestroyed, REACTIVE_TEMPLATE_CONSUMER, DECLARATION_LCONTAINER, QUERIES, assertNotReactive, ON_DESTROY_HOOKS, assertFunction, EFFECTS, assertProjectionSlots, NATIVE, ANIMATIONS, assertParentView, CONTAINER_HEADER_OFFSET, assertNotSame, setCurrentDirectiveIndex, setCurrentTNode, getElementDepthCount, increaseElementDepthCount, wasLastNodeCreated, isCurrentTNodeParent, setCurrentTNodeAsNotParent, assertHasParent, INTERNAL_APPLICATION_ERROR_HANDLER, stringify, getCurrentDirectiveIndex, unwrapLView, isCreationMode, enterView, leaveView, AFTER_RENDER_SEQUENCES_TO_ADD, markAncestorsForTraversal, markViewForRefresh, setIsRefreshingViews, isExhaustiveCheckNoChanges, requiresRefreshOrTraversal, setIsInCheckNoChangesMode, CheckNoChangesMode, setBindingIndex, EFFECTS_TO_SCHEDULE, viewAttachedToChangeDetector, setBindingRootForHostBindings, isRefreshingViews, removeFromArray, addToArray, updateAncestorTraversalFlagsOnAttach, storeLViewOnDestroy, VIEW_REFS, assertGreaterThanOrEqual, isInI18nBlock, assertTNodeForTView, getCurrentParentTNode, getCurrentTNodePlaceholderOk, assertTNode, assertTIcu, assertNumberInRange, DEHYDRATED_VIEWS, getNgModuleDef, getPipeDef as getPipeDef$1, getNgModuleDefOrThrow, isStandalone, concatStringsWithSpace, assertInjectImplementationNotEqual, emitInjectEvent, getConstant, assertLessThan, getOrCreateTViewCleanup, getOrCreateLViewCleanup, assertNotDefined, nextBindingIndex, getSelectedTNode, getDirectiveDefOrThrow, getTNode, assertComponentType, debugStringifyTypeForError, ChangeDetectionScheduler, EnvironmentInjector, SVG_NAMESPACE, MATH_ML_NAMESPACE, viewAttachedToContainer, storeCleanupWithContext, signal, createInjectorWithoutInjectorInstances, R3Injector, getNullInjector, internalImportProvidersFrom, initNgDevMode, fillProperties, getBindingsEnabled, lastNodeWasCreated, NgZone, ErrorHandler, assertNotInReactiveContext, assertInInjectionContext, DestroyRef, ViewContext, removeLViewOnDestroy, walkUpViews, getNativeByIndex, assertElement, arrayInsert2, arraySplice, setInjectorProfiler, NullInjector, ENVIRONMENT_INITIALIZER, INJECTOR_DEF_TYPES, walkProviderTree, getInjectorDef, deepForEach, isTypeProvider, isSignal, isInInjectionContext, runInInjectionContext, ZONELESS_ENABLED, EffectScheduler, PendingTasksInternal, PendingTasks, assertTNodeCreationIndex, isSkipHydrationRootTNode, leaveSkipHydrationBlock, decreaseElementDepthCount, getNamespace, enterSkipHydrationBlock, getCurrentDirectiveDef, assertIndexInExpandoRange, getBindingIndex, assertOneOf, setInI18nBlock, nextContextImpl, getCurrentQueryIndex, getContextLView, load, keyValueArrayIndexOf, keyValueArraySet, keyValueArrayGet, incrementBindingIndex, isWritableSignal, store, providerToFactory, emitProviderConfiguredEvent, isClassProvider, getBindingRoot, NG_COMP_DEF, ɵɵresetView as __resetView, ɵɵnamespaceHTML as __namespaceHTML, ɵɵnamespaceMathML as __namespaceMathML, ɵɵnamespaceSVG as __namespaceSVG, ɵɵenableBindings as __enableBindings, ɵɵdisableBindings as __disableBindings, ɵɵrestoreView as __restoreView, forwardRef, NG_MOD_DEF, NG_INJ_DEF, NG_DIR_DEF, NG_PIPE_DEF, angularZoneInstanceIdProperty, SCHEDULE_IN_ROOT_ZONE, scheduleCallbackWithMicrotask, PROVIDED_ZONELESS, NoopNgZone, scheduleCallbackWithRafRace, getNativeByTNodeOrNull } from './root_effect_scheduler.mjs';
 import { setActiveConsumer, SIGNAL, consumerDestroy, REACTIVE_NODE, consumerPollProducersForChange, consumerBeforeComputation, getActiveConsumer, consumerAfterComputation, createComputed, setThrowInvalidWriteToSignalError } from './signal.mjs';
 import { Subject, Subscription } from 'rxjs';
 import { setActiveConsumer as setActiveConsumer$1 } from '@angular/core/primitives/signals';
@@ -7208,11 +7208,123 @@ function ensureIcuContainerVisitorLoaded(loader) {
     }
 }
 
+/** Parses a CSS time value to milliseconds. */
+function parseCssTimeUnitsToMs(value) {
+    // Some browsers will return it in seconds, whereas others will return milliseconds.
+    const multiplier = value.toLowerCase().indexOf('ms') > -1 ? 1 : 1000;
+    return parseFloat(value) * multiplier;
+}
+/** Parses out multiple values from a computed style into an array. */
+function parseCssPropertyValue(computedStyle, name) {
+    const value = computedStyle.getPropertyValue(name);
+    return value.split(',').map((part) => part.trim());
+}
+/** Gets the transform transition duration, including the delay, of an element in milliseconds. */
+function getLongestComputedTransition(computedStyle) {
+    const transitionedProperties = parseCssPropertyValue(computedStyle, 'transition-property');
+    const rawDurations = parseCssPropertyValue(computedStyle, 'transition-duration');
+    const rawDelays = parseCssPropertyValue(computedStyle, 'transition-delay');
+    const longest = { propertyName: '', duration: 0, animationName: undefined };
+    for (let i = 0; i < transitionedProperties.length; i++) {
+        const duration = parseCssTimeUnitsToMs(rawDelays[i]) + parseCssTimeUnitsToMs(rawDurations[i]);
+        if (duration > longest.duration) {
+            longest.propertyName = transitionedProperties[i];
+            longest.duration = duration;
+        }
+    }
+    return longest;
+}
+function getLongestComputedAnimation(computedStyle) {
+    const rawNames = parseCssPropertyValue(computedStyle, 'animation-name');
+    const rawDelays = parseCssPropertyValue(computedStyle, 'animation-delay');
+    const rawDurations = parseCssPropertyValue(computedStyle, 'animation-duration');
+    const longest = { animationName: '', propertyName: undefined, duration: 0 };
+    for (let i = 0; i < rawNames.length; i++) {
+        const duration = parseCssTimeUnitsToMs(rawDelays[i]) + parseCssTimeUnitsToMs(rawDurations[i]);
+        if (duration > longest.duration) {
+            longest.animationName = rawNames[i];
+            longest.duration = duration;
+        }
+    }
+    return longest;
+}
+function isShorterThanExistingAnimation(existing, longest) {
+    return existing !== undefined && existing.duration > longest.duration;
+}
+function longestExists(longest) {
+    return ((longest.animationName != undefined || longest.propertyName != undefined) &&
+        longest.duration > 0);
+}
+/**
+ * Determines the longest animation, but with `getComputedStyles` instead of `getAnimations`. This
+ * is ultimately safer than getAnimations because it can be used when recalculations are in
+ * progress. `getAnimations()` will be empty in that case.
+ */
+function determineLongestAnimationFromComputedStyles(el, animationsMap) {
+    const computedStyle = getComputedStyle(el);
+    const longestAnimation = getLongestComputedAnimation(computedStyle);
+    const longestTransition = getLongestComputedTransition(computedStyle);
+    const longest = longestAnimation.duration > longestTransition.duration ? longestAnimation : longestTransition;
+    if (isShorterThanExistingAnimation(animationsMap.get(el), longest))
+        return;
+    if (longestExists(longest)) {
+        animationsMap.set(el, longest);
+    }
+}
+/**
+ * Multiple animations can be set on an element. This grabs an element and
+ * determines which of those will be the longest duration. If we didn't do
+ * this, elements would be removed whenever the first animation completes.
+ * This ensures we get the longest running animation and only remove when
+ * that animation completes.
+ */
+function determineLongestAnimation(el, animationsMap, areAnimationSupported) {
+    if (!areAnimationSupported)
+        return;
+    const animations = el.getAnimations();
+    return animations.length === 0
+        ? // fallback to computed styles if getAnimations is empty. This would happen if styles are
+            // currently recalculating due to a reflow happening elsewhere.
+            determineLongestAnimationFromComputedStyles(el, animationsMap)
+        : determineLongestAnimationFromElementAnimations(el, animationsMap, animations);
+}
+function determineLongestAnimationFromElementAnimations(el, animationsMap, animations) {
+    let longest = {
+        animationName: undefined,
+        propertyName: undefined,
+        duration: 0,
+    };
+    for (const animation of animations) {
+        const timing = animation.effect?.getTiming();
+        // duration can be a string 'auto' or a number.
+        const animDuration = typeof timing?.duration === 'number' ? timing.duration : 0;
+        let duration = (timing?.delay ?? 0) + animDuration;
+        let propertyName;
+        let animationName;
+        if (animation.animationName) {
+            animationName = animation.animationName;
+        }
+        else {
+            // Check for CSSTransition specific property
+            propertyName = animation.transitionProperty;
+        }
+        if (duration >= longest.duration) {
+            longest = { animationName, propertyName, duration };
+        }
+    }
+    if (isShorterThanExistingAnimation(animationsMap.get(el), longest))
+        return;
+    if (longestExists(longest)) {
+        animationsMap.set(el, longest);
+    }
+}
+const allLeavingAnimations = new Set();
+
 /**
  * NOTE: for performance reasons, the possible actions are inlined within the function instead of
  * being passed as an argument.
  */
-function applyToElementOrContainer(action, renderer, parent, lNodeToHandle, beforeNode) {
+function applyToElementOrContainer(action, renderer, parent, lNodeToHandle, beforeNode, parentLView) {
     // If this slot was allocated for a text node dynamically created by i18n, the text node itself
     // won't be created until i18nApply() in the update block, so this node should be skipped.
     // For more info, see "ICU expressions should work inside an ngTemplateOutlet inside an ngFor"
@@ -7244,10 +7356,14 @@ function applyToElementOrContainer(action, renderer, parent, lNodeToHandle, befo
             nativeInsertBefore(renderer, parent, rNode, beforeNode || null, true);
         }
         else if (action === 2 /* WalkTNodeTreeAction.Detach */) {
-            nativeRemoveNode(renderer, rNode, isComponent);
+            runLeaveAnimationsWithCallback(parentLView, () => {
+                nativeRemoveNode(renderer, rNode, isComponent);
+            });
         }
         else if (action === 3 /* WalkTNodeTreeAction.Destroy */) {
-            renderer.destroyNode(rNode);
+            runLeaveAnimationsWithCallback(parentLView, () => {
+                renderer.destroyNode(rNode);
+            });
         }
         if (lContainer != null) {
             applyContainer(renderer, action, lContainer, parent, beforeNode);
@@ -7427,6 +7543,37 @@ function cleanUpView(tView, lView) {
         setActiveConsumer(prevConsumer);
     }
 }
+function runLeaveAnimationsWithCallback(lView, callback) {
+    if (lView && lView[ANIMATIONS] && lView[ANIMATIONS].leave) {
+        if (lView[ANIMATIONS].skipLeaveAnimations) {
+            lView[ANIMATIONS].skipLeaveAnimations = false;
+        }
+        else {
+            const leaveAnimations = lView[ANIMATIONS].leave;
+            const runningAnimations = [];
+            for (let index = 0; index < leaveAnimations.length; index++) {
+                const animateFn = leaveAnimations[index];
+                runningAnimations.push(animateFn());
+            }
+            lView[ANIMATIONS].running = Promise.allSettled(runningAnimations);
+            lView[ANIMATIONS].leave = undefined;
+        }
+    }
+    runAfterLeaveAnimations(lView, callback);
+}
+function runAfterLeaveAnimations(lView, callback) {
+    if (lView && lView[ANIMATIONS] && lView[ANIMATIONS].running) {
+        lView[ANIMATIONS].running.then(() => {
+            if (lView[ANIMATIONS] && lView[ANIMATIONS].running) {
+                lView[ANIMATIONS].running = undefined;
+            }
+            allLeavingAnimations.delete(lView);
+            callback();
+        });
+        return;
+    }
+    callback();
+}
 /** Removes listeners and unsubscribes from output subscriptions */
 function processCleanups(tView, lView) {
     ngDevMode && assertNotReactive(processCleanups.name);
@@ -7764,22 +7911,22 @@ function applyNodes(renderer, action, tNode, lView, parentRElement, beforeNode,
         if (!isDetachedByI18n(tNode)) {
             if (tNodeType & 8 /* TNodeType.ElementContainer */) {
                 applyNodes(renderer, action, tNode.child, lView, parentRElement, beforeNode, false);
-                applyToElementOrContainer(action, renderer, parentRElement, rawSlotValue, beforeNode);
+                applyToElementOrContainer(action, renderer, parentRElement, rawSlotValue, beforeNode, lView);
             }
             else if (tNodeType & 32 /* TNodeType.Icu */) {
                 const nextRNode = icuContainerIterate(tNode, lView);
                 let rNode;
                 while ((rNode = nextRNode())) {
-                    applyToElementOrContainer(action, renderer, parentRElement, rNode, beforeNode);
+                    applyToElementOrContainer(action, renderer, parentRElement, rNode, beforeNode, lView);
                 }
-                applyToElementOrContainer(action, renderer, parentRElement, rawSlotValue, beforeNode);
+                applyToElementOrContainer(action, renderer, parentRElement, rawSlotValue, beforeNode, lView);
             }
             else if (tNodeType & 16 /* TNodeType.Projection */) {
                 applyProjectionRecursive(renderer, action, lView, tNode, parentRElement, beforeNode);
             }
             else {
                 ngDevMode && assertTNodeType(tNode, 3 /* TNodeType.AnyRNode */ | 4 /* TNodeType.Container */);
-                applyToElementOrContainer(action, renderer, parentRElement, rawSlotValue, beforeNode);
+                applyToElementOrContainer(action, renderer, parentRElement, rawSlotValue, beforeNode, lView);
             }
         }
         tNode = isProjection ? tNode.projectionNext : tNode.next;
@@ -7833,7 +7980,7 @@ function applyProjectionRecursive(renderer, action, lView, tProjectionNode, pare
         // This should be refactored and cleaned up.
         for (let i = 0; i < nodeToProjectOrRNodes.length; i++) {
             const rNode = nodeToProjectOrRNodes[i];
-            applyToElementOrContainer(action, renderer, parentRElement, rNode, beforeNode);
+            applyToElementOrContainer(action, renderer, parentRElement, rNode, beforeNode, lView);
         }
     }
     else {
@@ -8975,6 +9122,7 @@ function refreshView(tView, lView, templateFn, context) {
         if (templateFn !== null) {
             executeTemplate(tView, lView, templateFn, 2 /* RenderFlags.Update */, context);
         }
+        runEnterAnimations(lView);
         const hooksInitPhaseCompleted = (flags & 3 /* LViewFlags.InitPhaseStateMask */) === 3 /* InitPhaseState.InitPhaseCompleted */;
         // execute pre-order hooks (OnInit, OnChanges, DoCheck)
         // PERF WARNING: do NOT extract this to a separate function without running benchmarks
@@ -9102,6 +9250,15 @@ function refreshView(tView, lView, templateFn, context) {
         leaveView();
     }
 }
+function runEnterAnimations(lView) {
+    const animationData = lView[ANIMATIONS];
+    if (animationData?.enter) {
+        for (const animateFn of animationData.enter) {
+            animateFn();
+        }
+        animationData.enter = undefined;
+    }
+}
 /**
  * Goes over embedded views (ones created through ViewContainerRef APIs) and refreshes
  * them by executing an associated template function.
@@ -9741,15 +9898,20 @@ class ViewRef {
      * introduce other changes.
      */
     checkNoChanges() {
-        if (!ngDevMode)
-            return;
-        try {
-            this.exhaustive ??= this._lView[INJECTOR].get(UseExhaustiveCheckNoChanges, USE_EXHAUSTIVE_CHECK_NO_CHANGES_DEFAULT);
-        }
-        catch {
-            this.exhaustive = USE_EXHAUSTIVE_CHECK_NO_CHANGES_DEFAULT;
+        // Note: we use `if (ngDevMode) { ... }` instead of an early return.
+        // ESBuild is conservative about removing dead code that follows `return;`
+        // inside a function body, so the block may remain in the bundle.
+        // Using a conditional ensures the dev-only logic is reliably tree-shaken
+        // in production builds.
+        if (ngDevMode) {
+            try {
+                this.exhaustive ??= this._lView[INJECTOR].get(UseExhaustiveCheckNoChanges, USE_EXHAUSTIVE_CHECK_NO_CHANGES_DEFAULT);
+            }
+            catch {
+                this.exhaustive = USE_EXHAUSTIVE_CHECK_NO_CHANGES_DEFAULT;
+            }
+            checkNoChangesInternal(this._lView, this.exhaustive);
         }
-        checkNoChangesInternal(this._lView, this.exhaustive);
     }
     attachToViewContainerRef() {
         if (this._appRef) {
@@ -13054,13 +13216,21 @@ function listenToDomEvent(tNode, tView, lView, eventTargetResolver, renderer, ev
         const target = eventTargetResolver ? eventTargetResolver(native) : native;
         stashEventListenerImpl(lView, target, eventName, wrappedListener);
         const cleanupFn = renderer.listen(target, eventName, wrappedListener);
-        const idxOrTargetGetter = eventTargetResolver
-            ? (_lView) => eventTargetResolver(unwrapRNode(_lView[tNode.index]))
-            : tNode.index;
-        storeListenerCleanup(idxOrTargetGetter, tView, lView, eventName, wrappedListener, cleanupFn, false);
+        // We skip cleaning up animation event types to ensure leaving animation events can be used.
+        // These events should be automatically garbage collected anyway after the element is
+        // removed from the DOM.
+        if (!isAnimationEventType(eventName)) {
+            const idxOrTargetGetter = eventTargetResolver
+                ? (_lView) => eventTargetResolver(unwrapRNode(_lView[tNode.index]))
+                : tNode.index;
+            storeListenerCleanup(idxOrTargetGetter, tView, lView, eventName, wrappedListener, cleanupFn, false);
+        }
     }
     return hasCoalesced;
 }
+function isAnimationEventType(eventName) {
+    return eventName.startsWith('animation') || eventName.startsWith('transition');
+}
 /**
  * A utility function that checks if a given element has already an event handler registered for an
  * event with a specified name. The TView.cleanup data structure is used to find out which events
@@ -13522,7 +13692,7 @@ class ComponentFactory extends ComponentFactory$1 {
 }
 function createRootTView(rootSelectorOrNode, componentDef, componentBindings, directives) {
     const tAttributes = rootSelectorOrNode
-        ? ['ng-version', '21.0.0-next.2']
+        ? ['ng-version', '21.0.0-next.4']
         : // Extract attributes and classes from the first selector only to match VE behavior.
             extractAttrsAndClassesFromSelector(componentDef.selectors[0]);
     let creationBindings = null;
@@ -19911,6 +20081,22 @@ function remove(list, el) {
     }
 }
 
+/**
+ * Replace with `Promise.withResolvers()` once it's available.
+ * NET September 2026
+ *
+ * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/withResolvers.
+ */
+function promiseWithResolvers() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    return { promise, resolve, reject };
+}
+
 /**
  * Schedules triggering of a defer block for `on idle` and `on timer` conditions.
  */
@@ -20280,7 +20466,7 @@ function cleanupRemainingHydrationQueue(hydrationQueue, dehydratedBlockRegistry)
  */
 function populateHydratingStateForQueue(registry, queue) {
     for (let blockId of queue) {
-        registry.hydrating.set(blockId, Promise.withResolvers());
+        registry.hydrating.set(blockId, promiseWithResolvers());
     }
 }
 // Waits for the next render cycle to complete
@@ -21128,278 +21314,88 @@ const MAX_ANIMATION_TIMEOUT = new InjectionToken(typeof ngDevMode !== 'undefined
 });
 const MAX_ANIMATION_TIMEOUT_DEFAULT = 4000;
 
+const DEFAULT_ANIMATIONS_DISABLED = false;
+const areAnimationSupported = (typeof ngServerMode === 'undefined' || !ngServerMode) &&
+    typeof document !== 'undefined' &&
+    // tslint:disable-next-line:no-toplevel-property-access
+    typeof document?.documentElement?.getAnimations === 'function';
 /**
- * Registers elements for delayed removal action for animation in the case
- * that `animate.leave` is used. This stores the target element and any
- * classes, class resolvers, and callback functions that may be needed
- * to apply the removal animation, and then stashes the actual element
- * removal function from the dom renderer to be called after the
- * animation is finished.
- */
-class ElementRegistry {
-    outElements = new WeakMap();
-    remove(el) {
-        this.outElements.delete(el);
-    }
-    /** Used when animate.leave is only applying classes */
-    trackClasses(details, classes) {
-        const classList = getClassListFromValue(classes);
-        if (!classList)
-            return;
-        for (let klass of classList) {
-            details.classes?.add(klass);
-        }
+ * Helper function to check if animations are disabled via injection token
+ */
+function areAnimationsDisabled(lView) {
+    const injector = lView[INJECTOR];
+    return injector.get(ANIMATIONS_DISABLED, DEFAULT_ANIMATIONS_DISABLED);
+}
+/**
+ * Asserts a value passed in is actually an animation type and not something else
+ */
+function assertAnimationTypes(value, instruction) {
+    if (value == null || (typeof value !== 'string' && typeof value !== 'function')) {
+        throw new RuntimeError(650 /* RuntimeErrorCode.ANIMATE_INVALID_VALUE */, `'${instruction}' value must be a string of CSS classes or an animation function, got ${stringify(value)}`);
     }
-    /** Used when animate.leave is applying classes via a bound attribute
-     *  which requires resolving the binding function at the right time
-     *  to get the proper class list. There may be multiple resolvers due
-     *  to composition via host bindings.
-     */
-    trackResolver(details, resolver) {
-        if (!details.classFns) {
-            details.classFns = [resolver];
-        }
-        else {
-            details.classFns.push(resolver);
-        }
+}
+/**
+ * Asserts a given native element is an actual Element node and not something like a comment node.
+ */
+function assertElementNodes(nativeElement, instruction) {
+    if (nativeElement.nodeType !== Node.ELEMENT_NODE) {
+        throw new RuntimeError(650 /* RuntimeErrorCode.ANIMATE_INVALID_VALUE */, `'${instruction}' can only be used on an element node, got ${stringify(nativeElement.nodeType)}`);
     }
-    /** Used when `animate.leave` is using the function signature and will have a
-     *  callback function, rather than a list of classes.
-     */
-    addCallback(el, value, animateWrapperFn) {
-        const details = this.outElements.get(el) ?? {
-            classes: null,
-            animateFn: () => { },
-            isEventBinding: true,
-        };
-        details.animateFn = animateWrapperFn(el, value);
-        this.outElements.set(el, details);
-    }
-    /** Used when `animate.leave` is using classes. */
-    add(el, value, animateWrapperFn) {
-        const details = this.outElements.get(el) ?? {
-            classes: new Set(),
-            animateFn: () => { },
-            isEventBinding: false,
-        };
-        if (typeof value === 'function') {
-            this.trackResolver(details, value);
+}
+/**
+ * trackEnterClasses is necessary in the case of composition where animate.enter
+ * is used on the same element in multiple places, like on the element and in a
+ * host binding. When removing classes, we need the entire list of animation classes
+ * added to properly remove them when the longest animation fires.
+ */
+function trackEnterClasses(el, classList, cleanupFns) {
+    const elementData = enterClassMap.get(el);
+    if (elementData) {
+        for (const klass of classList) {
+            elementData.classList.push(klass);
         }
-        else {
-            this.trackClasses(details, value);
+        for (const fn of cleanupFns) {
+            elementData.cleanupFns.push(fn);
         }
-        details.animateFn = animateWrapperFn(el, details.classes, details.classFns);
-        this.outElements.set(el, details);
     }
-    has(el) {
-        return this.outElements.has(el);
+    else {
+        enterClassMap.set(el, { classList, cleanupFns });
     }
-    /** This is called by the dom renderer to actually initiate the animation
-     *  using the animateFn stored in the registry. The DOM renderer passes in
-     *  the removal function to be fired off when the animation finishes.
-     */
-    animate(el, removeFn, maxAnimationTimeout) {
-        if (!this.outElements.has(el))
-            return removeFn();
-        const details = this.outElements.get(el);
-        let timeoutId;
-        let called = false;
-        const remove = () => {
-            // This called check is to prevent a rare race condition where the timing of removal
-            // might result in the removal function being called twice.
-            if (called)
-                return;
-            called = true;
-            clearTimeout(timeoutId);
-            this.remove(el);
-            removeFn();
-        };
-        // this timeout is used to ensure elements actually get removed in the case
-        // that the user forgot to call the remove callback. The timeout is cleared
-        // in the DOM renderer during the remove child process. It only applies
-        // to the event binding use case.
-        if (details.isEventBinding) {
-            timeoutId = setTimeout(remove, maxAnimationTimeout);
+}
+/**
+ * Helper function to cleanup enterClassMap data safely
+ */
+function cleanupEnterClassData(element) {
+    const elementData = enterClassMap.get(element);
+    if (elementData) {
+        for (const fn of elementData.cleanupFns) {
+            fn();
         }
-        details.animateFn(remove);
+        enterClassMap.delete(element);
     }
+    longestAnimations.delete(element);
 }
-function getClassListFromValue(value) {
-    const classes = typeof value === 'function' ? value() : value;
-    let classList = Array.isArray(classes) ? classes : null;
-    if (typeof classes === 'string') {
-        classList = classes
-            .trim()
-            .split(/\s+/)
-            .filter((k) => k);
-    }
-    return classList;
-}
-
-/** Parses a CSS time value to milliseconds. */
-function parseCssTimeUnitsToMs(value) {
-    // Some browsers will return it in seconds, whereas others will return milliseconds.
-    const multiplier = value.toLowerCase().indexOf('ms') > -1 ? 1 : 1000;
-    return parseFloat(value) * multiplier;
-}
-/** Parses out multiple values from a computed style into an array. */
-function parseCssPropertyValue(computedStyle, name) {
-    const value = computedStyle.getPropertyValue(name);
-    return value.split(',').map((part) => part.trim());
-}
-/** Gets the transform transition duration, including the delay, of an element in milliseconds. */
-function getLongestComputedTransition(computedStyle) {
-    const transitionedProperties = parseCssPropertyValue(computedStyle, 'transition-property');
-    const rawDurations = parseCssPropertyValue(computedStyle, 'transition-duration');
-    const rawDelays = parseCssPropertyValue(computedStyle, 'transition-delay');
-    const longest = { propertyName: '', duration: 0, animationName: undefined };
-    for (let i = 0; i < transitionedProperties.length; i++) {
-        const duration = parseCssTimeUnitsToMs(rawDelays[i]) + parseCssTimeUnitsToMs(rawDurations[i]);
-        if (duration > longest.duration) {
-            longest.propertyName = transitionedProperties[i];
-            longest.duration = duration;
-        }
-    }
-    return longest;
-}
-function getLongestComputedAnimation(computedStyle) {
-    const rawNames = parseCssPropertyValue(computedStyle, 'animation-name');
-    const rawDelays = parseCssPropertyValue(computedStyle, 'animation-delay');
-    const rawDurations = parseCssPropertyValue(computedStyle, 'animation-duration');
-    const longest = { animationName: '', propertyName: undefined, duration: 0 };
-    for (let i = 0; i < rawNames.length; i++) {
-        const duration = parseCssTimeUnitsToMs(rawDelays[i]) + parseCssTimeUnitsToMs(rawDurations[i]);
-        if (duration > longest.duration) {
-            longest.animationName = rawNames[i];
-            longest.duration = duration;
-        }
-    }
-    return longest;
-}
-function isShorterThanExistingAnimation(existing, longest) {
-    return existing !== undefined && existing.duration > longest.duration;
-}
-function longestExists(longest) {
-    return ((longest.animationName != undefined || longest.propertyName != undefined) &&
-        longest.duration > 0);
-}
-/**
- * Determines the longest animation, but with `getComputedStyles` instead of `getAnimations`. This
- * is ultimately safer than getAnimations because it can be used when recalculations are in
- * progress. `getAnimations()` will be empty in that case.
- */
-function determineLongestAnimationFromComputedStyles(el, animationsMap) {
-    const computedStyle = getComputedStyle(el);
-    const longestAnimation = getLongestComputedAnimation(computedStyle);
-    const longestTransition = getLongestComputedTransition(computedStyle);
-    const longest = longestAnimation.duration > longestTransition.duration ? longestAnimation : longestTransition;
-    if (isShorterThanExistingAnimation(animationsMap.get(el), longest))
-        return;
-    if (longestExists(longest)) {
-        animationsMap.set(el, longest);
-    }
-}
-/**
- * Multiple animations can be set on an element. This grabs an element and
- * determines which of those will be the longest duration. If we didn't do
- * this, elements would be removed whenever the first animation completes.
- * This ensures we get the longest running animation and only remove when
- * that animation completes.
- */
-function determineLongestAnimation(el, animationsMap, areAnimationSupported) {
-    if (!areAnimationSupported)
-        return;
-    const animations = el.getAnimations();
-    return animations.length === 0
-        ? // fallback to computed styles if getAnimations is empty. This would happen if styles are
-            // currently recalculating due to a reflow happening elsewhere.
-            determineLongestAnimationFromComputedStyles(el, animationsMap)
-        : determineLongestAnimationFromElementAnimations(el, animationsMap, animations);
-}
-function determineLongestAnimationFromElementAnimations(el, animationsMap, animations) {
-    let longest = {
-        animationName: undefined,
-        propertyName: undefined,
-        duration: 0,
-    };
-    for (const animation of animations) {
-        const timing = animation.effect?.getTiming();
-        // duration can be a string 'auto' or a number.
-        const animDuration = typeof timing?.duration === 'number' ? timing.duration : 0;
-        let duration = (timing?.delay ?? 0) + animDuration;
-        let propertyName;
-        let animationName;
-        if (animation.animationName) {
-            animationName = animation.animationName;
-        }
-        else {
-            // Check for CSSTransition specific property
-            propertyName = animation.transitionProperty;
-        }
-        if (duration >= longest.duration) {
-            longest = { animationName, propertyName, duration };
-        }
-    }
-    if (isShorterThanExistingAnimation(animationsMap.get(el), longest))
-        return;
-    if (longestExists(longest)) {
-        animationsMap.set(el, longest);
-    }
-}
-
-const DEFAULT_ANIMATIONS_DISABLED = false;
-const areAnimationSupported = (typeof ngServerMode === 'undefined' || !ngServerMode) &&
-    typeof document !== 'undefined' &&
-    // tslint:disable-next-line:no-toplevel-property-access
-    typeof document?.documentElement?.getAnimations === 'function';
-/**
- * Helper function to check if animations are disabled via injection token
- */
-function areAnimationsDisabled(lView) {
-    const injector = lView[INJECTOR];
-    return injector.get(ANIMATIONS_DISABLED, DEFAULT_ANIMATIONS_DISABLED);
-}
-/**
- * Helper function to setup element registry cleanup when LView is destroyed
- */
-function setupElementRegistryCleanup(elementRegistry, lView, tView, nativeElement) {
-    if (lView[FLAGS] & 8 /* LViewFlags.FirstLViewPass */) {
-        storeCleanupWithContext(tView, lView, nativeElement, (elToClean) => {
-            elementRegistry.elements.remove(elToClean);
-        });
-    }
-}
-/**
- * Helper function to cleanup enterClassMap data safely
- */
-function cleanupEnterClassData(element) {
-    const elementData = enterClassMap.get(element);
-    if (elementData) {
-        for (const fn of elementData.cleanupFns) {
-            fn();
-        }
-        enterClassMap.delete(element);
-    }
-    longestAnimations.delete(element);
-}
-const noOpAnimationComplete = () => { };
-// Tracks the list of classes added to a DOM node from `animate.enter` calls to ensure
-// we remove all of the classes in the case of animation composition via host bindings.
-const enterClassMap = new WeakMap();
-const longestAnimations = new WeakMap();
-// Tracks nodes that are animating away for the duration of the animation. This is
-// used to prevent duplicate nodes from showing up when nodes have been toggled quickly
-// from an `@if` or `@for`.
-const leavingNodes = new WeakMap();
-function clearLeavingNodes(tNode, el) {
-    const nodes = leavingNodes.get(tNode);
-    if (nodes && nodes.length > 0) {
-        const ix = nodes.findIndex((node) => node === el);
-        if (ix > -1)
-            nodes.splice(ix, 1);
-    }
-    if (nodes?.length === 0) {
-        leavingNodes.delete(tNode);
+const noOpAnimationComplete = () => { };
+// Tracks the list of classes added to a DOM node from `animate.enter` calls to ensure
+// we remove all of the classes in the case of animation composition via host bindings.
+const enterClassMap = new WeakMap();
+const longestAnimations = new WeakMap();
+// Tracks nodes that are animating away for the duration of the animation. This is
+// used to prevent duplicate nodes from showing up when nodes have been toggled quickly
+// from an `@if` or `@for`.
+const leavingNodes = new WeakMap();
+/**
+ * This actually removes the leaving HTML Element in the TNode
+ */
+function clearLeavingNodes(tNode, el) {
+    const nodes = leavingNodes.get(tNode);
+    if (nodes && nodes.length > 0) {
+        const ix = nodes.findIndex((node) => node === el);
+        if (ix > -1)
+            nodes.splice(ix, 1);
+    }
+    if (nodes?.length === 0) {
+        leavingNodes.delete(tNode);
     }
 }
 /**
@@ -21414,7 +21410,9 @@ function cancelLeavingNodes(tNode, lView) {
         // this is the insertion point for the new TNode element.
         // it will be inserted before the declaring containers anchor.
         const beforeNode = getBeforeNodeForView(tNode.index, lContainer);
-        // here we need to check the previous sibling of that anchor
+        // here we need to check the previous sibling of that anchor. The first
+        // previousSibling node will be the new element added. The second
+        // previousSibling will be the one that's being removed.
         const previousNode = beforeNode?.previousSibling;
         // We really only want to cancel animations if the leaving node is the
         // same as the node before where the new node will be inserted. This is
@@ -21424,6 +21422,11 @@ function cancelLeavingNodes(tNode, lView) {
         }
     }
 }
+/**
+ * Tracks the nodes list of nodes that are leaving the DOM so we can cancel any leave animations
+ * and remove the node before adding a new entering instance of the DOM node. This prevents
+ * duplicates from showing up on screen mid-animation.
+ */
 function trackLeavingNodes(tNode, el) {
     // We need to track this tNode's element just to be sure we don't add
     // a new RNode for this TNode while this one is still animating away.
@@ -21435,6 +21438,80 @@ function trackLeavingNodes(tNode, el) {
         leavingNodes.set(tNode, [el]);
     }
 }
+/**
+ * Retrieves the list of specified enter animations from the lView
+ */
+function getLViewEnterAnimations(lView) {
+    const animationData = (lView[ANIMATIONS] ??= {});
+    return (animationData.enter ??= []);
+}
+/**
+ * Retrieves the list of specified leave animations from the lView
+ */
+function getLViewLeaveAnimations(lView) {
+    const animationData = (lView[ANIMATIONS] ??= {});
+    return (animationData.leave ??= []);
+}
+/**
+ * Gets the list of classes from a passed in value
+ */
+function getClassListFromValue(value) {
+    const classes = typeof value === 'function' ? value() : value;
+    let classList = Array.isArray(classes) ? classes : null;
+    if (typeof classes === 'string') {
+        classList = classes
+            .trim()
+            .split(/\s+/)
+            .filter((k) => k);
+    }
+    return classList;
+}
+/**
+ * Cancels any running enter animations on a given element to prevent them from interfering
+ * with leave animations.
+ */
+function cancelAnimationsIfRunning(element, renderer) {
+    if (!areAnimationSupported)
+        return;
+    const elementData = enterClassMap.get(element);
+    if (elementData &&
+        elementData.classList.length > 0 &&
+        elementHasClassList(element, elementData.classList)) {
+        for (const klass of elementData.classList) {
+            renderer.removeClass(element, klass);
+        }
+    }
+    // We need to prevent any enter animation listeners from firing if they exist.
+    cleanupEnterClassData(element);
+}
+/**
+ * Checks if a given element contains the classes is a provided list
+ */
+function elementHasClassList(element, classList) {
+    for (const className of classList) {
+        if (element.classList.contains(className))
+            return true;
+    }
+    return false;
+}
+/**
+ * Determines if the animation or transition event is currently the expected longest animation
+ * based on earlier determined data in `longestAnimations`
+ *
+ * @param event
+ * @param nativeElement
+ * @returns
+ */
+function isLongestAnimation(event, nativeElement) {
+    const longestAnimation = longestAnimations.get(nativeElement);
+    return (nativeElement === event.target &&
+        longestAnimation !== undefined &&
+        ((longestAnimation.animationName !== undefined &&
+            event.animationName === longestAnimation.animationName) ||
+            (longestAnimation.propertyName !== undefined &&
+                event.propertyName === longestAnimation.propertyName)));
+}
+
 /**
  * Instruction to handle the `animate.enter` behavior for class bindings.
  *
@@ -21454,6 +21531,11 @@ function ɵɵanimateEnter(value) {
         return ɵɵanimateEnter;
     }
     const tNode = getCurrentTNode();
+    cancelLeavingNodes(tNode, lView);
+    getLViewEnterAnimations(lView).push(() => runEnterAnimation(lView, tNode, value));
+    return ɵɵanimateEnter; // For chaining
+}
+function runEnterAnimation(lView, tNode, value) {
     const nativeElement = getNativeByTNode(tNode, lView);
     ngDevMode && assertElementNodes(nativeElement, 'animate.enter');
     const renderer = lView[RENDERER];
@@ -21466,23 +21548,22 @@ function ɵɵanimateEnter(value) {
     // to get the longest animation to ensure we don't complete animations early.
     // This also allows us to setup cancellation of animations in progress if the
     // gets removed early.
-    const handleAnimationStart = (event) => {
+    const handleEnterAnimationStart = (event) => {
         const eventName = event instanceof AnimationEvent ? 'animationend' : 'transitionend';
         ngZone.runOutsideAngular(() => {
-            cleanupFns.push(renderer.listen(nativeElement, eventName, handleInAnimationEnd));
+            cleanupFns.push(renderer.listen(nativeElement, eventName, handleEnterAnimationEnd));
         });
     };
     // When the longest animation ends, we can remove all the classes
-    const handleInAnimationEnd = (event) => {
-        animationEnd(event, nativeElement, renderer);
+    const handleEnterAnimationEnd = (event) => {
+        enterAnimationEnd(event, nativeElement, renderer);
     };
     // We only need to add these event listeners if there are actual classes to apply
     if (activeClasses && activeClasses.length > 0) {
         ngZone.runOutsideAngular(() => {
-            cleanupFns.push(renderer.listen(nativeElement, 'animationstart', handleAnimationStart));
-            cleanupFns.push(renderer.listen(nativeElement, 'transitionstart', handleAnimationStart));
+            cleanupFns.push(renderer.listen(nativeElement, 'animationstart', handleEnterAnimationStart));
+            cleanupFns.push(renderer.listen(nativeElement, 'transitionstart', handleEnterAnimationStart));
         });
-        cancelLeavingNodes(tNode, lView);
         trackEnterClasses(nativeElement, activeClasses, cleanupFns);
         for (const klass of activeClasses) {
             renderer.addClass(nativeElement, klass);
@@ -21502,26 +21583,21 @@ function ɵɵanimateEnter(value) {
             });
         });
     }
-    return ɵɵanimateEnter; // For chaining
 }
-/**
- * trackEnterClasses is necessary in the case of composition where animate.enter
- * is used on the same element in multiple places, like on the element and in a
- * host binding. When removing classes, we need the entire list of animation classes
- * added to properly remove them when the longest animation fires.
- */
-function trackEnterClasses(el, classList, cleanupFns) {
-    const elementData = enterClassMap.get(el);
-    if (elementData) {
-        for (const klass of classList) {
-            elementData.classList.push(klass);
-        }
-        for (const fn of cleanupFns) {
-            elementData.cleanupFns.push(fn);
+function enterAnimationEnd(event, nativeElement, renderer) {
+    const elementData = enterClassMap.get(nativeElement);
+    if (!elementData)
+        return;
+    if (isLongestAnimation(event, nativeElement)) {
+        // Now that we've found the longest animation, there's no need
+        // to keep bubbling up this event as it's not going to apply to
+        // other elements further up. We don't want it to inadvertently
+        // affect any other animations on the page.
+        event.stopImmediatePropagation();
+        for (const klass of elementData.classList) {
+            renderer.removeClass(nativeElement, klass);
         }
-    }
-    else {
-        enterClassMap.set(el, { classList, cleanupFns });
+        cleanupEnterClassData(nativeElement);
     }
 }
 /**
@@ -21544,16 +21620,22 @@ function ɵɵanimateEnterListener(value) {
         return ɵɵanimateEnterListener;
     }
     const tNode = getCurrentTNode();
+    cancelLeavingNodes(tNode, lView);
+    getLViewEnterAnimations(lView).push(() => runEnterAnimationFunction(lView, tNode, value));
+    return ɵɵanimateEnterListener;
+}
+/**
+ * runs enter animations when a custom function is provided
+ */
+function runEnterAnimationFunction(lView, tNode, value) {
     const nativeElement = getNativeByTNode(tNode, lView);
     ngDevMode && assertElementNodes(nativeElement, 'animate.enter');
-    cancelLeavingNodes(tNode, lView);
     value.call(lView[CONTEXT], { target: nativeElement, animationComplete: noOpAnimationComplete });
-    return ɵɵanimateEnterListener;
 }
 /**
  * Instruction to handle the `animate.leave` behavior for class animations.
- * It registers an animation with the ElementRegistry to be run when the element
- * is scheduled for removal from the DOM.
+ * It creates a leave animation function that's tracked in the LView to
+ * be run before DOM node removal and cleanup.
  *
  * @param value The value bound to `animate.leave`, which can be a string or a function.
  * @returns This function returns itself so that it may be chained.
@@ -21571,170 +21653,34 @@ function ɵɵanimateLeave(value) {
     if (animationsDisabled) {
         return ɵɵanimateLeave;
     }
-    const tView = getTView();
     const tNode = getCurrentTNode();
-    const nativeElement = getNativeByTNode(tNode, lView);
-    ngDevMode && assertElementNodes(nativeElement, 'animate.leave');
-    // This instruction is called in the update pass.
-    const renderer = lView[RENDERER];
-    const elementRegistry = getAnimationElementRemovalRegistry();
-    ngDevMode &&
-        assertDefined(elementRegistry.elements, 'Expected `ElementRegistry` to be present in animations subsystem');
-    const ngZone = lView[INJECTOR].get(NgZone);
-    // This function gets stashed in the registry to be used once the element removal process
-    // begins. We pass in the values and resolvers so as to evaluate the resolved classes
-    // at the latest possible time, meaning we evaluate them right before the animation
-    // begins.
-    const animate = (el, value, resolvers) => {
-        return (removalFn) => {
-            animateLeaveClassRunner(el, tNode, getClassList(value, resolvers), removalFn, renderer, animationsDisabled, ngZone);
-        };
-    };
-    // Ensure cleanup if the LView is destroyed before the animation runs.
-    setupElementRegistryCleanup(elementRegistry, lView, tView, nativeElement);
-    elementRegistry.elements.add(nativeElement, value, animate);
+    getLViewLeaveAnimations(lView).push(() => runLeaveAnimations(lView, tNode, value, animationsDisabled));
     return ɵɵanimateLeave; // For chaining
 }
-/**
- * Instruction to handle the `(animate.leave)` behavior for event bindings, aka when
- * a user wants to use a custom animation function rather than a class. It registers
- * an animation with the ElementRegistry to be run when the element is scheduled for
- * removal from the DOM.
- *
- * @param value The value bound to `(animate.leave)`, an AnimationFunction.
- * @returns This function returns itself so that it may be chained.
- *
- * @codeGenApi
- */
-function ɵɵanimateLeaveListener(value) {
-    performanceMarkFeature('NgAnimateLeave');
-    if ((typeof ngServerMode !== 'undefined' && ngServerMode) || !areAnimationSupported) {
-        return ɵɵanimateLeaveListener;
-    }
-    ngDevMode && assertAnimationTypes(value, 'animate.leave');
-    // Even when animations are disabled, we still need to register the element for removal
-    // to ensure proper cleanup and allow developers to handle element removal in tests
-    // So we don't have an early return here.
-    const lView = getLView();
-    const tNode = getCurrentTNode();
-    const tView = getTView();
+function runLeaveAnimations(lView, tNode, value, animationsDisabled) {
+    const { promise, resolve } = promiseWithResolvers();
     const nativeElement = getNativeByTNode(tNode, lView);
     ngDevMode && assertElementNodes(nativeElement, 'animate.leave');
-    const elementRegistry = getAnimationElementRemovalRegistry();
-    ngDevMode &&
-        assertDefined(elementRegistry.elements, 'Expected `ElementRegistry` to be present in animations subsystem');
     const renderer = lView[RENDERER];
-    const animationsDisabled = areAnimationsDisabled(lView);
     const ngZone = lView[INJECTOR].get(NgZone);
-    const animate = (_el, value) => {
-        return (removeFn) => {
-            if (animationsDisabled) {
-                removeFn();
-            }
-            else {
-                const event = {
-                    target: nativeElement,
-                    animationComplete: () => {
-                        clearLeavingNodes(tNode, _el);
-                        removeFn();
-                    },
-                };
-                trackLeavingNodes(tNode, _el);
-                ngZone.runOutsideAngular(() => {
-                    renderer.listen(_el, 'animationend', () => removeFn(), { once: true });
-                });
-                value.call(lView[CONTEXT], event);
-            }
-        };
-    };
-    // Ensure cleanup if the LView is destroyed before the animation runs.
-    setupElementRegistryCleanup(elementRegistry, lView, tView, nativeElement);
-    elementRegistry.elements.addCallback(nativeElement, value, animate);
-    return ɵɵanimateLeaveListener; // For chaining
-}
-/**
- * Builds the list of classes to apply to an element based on either the passed in list of strings
- * or the set of resolver functions that are coming from bindings. Those resolver functions should
- * resolve into either a string or a string array. There may be multiple to support composition.
- */
-function getClassList(value, resolvers) {
-    const classList = new Set(value);
-    if (resolvers && resolvers.length) {
-        for (const resolverFn of resolvers) {
-            const resolvedValue = getClassListFromValue(resolverFn);
-            if (resolvedValue) {
-                for (const rv of resolvedValue) {
-                    classList.add(rv);
-                }
-            }
-        }
-    }
-    return classList;
-}
-function cancelAnimationsIfRunning(element, renderer) {
-    if (!areAnimationSupported)
-        return;
-    const elementData = enterClassMap.get(element);
-    if (elementData &&
-        elementData.classList.length > 0 &&
-        elementHasClassList(element, elementData.classList)) {
-        for (const klass of elementData.classList) {
-            renderer.removeClass(element, klass);
-        }
-    }
-    // We need to prevent any enter animation listeners from firing if they exist.
-    cleanupEnterClassData(element);
-}
-function elementHasClassList(element, classList) {
-    for (const className of classList) {
-        if (element.classList.contains(className))
-            return true;
-    }
-    return false;
-}
-function isLongestAnimation(event, nativeElement) {
-    const longestAnimation = longestAnimations.get(nativeElement);
-    return (nativeElement === event.target &&
-        longestAnimation !== undefined &&
-        ((longestAnimation.animationName !== undefined &&
-            event.animationName === longestAnimation.animationName) ||
-            (longestAnimation.propertyName !== undefined &&
-                event.propertyName === longestAnimation.propertyName)));
-}
-function animationEnd(event, nativeElement, renderer) {
-    const elementData = enterClassMap.get(nativeElement);
-    if (!elementData)
-        return;
-    if (isLongestAnimation(event, nativeElement)) {
-        // Now that we've found the longest animation, there's no need
-        // to keep bubbling up this event as it's not going to apply to
-        // other elements further up. We don't want it to inadvertently
-        // affect any other animations on the page.
-        event.stopImmediatePropagation();
-        for (const klass of elementData.classList) {
-            renderer.removeClass(nativeElement, klass);
-        }
-        cleanupEnterClassData(nativeElement);
-    }
-}
-function assertAnimationTypes(value, instruction) {
-    if (value == null || (typeof value !== 'string' && typeof value !== 'function')) {
-        throw new RuntimeError(650 /* RuntimeErrorCode.ANIMATE_INVALID_VALUE */, `'${instruction}' value must be a string of CSS classes or an animation function, got ${stringify(value)}`);
+    allLeavingAnimations.add(lView);
+    const activeClasses = getClassListFromValue(value);
+    if (activeClasses && activeClasses.length > 0) {
+        animateLeaveClassRunner(nativeElement, tNode, activeClasses, renderer, animationsDisabled, ngZone, resolve);
     }
-}
-function assertElementNodes(nativeElement, instruction) {
-    if (nativeElement.nodeType !== Node.ELEMENT_NODE) {
-        throw new RuntimeError(650 /* RuntimeErrorCode.ANIMATE_INVALID_VALUE */, `'${instruction}' can only be used on an element node, got ${stringify(nativeElement.nodeType)}`);
+    else {
+        resolve();
     }
+    return promise;
 }
 /**
  * This function actually adds the classes that animate element that's leaving the DOM.
  * Once it finishes, it calls the remove function that was provided by the DOM renderer.
  */
-function animateLeaveClassRunner(el, tNode, classList, finalRemoveFn, renderer, animationsDisabled, ngZone) {
+function animateLeaveClassRunner(el, tNode, classList, renderer, animationsDisabled, ngZone, resolver) {
     if (animationsDisabled) {
         longestAnimations.delete(el);
-        finalRemoveFn();
+        resolver();
         return;
     }
     cancelAnimationsIfRunning(el, renderer);
@@ -21747,8 +21693,16 @@ function animateLeaveClassRunner(el, tNode, classList, finalRemoveFn, renderer,
             event.stopImmediatePropagation();
             longestAnimations.delete(el);
             clearLeavingNodes(tNode, el);
-            finalRemoveFn();
+            if (Array.isArray(tNode.projection)) {
+                // in the content projection case, the element is not destroyed.
+                // So we need to remove the class at the end so that it isn't left
+                // behind for whenever the item shows up again.
+                for (const item of classList) {
+                    renderer.removeClass(el, item);
+                }
+            }
         }
+        resolver();
     };
     ngZone.runOutsideAngular(() => {
         renderer.listen(el, 'animationend', handleOutAnimationEnd);
@@ -21766,11 +21720,75 @@ function animateLeaveClassRunner(el, tNode, classList, finalRemoveFn, renderer,
             determineLongestAnimation(el, longestAnimations, areAnimationSupported);
             if (!longestAnimations.has(el)) {
                 clearLeavingNodes(tNode, el);
-                finalRemoveFn();
+                resolver();
             }
         });
     });
 }
+/**
+ * Instruction to handle the `(animate.leave)` behavior for event bindings, aka when
+ * a user wants to use a custom animation function rather than a class. It registers
+ * a leave animation function in the LView to be run at right before removal from the
+ * DOM.
+ *
+ * @param value The value bound to `(animate.leave)`, an AnimationFunction.
+ * @returns This function returns itself so that it may be chained.
+ *
+ * @codeGenApi
+ */
+function ɵɵanimateLeaveListener(value) {
+    performanceMarkFeature('NgAnimateLeave');
+    if ((typeof ngServerMode !== 'undefined' && ngServerMode) || !areAnimationSupported) {
+        return ɵɵanimateLeaveListener;
+    }
+    ngDevMode && assertAnimationTypes(value, 'animate.leave');
+    // Even when animations are disabled, we still need to register the element for removal
+    // to ensure proper cleanup and allow developers to handle element removal in tests
+    // So we don't have an early return here.
+    const lView = getLView();
+    const tNode = getCurrentTNode();
+    allLeavingAnimations.add(lView);
+    getLViewLeaveAnimations(lView).push(() => runLeaveAnimationFunction(lView, tNode, value));
+    return ɵɵanimateLeaveListener; // For chaining
+}
+/**
+ * runs leave animations when a custom function is provided
+ */
+function runLeaveAnimationFunction(lView, tNode, value) {
+    const { promise, resolve } = promiseWithResolvers();
+    const nativeElement = getNativeByTNode(tNode, lView);
+    ngDevMode && assertElementNodes(nativeElement, 'animate.leave');
+    const renderer = lView[RENDERER];
+    const animationsDisabled = areAnimationsDisabled(lView);
+    const ngZone = lView[INJECTOR].get(NgZone);
+    const maxAnimationTimeout = lView[INJECTOR].get(MAX_ANIMATION_TIMEOUT);
+    if (animationsDisabled) {
+        resolve();
+    }
+    else {
+        const timeoutId = setTimeout(() => {
+            clearLeavingNodes(tNode, nativeElement);
+            resolve();
+        }, maxAnimationTimeout);
+        const event = {
+            target: nativeElement,
+            animationComplete: () => {
+                clearLeavingNodes(tNode, nativeElement);
+                clearTimeout(timeoutId);
+                resolve();
+            },
+        };
+        trackLeavingNodes(tNode, nativeElement);
+        ngZone.runOutsideAngular(() => {
+            renderer.listen(nativeElement, 'animationend', () => {
+                resolve();
+            }, { once: true });
+        });
+        value.call(lView[CONTEXT], event);
+    }
+    // Ensure cleanup if the LView is destroyed before the animation runs.
+    return promise;
+}
 
 /*!
  * @license
@@ -21821,7 +21839,11 @@ class LiveCollection {
         }
     }
     move(prevIndex, newIdx) {
-        this.attach(newIdx, this.detach(prevIndex));
+        // For move operations, the detach code path is the same one used for removing
+        // DOM nodes, which would trigger `animate.leave` bindings. We need to skip
+        // those animations in the case of a move operation so the moving elements don't
+        // unexpectedly disappear.
+        this.attach(newIdx, this.detach(prevIndex, true /* skipLeaveAnimations */));
     }
 }
 function valuesMatching(liveIdx, liveValue, newIdx, newValue, trackBy) {
@@ -22393,8 +22415,10 @@ class LiveCollectionLContainerImpl extends LiveCollection {
         this.needsIndexUpdate ||= index !== this.length;
         addLViewToLContainer(this.lContainer, lView, index, shouldAddViewToDom(this.templateTNode, dehydratedView));
     }
-    detach(index) {
+    detach(index, skipLeaveAnimations) {
         this.needsIndexUpdate ||= index !== this.length - 1;
+        if (skipLeaveAnimations)
+            setSkipLeaveAnimations(this.lContainer, index);
         return detachExistingView(this.lContainer, index);
     }
     create(index, value) {
@@ -22500,6 +22524,15 @@ function getLContainer(lView, index) {
     ngDevMode && assertLContainer(lContainer);
     return lContainer;
 }
+function setSkipLeaveAnimations(lContainer, index) {
+    if (lContainer.length <= CONTAINER_HEADER_OFFSET)
+        return;
+    const indexInContainer = CONTAINER_HEADER_OFFSET + index;
+    const viewToDetach = lContainer[indexInContainer];
+    if (viewToDetach && viewToDetach[ANIMATIONS]) {
+        viewToDetach[ANIMATIONS].skipLeaveAnimations = true;
+    }
+}
 function detachExistingView(lContainer, index) {
     const existingLView = detachView(lContainer, index);
     ngDevMode && assertLView(existingLView);
@@ -22987,7 +23020,7 @@ function plural(val) {
         return 1;
     return 5;
 }
-var localeEn = ["en", [["a", "p"], ["AM", "PM"], u], [["AM", "PM"], u, u], [["S", "M", "T", "W", "T", "F", "S"], ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"], ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"], ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"]], u, [["J", "F", "M", "A", "M", "J", "J", "A", "S", "O", "N", "D"], ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"], ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"]], u, [["B", "A"], ["BC", "AD"], ["Before Christ", "Anno Domini"]], 0, [6, 0], ["M/d/yy", "MMM d, y", "MMMM d, y", "EEEE, MMMM d, y"], ["h:mm a", "h:mm:ss a", "h:mm:ss a z", "h:mm:ss a zzzz"], ["{1}, {0}", u, "{1} 'at' {0}", u], [".", ",", ";", "%", "+", "-", "E", "×", "‰", "∞", "NaN", ":"], ["#,##0.###", "#,##0%", "¤#,##0.00", "#E0"], "USD", "$", "US Dollar", {}, "ltr", plural];
+var localeEn = ["en", [["a", "p"], ["AM", "PM"]], [["AM", "PM"]], [["S", "M", "T", "W", "T", "F", "S"], ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"], ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"], ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"]], u, [["J", "F", "M", "A", "M", "J", "J", "A", "S", "O", "N", "D"], ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"], ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"]], u, [["B", "A"], ["BC", "AD"], ["Before Christ", "Anno Domini"]], 0, [6, 0], ["M/d/yy", "MMM d, y", "MMMM d, y", "EEEE, MMMM d, y"], ["h:mm a", "h:mm:ss a", "h:mm:ss a z", "h:mm:ss a zzzz"], ["{1}, {0}", u, "{1} 'at' {0}", u], [".", ",", ";", "%", "+", "-", "E", "×", "‰", "∞", "NaN", ":"], ["#,##0.###", "#,##0%", "¤#,##0.00", "#E0"], "USD", "$", "US Dollar", {}, "ltr", plural];
 
 /**
  * This const is used to store the locale data registered with `registerLocaleData`
@@ -23155,6 +23188,7 @@ const ICU_MARKER = {
  */
 var I18nCreateOpCode;
 (function (I18nCreateOpCode) {
+    /* tslint:disable:no-duplicate-enum-values */
     /**
      * Number of bits to shift index so that it can be combined with the `APPEND_EAGERLY` and
      * `COMMENT`.
@@ -23168,6 +23202,7 @@ var I18nCreateOpCode;
      * If set the node should be comment (rather than a text) node.
      */
     I18nCreateOpCode[I18nCreateOpCode["COMMENT"] = 2] = "COMMENT";
+    /* tslint:enable:no-duplicate-enum-values */
 })(I18nCreateOpCode || (I18nCreateOpCode = {}));
 
 /**
@@ -27693,18 +27728,6 @@ function ɵɵExternalStylesFeature(styleUrls) {
     };
 }
 
-/**
- * This feature adds the element registry for delayed element removal when animate.leave
- * is utilized.
- *
- * @codeGenApi
- */
-function ɵɵAnimationsFeature() {
-    return () => {
-        setAnimationElementRemovalRegistry(new ElementRegistry());
-    };
-}
-
 /**
  * Generated next to NgModules to monkey-patch directive and pipe references onto a component's
  * definition, when generating a direct reference in the component file would otherwise create an
@@ -28664,7 +28687,6 @@ const angularCoreEnv = (() => ({
     'ɵɵCopyDefinitionFeature': ɵɵCopyDefinitionFeature,
     'ɵɵInheritDefinitionFeature': ɵɵInheritDefinitionFeature,
     'ɵɵExternalStylesFeature': ɵɵExternalStylesFeature,
-    'ɵɵAnimationsFeature': ɵɵAnimationsFeature,
     'ɵɵnextContext': ɵɵnextContext,
     'ɵɵnamespaceHTML': __namespaceHTML,
     'ɵɵnamespaceMathML': __namespaceMathML,
@@ -29395,7 +29417,6 @@ function compileComponent(type, metadata) {
                     declarations: [],
                     changeDetection: metadata.changeDetection,
                     encapsulation,
-                    interpolation: metadata.interpolation,
                     viewProviders: metadata.viewProviders || null,
                     // We can't inspect whether any of the dependencies are actually directives, because they
                     // get patched on after compilation. That's why in JIT mode we consider that any
@@ -29917,180 +29938,6 @@ const COMPILER_OPTIONS = new InjectionToken(ngDevMode ? 'compilerOptions' : '');
 class CompilerFactory {
 }
 
-class NgZoneChangeDetectionScheduler {
-    zone = inject(NgZone);
-    changeDetectionScheduler = inject(ChangeDetectionScheduler);
-    applicationRef = inject(ApplicationRef);
-    applicationErrorHandler = inject(INTERNAL_APPLICATION_ERROR_HANDLER);
-    _onMicrotaskEmptySubscription;
-    initialize() {
-        if (this._onMicrotaskEmptySubscription) {
-            return;
-        }
-        this._onMicrotaskEmptySubscription = this.zone.onMicrotaskEmpty.subscribe({
-            next: () => {
-                // `onMicroTaskEmpty` can happen _during_ the zoneless scheduler change detection because
-                // zone.run(() => {}) will result in `checkStable` at the end of the `zone.run` closure
-                // and emit `onMicrotaskEmpty` synchronously if run coalsecing is false.
-                if (this.changeDetectionScheduler.runningTick) {
-                    return;
-                }
-                this.zone.run(() => {
-                    try {
-                        this.applicationRef.dirtyFlags |= 1 /* ApplicationRefDirtyFlags.ViewTreeGlobal */;
-                        this.applicationRef._tick();
-                    }
-                    catch (e) {
-                        this.applicationErrorHandler(e);
-                    }
-                });
-            },
-        });
-    }
-    ngOnDestroy() {
-        this._onMicrotaskEmptySubscription?.unsubscribe();
-    }
-    static ɵfac = function NgZoneChangeDetectionScheduler_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || NgZoneChangeDetectionScheduler)(); };
-    static ɵprov = /*@__PURE__*/ __defineInjectable({ token: NgZoneChangeDetectionScheduler, factory: NgZoneChangeDetectionScheduler.ɵfac, providedIn: 'root' });
-}
-(() => { (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgZoneChangeDetectionScheduler, [{
-        type: Injectable,
-        args: [{ providedIn: 'root' }]
-    }], null, null); })();
-/**
- * Internal token used to verify that `provideZoneChangeDetection` is not used
- * with the bootstrapModule API.
- */
-const PROVIDED_NG_ZONE = new InjectionToken(typeof ngDevMode === 'undefined' || ngDevMode ? 'provideZoneChangeDetection token' : '', { factory: () => false });
-function internalProvideZoneChangeDetection({ ngZoneFactory, scheduleInRootZone, }) {
-    ngZoneFactory ??= () => new NgZone({ ...getNgZoneOptions(), scheduleInRootZone });
-    return [
-        { provide: NgZone, useFactory: ngZoneFactory },
-        {
-            provide: ENVIRONMENT_INITIALIZER,
-            multi: true,
-            useFactory: () => {
-                const ngZoneChangeDetectionScheduler = inject(NgZoneChangeDetectionScheduler, {
-                    optional: true,
-                });
-                if ((typeof ngDevMode === 'undefined' || ngDevMode) &&
-                    ngZoneChangeDetectionScheduler === null) {
-                    throw new RuntimeError(402 /* RuntimeErrorCode.MISSING_REQUIRED_INJECTABLE_IN_BOOTSTRAP */, `A required Injectable was not found in the dependency injection tree. ` +
-                        'If you are bootstrapping an NgModule, make sure that the `BrowserModule` is imported.');
-                }
-                return () => ngZoneChangeDetectionScheduler.initialize();
-            },
-        },
-        {
-            provide: ENVIRONMENT_INITIALIZER,
-            multi: true,
-            useFactory: () => {
-                const service = inject(ZoneStablePendingTask);
-                return () => {
-                    service.initialize();
-                };
-            },
-        },
-        {
-            provide: SCHEDULE_IN_ROOT_ZONE,
-            useValue: scheduleInRootZone ?? SCHEDULE_IN_ROOT_ZONE_DEFAULT,
-        },
-    ];
-}
-/**
- * Provides `NgZone`-based change detection for the application bootstrapped using
- * `bootstrapApplication`.
- *
- * `NgZone` is already provided in applications by default. This provider allows you to configure
- * options like `eventCoalescing` in the `NgZone`.
- * This provider is not available for `platformBrowser().bootstrapModule`, which uses
- * `BootstrapOptions` instead.
- *
- * @usageNotes
- * ```ts
- * bootstrapApplication(MyApp, {providers: [
- *   provideZoneChangeDetection({eventCoalescing: true}),
- * ]});
- * ```
- *
- * @publicApi
- * @see {@link /api/platform-browser/bootstrapApplication bootstrapApplication}
- * @see {@link NgZoneOptions}
- */
-function provideZoneChangeDetection(options) {
-    const scheduleInRootZone = options?.scheduleInRootZone;
-    const zoneProviders = internalProvideZoneChangeDetection({
-        ngZoneFactory: () => {
-            const ngZoneOptions = getNgZoneOptions(options);
-            ngZoneOptions.scheduleInRootZone = scheduleInRootZone;
-            if (ngZoneOptions.shouldCoalesceEventChangeDetection) {
-                performanceMarkFeature('NgZone_CoalesceEvent');
-            }
-            return new NgZone(ngZoneOptions);
-        },
-        scheduleInRootZone,
-    });
-    return makeEnvironmentProviders([
-        { provide: PROVIDED_NG_ZONE, useValue: true },
-        { provide: ZONELESS_ENABLED, useValue: false },
-        zoneProviders,
-    ]);
-}
-// Transforms a set of `BootstrapOptions` (supported by the NgModule-based bootstrap APIs) ->
-// `NgZoneOptions` that are recognized by the NgZone constructor. Passing no options will result in
-// a set of default options returned.
-function getNgZoneOptions(options) {
-    return {
-        enableLongStackTrace: typeof ngDevMode === 'undefined' ? false : !!ngDevMode,
-        shouldCoalesceEventChangeDetection: options?.eventCoalescing ?? false,
-        shouldCoalesceRunChangeDetection: options?.runCoalescing ?? false,
-    };
-}
-class ZoneStablePendingTask {
-    subscription = new Subscription();
-    initialized = false;
-    zone = inject(NgZone);
-    pendingTasks = inject(PendingTasksInternal);
-    initialize() {
-        if (this.initialized) {
-            return;
-        }
-        this.initialized = true;
-        let task = null;
-        if (!this.zone.isStable && !this.zone.hasPendingMacrotasks && !this.zone.hasPendingMicrotasks) {
-            task = this.pendingTasks.add();
-        }
-        this.zone.runOutsideAngular(() => {
-            this.subscription.add(this.zone.onStable.subscribe(() => {
-                NgZone.assertNotInAngularZone();
-                // Check whether there are no pending macro/micro tasks in the next tick
-                // to allow for NgZone to update the state.
-                queueMicrotask(() => {
-                    if (task !== null &&
-                        !this.zone.hasPendingMacrotasks &&
-                        !this.zone.hasPendingMicrotasks) {
-                        this.pendingTasks.remove(task);
-                        task = null;
-                    }
-                });
-            }));
-        });
-        this.subscription.add(this.zone.onUnstable.subscribe(() => {
-            NgZone.assertInAngularZone();
-            task ??= this.pendingTasks.add();
-        }));
-    }
-    ngOnDestroy() {
-        this.subscription.unsubscribe();
-    }
-    static ɵfac = function ZoneStablePendingTask_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || ZoneStablePendingTask)(); };
-    static ɵprov = /*@__PURE__*/ __defineInjectable({ token: ZoneStablePendingTask, factory: ZoneStablePendingTask.ɵfac, providedIn: 'root' });
-}
-(() => { (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(ZoneStablePendingTask, [{
-        type: Injectable,
-        args: [{ providedIn: 'root' }]
-    }], null, null); })();
-
 const CONSECUTIVE_MICROTASK_NOTIFICATION_LIMIT = 100;
 let consecutiveMicrotaskNotifications = 0;
 let stackFromLastFewNotifications = [];
@@ -30115,7 +29962,6 @@ class ChangeDetectionSchedulerImpl {
     ngZone = inject(NgZone);
     zonelessEnabled = inject(ZONELESS_ENABLED);
     tracing = inject(TracingService, { optional: true });
-    disableScheduling = inject(ZONELESS_SCHEDULER_DISABLED, { optional: true }) ?? false;
     zoneIsDefined = typeof Zone !== 'undefined' && !!Zone.root.run;
     schedulerTickApplyArgs = [{ data: { '__scheduler_tick__': true } }];
     subscriptions = new Subscription();
@@ -30146,14 +29992,6 @@ class ChangeDetectionSchedulerImpl {
                 this.cleanup();
             }
         }));
-        // 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 &&
-                // NoopNgZone without enabling zoneless means no scheduling whatsoever
-                (this.ngZone instanceof NoopNgZone ||
-                    // The same goes for the lack of Zone without enabling zoneless scheduling
-                    !this.zoneIsDefined);
     }
     notify(source) {
         if (!this.zonelessEnabled && source === 5 /* NotificationSource.Listener */) {
@@ -30167,7 +30005,6 @@ class ChangeDetectionSchedulerImpl {
             // to make listener callbacks work correctly with `OnPush` components.
             return;
         }
-        let force = false;
         switch (source) {
             case 0 /* NotificationSource.MarkAncestorsForTraversal */: {
                 this.appRef.dirtyFlags |= 2 /* ApplicationRefDirtyFlags.ViewTreeTraversal */;
@@ -30186,34 +30023,19 @@ class ChangeDetectionSchedulerImpl {
                 // during CD. In practice this is a no-op since the elements code also calls via a
                 // `markForRefresh()` API which sends `NotificationSource.MarkAncestorsForTraversal` anyway.
                 this.appRef.dirtyFlags |= 2 /* ApplicationRefDirtyFlags.ViewTreeTraversal */;
-                force = true;
                 break;
             }
             case 12 /* NotificationSource.RootEffect */: {
                 this.appRef.dirtyFlags |= 16 /* ApplicationRefDirtyFlags.RootEffects */;
-                // Root effects still force a CD, even if the scheduler is disabled. This ensures that
-                // effects always run, even when triggered from outside the zone when the scheduler is
-                // otherwise disabled.
-                force = true;
                 break;
             }
             case 13 /* NotificationSource.ViewEffect */: {
                 // This is technically a no-op, since view effects will also send a
                 // `MarkAncestorsForTraversal` notification. Still, we set this for logical consistency.
                 this.appRef.dirtyFlags |= 2 /* ApplicationRefDirtyFlags.ViewTreeTraversal */;
-                // View effects still force a CD, even if the scheduler is disabled. This ensures that
-                // effects always run, even when triggered from outside the zone when the scheduler is
-                // otherwise disabled.
-                force = true;
                 break;
             }
             case 11 /* NotificationSource.PendingTaskRemoved */: {
-                // Removing a pending task via the public API forces a scheduled tick, ensuring that
-                // stability is async and delayed until there was at least an opportunity to run
-                // application synchronization. This prevents some footguns when working with the
-                // public API for pending tasks where developers attempt to update application state
-                // immediately after removing the last task.
-                force = true;
                 break;
             }
             case 9 /* NotificationSource.ViewDetachedFromDOM */:
@@ -30231,7 +30053,7 @@ class ChangeDetectionSchedulerImpl {
         // notification so that the resulting CD run can be attributed to the
         // context which produced the notification.
         this.appRef.tracingSnapshot = this.tracing?.snapshot(this.appRef.tracingSnapshot) ?? null;
-        if (!this.shouldScheduleTick(force)) {
+        if (!this.shouldScheduleTick()) {
             return;
         }
         if (typeof ngDevMode === 'undefined' || ngDevMode) {
@@ -30254,8 +30076,8 @@ class ChangeDetectionSchedulerImpl {
             this.cancelScheduledCallback = this.ngZone.runOutsideAngular(() => scheduleCallback(() => this.tick()));
         }
     }
-    shouldScheduleTick(force) {
-        if ((this.disableScheduling && !force) || this.appRef.destroyed) {
+    shouldScheduleTick() {
+        if (this.appRef.destroyed) {
             return false;
         }
         // already scheduled or running
@@ -30406,15 +30228,19 @@ function provideZonelessChangeDetection() {
         console.warn(message);
     }
     return makeEnvironmentProviders([
-        { provide: ChangeDetectionScheduler, useExisting: ChangeDetectionSchedulerImpl },
-        { provide: NgZone, useClass: NoopNgZone },
-        { provide: ZONELESS_ENABLED, useValue: true },
-        { provide: SCHEDULE_IN_ROOT_ZONE, useValue: false },
+        ...provideZonelessChangeDetectionInternal(),
         typeof ngDevMode === 'undefined' || ngDevMode
             ? [{ provide: PROVIDED_ZONELESS, useValue: true }]
             : [],
     ]);
 }
+function provideZonelessChangeDetectionInternal() {
+    return [
+        { provide: ChangeDetectionScheduler, useExisting: ChangeDetectionSchedulerImpl },
+        { provide: NgZone, useClass: NoopNgZone },
+        { provide: ZONELESS_ENABLED, useValue: true },
+    ];
+}
 
 /// <reference path="../../../goog.d.ts" />
 /**
@@ -31185,5 +31011,5 @@ function getDebugNode(nativeNode) {
     return null;
 }
 
-export { AFTER_RENDER_PHASES, ANIMATIONS_DISABLED, ANIMATION_MODULE_TYPE, APP_BOOTSTRAP_LISTENER, APP_ID, APP_INITIALIZER, AcxChangeDetectionStrategy, AcxViewEncapsulation, AfterRenderImpl, AfterRenderManager, AfterRenderSequence, ApplicationInitStatus, ApplicationRef, Attribute, COMPILER_OPTIONS, CONTAINERS, CSP_NONCE, CUSTOM_ELEMENTS_SCHEMA, ChangeDetectionSchedulerImpl, ChangeDetectionStrategy, Compiler, CompilerFactory, Component, ComponentFactory, ComponentFactory$1, ComponentFactoryResolver$1 as ComponentFactoryResolver, ComponentRef$1 as ComponentRef, ComponentRef as ComponentRef$1, Console, DEFAULT_CURRENCY_CODE, DEFAULT_LOCALE_ID, DEFER_BLOCK_CONFIG, DEFER_BLOCK_DEPENDENCY_INTERCEPTOR, DEFER_BLOCK_ID, DEFER_BLOCK_SSR_ID_ATTRIBUTE, DEFER_BLOCK_STATE$1 as DEFER_BLOCK_STATE, DEFER_BLOCK_STATE as DEFER_BLOCK_STATE$1, DEFER_HYDRATE_TRIGGERS, DEFER_PARENT_BLOCK_ID, DEHYDRATED_BLOCK_REGISTRY, DISCONNECTED_NODES, DebugElement, DebugEventListener, DebugNode, DeferBlockBehavior, DeferBlockState, DehydratedBlockRegistry, Directive, ELEMENT_CONTAINERS, EVENT_REPLAY_ENABLED_DEFAULT, ElementRef, ElementRegistry, EnvironmentNgModuleRefAdapter, Framework, Host, HostBinding, HostListener, HydrationStatus, I18N_DATA, IMAGE_CONFIG, IMAGE_CONFIG_DEFAULTS, IS_ENABLED_BLOCKING_INITIAL_NAVIGATION, IS_EVENT_REPLAY_ENABLED, IS_HYDRATION_DOM_REUSE_ENABLED, IS_I18N_HYDRATION_ENABLED, IS_INCREMENTAL_HYDRATION_ENABLED, Inject, Injectable, Input, JSACTION_BLOCK_ELEMENT_MAP, JSACTION_EVENT_CONTRACT, LContext, LOCALE_ID, LocaleDataIndex, MAX_ANIMATION_TIMEOUT, MULTIPLIER, MissingTranslationStrategy, ModuleWithComponentFactories, NGH_ATTR_NAME, NGH_DATA_KEY, NGH_DEFER_BLOCKS_KEY, NODES, NOOP_AFTER_RENDER_REF, NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR, NO_CHANGE, NO_ERRORS_SCHEMA, NUM_ROOT_NODES, NgModule, NgModuleFactory, NgModuleFactory$1, NgModuleRef, NgModuleRef$1, Optional, Output, PLATFORM_ID, PLATFORM_INITIALIZER, PRESERVE_HOST_CONTENT, PROVIDED_NG_ZONE, Pipe, QueryList, ReflectionCapabilities, Renderer2, RendererFactory2, RendererStyleFlags2, SKIP_HYDRATION_ATTR_NAME, SSR_CONTENT_INTEGRITY_MARKER, Sanitizer, SecurityContext, Self, SimpleChange, SkipSelf, TEMPLATES, TEMPLATE_ID, TESTABILITY, TESTABILITY_GETTER, TRANSLATIONS, TRANSLATIONS_FORMAT, TemplateRef, Testability, TestabilityRegistry, TimerScheduler, TracingAction, TracingService, TransferState, Type, UseExhaustiveCheckNoChanges, ViewContainerRef, ViewEncapsulation, ViewRef, _sanitizeHtml, _sanitizeUrl, afterEveryRender, afterNextRender, allowSanitizationBypassAndThrow, angularCoreEnv, appendDeferBlocksToJSActionMap, asNativeElements, assertComponentDef, assertStandaloneComponentType, bypassSanitizationTrustHtml, bypassSanitizationTrustResourceUrl, bypassSanitizationTrustScript, bypassSanitizationTrustStyle, bypassSanitizationTrustUrl, calcPathForNode, checkNoChangesInternal, cleanupDehydratedViews, clearResolutionOfComponentResourcesQueue, collectNativeNodes, collectNativeNodesInLContainer, compileComponent, compileDirective, compileNgModule, compileNgModuleDefs, compilePipe, convertHydrateTriggersToJsAction, countBlocksSkippedByHydration, createEnvironmentInjector, createMultiResultQuerySignalFn, createNgModule, createNgModuleRef, createNgModuleRefWithProviders, createSingleResultOptionalQuerySignalFn, createSingleResultRequiredQuerySignalFn, depsTracker, devModeEqual, enableApplyRootElementTransformImpl, enableClaimDehydratedIcuCaseImpl, enableFindMatchingDehydratedViewImpl, enableLocateOrCreateContainerAnchorImpl, enableLocateOrCreateContainerRefImpl, enableLocateOrCreateElementContainerNodeImpl, enableLocateOrCreateElementNodeImpl, enableLocateOrCreateI18nNodeImpl, enableLocateOrCreateTextNodeImpl, enablePrepareI18nBlockForHydrationImpl, enableProfiling, enableRetrieveDeferBlockDataImpl, enableRetrieveHydrationInfoImpl, enableStashEventListenerImpl, findLocaleData, flushModuleScopingQueueAsMuchAsPossible, gatherDeferBlocksCommentNodes, generateStandaloneInDeclarationsError, getAsyncClassMetadataFn, getCompilerFacade, getDebugNode, getDeferBlocks$1 as getDeferBlocks, getDirectives, getDocument, getHostElement, getLContext, getLDeferBlockDetails, getLNodeForHydration, getLocaleCurrencyCode, getLocalePluralCase, getNgZoneOptions, getOrComputeI18nChildren, getRegisteredNgModuleType, getSanitizationBypassType, getTDeferBlockDetails, getTransferState, inferTagNameFromDefinition, inputBinding, internalProvideZoneChangeDetection, invokeListeners, isBoundToModule, isComponentDefPendingResolution, isComponentResourceResolutionQueueEmpty, isDeferBlock, isDetachedByI18n, isDisconnectedNode, isI18nHydrationEnabled, isI18nHydrationSupportEnabled, isInSkipHydrationBlock, isIncrementalHydrationEnabled, isJsObject, isLetDeclaration, isListLikeIterable, isNgModule, isPromise, isSubscribable, isTNodeShape, isViewDirty, iterateListLike, makePropDecorator, makeStateKey, markForRefresh, noSideEffects, optionsReducer, outputBinding, patchComponentDefWithScope, performanceMarkFeature, processAndInitTriggers, processBlockData, processTextNodeBeforeSerialization, profiler, provideAppInitializer, provideNgReflectAttributes, provideZoneChangeDetection, provideZonelessChangeDetection, publishDefaultGlobalUtils, publishExternalGlobalUtil, publishSignalConfiguration, readHydrationInfo, readPatchedLView, registerLocaleData, registerNgModuleType, remove, removeListeners, renderDeferBlockState, resetCompiledComponents, resetJitOptions, resolveComponentResources, restoreComponentResolutionQueue, setAllowDuplicateNgModuleIdsForTest, setClassMetadata, setClassMetadataAsync, setDocument, setIsI18nHydrationSupportEnabled, setJSActionAttributes, setJitOptions, setLocaleId, setStashFn, setTestabilityGetter, sharedMapFunction, sharedStashFunction, transitiveScopesFor, triggerHydrationFromBlockName, triggerResourceLoading, trySerializeI18nBlock, twoWayBinding, unregisterAllLocaleData, unsupportedProjectionOfDomNodes, unwrapSafeValue, validateMatchingNode, validateNodeExists, verifySsrContentsIntegrity, ɵgetUnknownElementStrictMode, ɵgetUnknownPropertyStrictMode, ɵsetClassDebugInfo, ɵsetUnknownElementStrictMode, ɵsetUnknownPropertyStrictMode, ɵɵAnimationsFeature, ɵɵCopyDefinitionFeature, ɵɵExternalStylesFeature, ɵɵHostDirectivesFeature, ɵɵInheritDefinitionFeature, ɵɵNgOnChangesFeature, ɵɵProvidersFeature, ɵɵadvance, ɵɵanimateEnter, ɵɵanimateEnterListener, ɵɵanimateLeave, ɵɵanimateLeaveListener, ɵɵariaProperty, ɵɵattachSourceLocations, ɵɵattribute, ɵɵclassMap, ɵɵclassProp, ɵɵcomponentInstance, ɵɵconditional, ɵɵconditionalBranchCreate, ɵɵconditionalCreate, ɵɵcontentQuery, ɵɵcontentQuerySignal, ɵɵdeclareLet, ɵɵdefer, ɵɵdeferEnableTimerScheduling, ɵɵdeferHydrateNever, ɵɵdeferHydrateOnHover, ɵɵdeferHydrateOnIdle, ɵɵdeferHydrateOnImmediate, ɵɵdeferHydrateOnInteraction, ɵɵdeferHydrateOnTimer, ɵɵdeferHydrateOnViewport, ɵɵdeferHydrateWhen, ɵɵdeferOnHover, ɵɵdeferOnIdle, ɵɵdeferOnImmediate, ɵɵdeferOnInteraction, ɵɵdeferOnTimer, ɵɵdeferOnViewport, ɵɵdeferPrefetchOnHover, ɵɵdeferPrefetchOnIdle, ɵɵdeferPrefetchOnImmediate, ɵɵdeferPrefetchOnInteraction, ɵɵdeferPrefetchOnTimer, ɵɵdeferPrefetchOnViewport, ɵɵdeferPrefetchWhen, ɵɵdeferWhen, ɵɵdefineComponent, ɵɵdefineDirective, ɵɵdefineNgModule, ɵɵdefinePipe, ɵɵdirectiveInject, ɵɵdomElement, ɵɵdomElementContainer, ɵɵdomElementContainerEnd, ɵɵdomElementContainerStart, ɵɵdomElementEnd, ɵɵdomElementStart, ɵɵdomListener, ɵɵdomProperty, ɵɵdomTemplate, ɵɵelement, ɵɵelementContainer, ɵɵelementContainerEnd, ɵɵelementContainerStart, ɵɵelementEnd, ɵɵelementStart, ɵɵgetComponentDepsFactory, ɵɵgetCurrentView, ɵɵgetInheritedFactory, ɵɵgetReplaceMetadataURL, ɵɵi18n, ɵɵi18nApply, ɵɵi18nAttributes, ɵɵi18nEnd, ɵɵi18nExp, ɵɵi18nPostprocess, ɵɵi18nStart, ɵɵinjectAttribute, ɵɵinterpolate, ɵɵinterpolate1, ɵɵinterpolate2, ɵɵinterpolate3, ɵɵinterpolate4, ɵɵinterpolate5, ɵɵinterpolate6, ɵɵinterpolate7, ɵɵinterpolate8, ɵɵinterpolateV, ɵɵinvalidFactory, ɵɵlistener, ɵɵloadQuery, ɵɵnextContext, ɵɵpipe, ɵɵpipeBind1, ɵɵpipeBind2, ɵɵpipeBind3, ɵɵpipeBind4, ɵɵpipeBindV, ɵɵprojection, ɵɵprojectionDef, ɵɵproperty, ɵɵpureFunction0, ɵɵpureFunction1, ɵɵpureFunction2, ɵɵpureFunction3, ɵɵpureFunction4, ɵɵpureFunction5, ɵɵpureFunction6, ɵɵpureFunction7, ɵɵpureFunction8, ɵɵpureFunctionV, ɵɵqueryAdvance, ɵɵqueryRefresh, ɵɵreadContextLet, ɵɵreference, ɵɵrepeater, ɵɵrepeaterCreate, ɵɵrepeaterTrackByIdentity, ɵɵrepeaterTrackByIndex, ɵɵreplaceMetadata, ɵɵresolveBody, ɵɵresolveDocument, ɵɵresolveWindow, ɵɵsanitizeHtml, ɵɵsanitizeResourceUrl, ɵɵsanitizeScript, ɵɵsanitizeStyle, ɵɵsanitizeUrl, ɵɵsanitizeUrlOrResourceUrl, ɵɵsetComponentScope, ɵɵsetNgModuleScope, ɵɵstoreLet, ɵɵstyleMap, ɵɵstyleProp, ɵɵsyntheticHostListener, ɵɵsyntheticHostProperty, ɵɵtemplate, ɵɵtemplateRefExtractor, ɵɵtext, ɵɵtextInterpolate, ɵɵtextInterpolate1, ɵɵtextInterpolate2, ɵɵtextInterpolate3, ɵɵtextInterpolate4, ɵɵtextInterpolate5, ɵɵtextInterpolate6, ɵɵtextInterpolate7, ɵɵtextInterpolate8, ɵɵtextInterpolateV, ɵɵtrustConstantHtml, ɵɵtrustConstantResourceUrl, ɵɵtwoWayBindingSet, ɵɵtwoWayListener, ɵɵtwoWayProperty, ɵɵvalidateIframeAttribute, ɵɵviewQuery, ɵɵviewQuerySignal };
+export { AFTER_RENDER_PHASES, ANIMATIONS_DISABLED, ANIMATION_MODULE_TYPE, APP_BOOTSTRAP_LISTENER, APP_ID, APP_INITIALIZER, AcxChangeDetectionStrategy, AcxViewEncapsulation, AfterRenderImpl, AfterRenderManager, AfterRenderSequence, ApplicationInitStatus, ApplicationRef, Attribute, COMPILER_OPTIONS, CONTAINERS, CSP_NONCE, CUSTOM_ELEMENTS_SCHEMA, ChangeDetectionSchedulerImpl, ChangeDetectionStrategy, Compiler, CompilerFactory, Component, ComponentFactory, ComponentFactory$1, ComponentFactoryResolver$1 as ComponentFactoryResolver, ComponentRef$1 as ComponentRef, ComponentRef as ComponentRef$1, Console, DEFAULT_CURRENCY_CODE, DEFAULT_LOCALE_ID, DEFER_BLOCK_CONFIG, DEFER_BLOCK_DEPENDENCY_INTERCEPTOR, DEFER_BLOCK_ID, DEFER_BLOCK_SSR_ID_ATTRIBUTE, DEFER_BLOCK_STATE$1 as DEFER_BLOCK_STATE, DEFER_BLOCK_STATE as DEFER_BLOCK_STATE$1, DEFER_HYDRATE_TRIGGERS, DEFER_PARENT_BLOCK_ID, DEHYDRATED_BLOCK_REGISTRY, DISCONNECTED_NODES, DebugElement, DebugEventListener, DebugNode, DeferBlockBehavior, DeferBlockState, DehydratedBlockRegistry, Directive, ELEMENT_CONTAINERS, EVENT_REPLAY_ENABLED_DEFAULT, ElementRef, EnvironmentNgModuleRefAdapter, Framework, Host, HostBinding, HostListener, HydrationStatus, I18N_DATA, IMAGE_CONFIG, IMAGE_CONFIG_DEFAULTS, IS_ENABLED_BLOCKING_INITIAL_NAVIGATION, IS_EVENT_REPLAY_ENABLED, IS_HYDRATION_DOM_REUSE_ENABLED, IS_I18N_HYDRATION_ENABLED, IS_INCREMENTAL_HYDRATION_ENABLED, Inject, Injectable, Input, JSACTION_BLOCK_ELEMENT_MAP, JSACTION_EVENT_CONTRACT, LContext, LOCALE_ID, LocaleDataIndex, MAX_ANIMATION_TIMEOUT, MULTIPLIER, MissingTranslationStrategy, ModuleWithComponentFactories, NGH_ATTR_NAME, NGH_DATA_KEY, NGH_DEFER_BLOCKS_KEY, NODES, NOOP_AFTER_RENDER_REF, NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR, NO_CHANGE, NO_ERRORS_SCHEMA, NUM_ROOT_NODES, NgModule, NgModuleFactory, NgModuleFactory$1, NgModuleRef, NgModuleRef$1, Optional, Output, PLATFORM_ID, PLATFORM_INITIALIZER, PRESERVE_HOST_CONTENT, Pipe, QueryList, ReflectionCapabilities, Renderer2, RendererFactory2, RendererStyleFlags2, SKIP_HYDRATION_ATTR_NAME, SSR_CONTENT_INTEGRITY_MARKER, Sanitizer, SecurityContext, Self, SimpleChange, SkipSelf, TEMPLATES, TEMPLATE_ID, TESTABILITY, TESTABILITY_GETTER, TRANSLATIONS, TRANSLATIONS_FORMAT, TemplateRef, Testability, TestabilityRegistry, TimerScheduler, TracingAction, TracingService, TransferState, Type, UseExhaustiveCheckNoChanges, ViewContainerRef, ViewEncapsulation, ViewRef, _sanitizeHtml, _sanitizeUrl, afterEveryRender, afterNextRender, allLeavingAnimations, allowSanitizationBypassAndThrow, angularCoreEnv, appendDeferBlocksToJSActionMap, asNativeElements, assertComponentDef, assertStandaloneComponentType, bypassSanitizationTrustHtml, bypassSanitizationTrustResourceUrl, bypassSanitizationTrustScript, bypassSanitizationTrustStyle, bypassSanitizationTrustUrl, calcPathForNode, checkNoChangesInternal, cleanupDehydratedViews, clearResolutionOfComponentResourcesQueue, collectNativeNodes, collectNativeNodesInLContainer, compileComponent, compileDirective, compileNgModule, compileNgModuleDefs, compilePipe, convertHydrateTriggersToJsAction, countBlocksSkippedByHydration, createEnvironmentInjector, createMultiResultQuerySignalFn, createNgModule, createNgModuleRef, createNgModuleRefWithProviders, createSingleResultOptionalQuerySignalFn, createSingleResultRequiredQuerySignalFn, depsTracker, devModeEqual, enableApplyRootElementTransformImpl, enableClaimDehydratedIcuCaseImpl, enableFindMatchingDehydratedViewImpl, enableLocateOrCreateContainerAnchorImpl, enableLocateOrCreateContainerRefImpl, enableLocateOrCreateElementContainerNodeImpl, enableLocateOrCreateElementNodeImpl, enableLocateOrCreateI18nNodeImpl, enableLocateOrCreateTextNodeImpl, enablePrepareI18nBlockForHydrationImpl, enableProfiling, enableRetrieveDeferBlockDataImpl, enableRetrieveHydrationInfoImpl, enableStashEventListenerImpl, findLocaleData, flushModuleScopingQueueAsMuchAsPossible, gatherDeferBlocksCommentNodes, generateStandaloneInDeclarationsError, getAsyncClassMetadataFn, getCompilerFacade, getDebugNode, getDeferBlocks$1 as getDeferBlocks, getDirectives, getDocument, getHostElement, getLContext, getLDeferBlockDetails, getLNodeForHydration, getLocaleCurrencyCode, getLocalePluralCase, getOrComputeI18nChildren, getRegisteredNgModuleType, getSanitizationBypassType, getTDeferBlockDetails, getTransferState, inferTagNameFromDefinition, inputBinding, invokeListeners, isBoundToModule, isComponentDefPendingResolution, isComponentResourceResolutionQueueEmpty, isDeferBlock, isDetachedByI18n, isDisconnectedNode, isI18nHydrationEnabled, isI18nHydrationSupportEnabled, isInSkipHydrationBlock, isIncrementalHydrationEnabled, isJsObject, isLetDeclaration, isListLikeIterable, isNgModule, isPromise, isSubscribable, isTNodeShape, isViewDirty, iterateListLike, makePropDecorator, makeStateKey, markForRefresh, noSideEffects, optionsReducer, outputBinding, patchComponentDefWithScope, performanceMarkFeature, processAndInitTriggers, processBlockData, processTextNodeBeforeSerialization, profiler, provideAppInitializer, provideNgReflectAttributes, provideZonelessChangeDetection, provideZonelessChangeDetectionInternal, publishDefaultGlobalUtils, publishExternalGlobalUtil, publishSignalConfiguration, readHydrationInfo, readPatchedLView, registerLocaleData, registerNgModuleType, remove, removeListeners, renderDeferBlockState, resetCompiledComponents, resetJitOptions, resolveComponentResources, restoreComponentResolutionQueue, setAllowDuplicateNgModuleIdsForTest, setClassMetadata, setClassMetadataAsync, setDocument, setIsI18nHydrationSupportEnabled, setJSActionAttributes, setJitOptions, setLocaleId, setStashFn, setTestabilityGetter, sharedMapFunction, sharedStashFunction, transitiveScopesFor, triggerHydrationFromBlockName, triggerResourceLoading, trySerializeI18nBlock, twoWayBinding, unregisterAllLocaleData, unsupportedProjectionOfDomNodes, unwrapSafeValue, validateMatchingNode, validateNodeExists, verifySsrContentsIntegrity, ɵgetUnknownElementStrictMode, ɵgetUnknownPropertyStrictMode, ɵsetClassDebugInfo, ɵsetUnknownElementStrictMode, ɵsetUnknownPropertyStrictMode, ɵɵCopyDefinitionFeature, ɵɵExternalStylesFeature, ɵɵHostDirectivesFeature, ɵɵInheritDefinitionFeature, ɵɵNgOnChangesFeature, ɵɵProvidersFeature, ɵɵadvance, ɵɵanimateEnter, ɵɵanimateEnterListener, ɵɵanimateLeave, ɵɵanimateLeaveListener, ɵɵariaProperty, ɵɵattachSourceLocations, ɵɵattribute, ɵɵclassMap, ɵɵclassProp, ɵɵcomponentInstance, ɵɵconditional, ɵɵconditionalBranchCreate, ɵɵconditionalCreate, ɵɵcontentQuery, ɵɵcontentQuerySignal, ɵɵdeclareLet, ɵɵdefer, ɵɵdeferEnableTimerScheduling, ɵɵdeferHydrateNever, ɵɵdeferHydrateOnHover, ɵɵdeferHydrateOnIdle, ɵɵdeferHydrateOnImmediate, ɵɵdeferHydrateOnInteraction, ɵɵdeferHydrateOnTimer, ɵɵdeferHydrateOnViewport, ɵɵdeferHydrateWhen, ɵɵdeferOnHover, ɵɵdeferOnIdle, ɵɵdeferOnImmediate, ɵɵdeferOnInteraction, ɵɵdeferOnTimer, ɵɵdeferOnViewport, ɵɵdeferPrefetchOnHover, ɵɵdeferPrefetchOnIdle, ɵɵdeferPrefetchOnImmediate, ɵɵdeferPrefetchOnInteraction, ɵɵdeferPrefetchOnTimer, ɵɵdeferPrefetchOnViewport, ɵɵdeferPrefetchWhen, ɵɵdeferWhen, ɵɵdefineComponent, ɵɵdefineDirective, ɵɵdefineNgModule, ɵɵdefinePipe, ɵɵdirectiveInject, ɵɵdomElement, ɵɵdomElementContainer, ɵɵdomElementContainerEnd, ɵɵdomElementContainerStart, ɵɵdomElementEnd, ɵɵdomElementStart, ɵɵdomListener, ɵɵdomProperty, ɵɵdomTemplate, ɵɵelement, ɵɵelementContainer, ɵɵelementContainerEnd, ɵɵelementContainerStart, ɵɵelementEnd, ɵɵelementStart, ɵɵgetComponentDepsFactory, ɵɵgetCurrentView, ɵɵgetInheritedFactory, ɵɵgetReplaceMetadataURL, ɵɵi18n, ɵɵi18nApply, ɵɵi18nAttributes, ɵɵi18nEnd, ɵɵi18nExp, ɵɵi18nPostprocess, ɵɵi18nStart, ɵɵinjectAttribute, ɵɵinterpolate, ɵɵinterpolate1, ɵɵinterpolate2, ɵɵinterpolate3, ɵɵinterpolate4, ɵɵinterpolate5, ɵɵinterpolate6, ɵɵinterpolate7, ɵɵinterpolate8, ɵɵinterpolateV, ɵɵinvalidFactory, ɵɵlistener, ɵɵloadQuery, ɵɵnextContext, ɵɵpipe, ɵɵpipeBind1, ɵɵpipeBind2, ɵɵpipeBind3, ɵɵpipeBind4, ɵɵpipeBindV, ɵɵprojection, ɵɵprojectionDef, ɵɵproperty, ɵɵpureFunction0, ɵɵpureFunction1, ɵɵpureFunction2, ɵɵpureFunction3, ɵɵpureFunction4, ɵɵpureFunction5, ɵɵpureFunction6, ɵɵpureFunction7, ɵɵpureFunction8, ɵɵpureFunctionV, ɵɵqueryAdvance, ɵɵqueryRefresh, ɵɵreadContextLet, ɵɵreference, ɵɵrepeater, ɵɵrepeaterCreate, ɵɵrepeaterTrackByIdentity, ɵɵrepeaterTrackByIndex, ɵɵreplaceMetadata, ɵɵresolveBody, ɵɵresolveDocument, ɵɵresolveWindow, ɵɵsanitizeHtml, ɵɵsanitizeResourceUrl, ɵɵsanitizeScript, ɵɵsanitizeStyle, ɵɵsanitizeUrl, ɵɵsanitizeUrlOrResourceUrl, ɵɵsetComponentScope, ɵɵsetNgModuleScope, ɵɵstoreLet, ɵɵstyleMap, ɵɵstyleProp, ɵɵsyntheticHostListener, ɵɵsyntheticHostProperty, ɵɵtemplate, ɵɵtemplateRefExtractor, ɵɵtext, ɵɵtextInterpolate, ɵɵtextInterpolate1, ɵɵtextInterpolate2, ɵɵtextInterpolate3, ɵɵtextInterpolate4, ɵɵtextInterpolate5, ɵɵtextInterpolate6, ɵɵtextInterpolate7, ɵɵtextInterpolate8, ɵɵtextInterpolateV, ɵɵtrustConstantHtml, ɵɵtrustConstantResourceUrl, ɵɵtwoWayBindingSet, ɵɵtwoWayListener, ɵɵtwoWayProperty, ɵɵvalidateIframeAttribute, ɵɵviewQuery, ɵɵviewQuerySignal };
 //# sourceMappingURL=debug_node.mjs.map