@angular/core 18.0.0-next.1 → 18.0.0-next.3

package/fesm2022/core.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v18.0.0-next.1
+ * @license Angular v18.0.0-next.3
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -4152,16 +4152,6 @@ const profiler = function (event, instance, hookOrListener) {
 const SVG_NAMESPACE = 'svg';
 const MATH_ML_NAMESPACE = 'math';
 
-// TODO(atscott): Remove prior to v18 release. Keeping this around in case anyone internally needs
-// to opt out temporarily.
-let _ensureDirtyViewsAreAlwaysReachable = true;
-function getEnsureDirtyViewsAreAlwaysReachable() {
-    return _ensureDirtyViewsAreAlwaysReachable;
-}
-function setEnsureDirtyViewsAreAlwaysReachable(v) {
-    _ensureDirtyViewsAreAlwaysReachable = v;
-}
-
 /**
  * For efficiency reasons we often put several different data types (`RNode`, `LView`, `LContainer`)
  * in same location in `LView`. This is because we don't want to pre-allocate space for it
@@ -4329,21 +4319,12 @@ function requiresRefreshOrTraversal(lView) {
  */
 function updateAncestorTraversalFlagsOnAttach(lView) {
     lView[ENVIRONMENT].changeDetectionScheduler?.notify(1 /* NotificationType.AfterRenderHooks */);
-    // TODO(atscott): Simplify if...else cases once getEnsureDirtyViewsAreAlwaysReachable is always
-    // `true`. When we attach a view that's marked `Dirty`, we should ensure that it is reached during
-    // the next CD traversal so we add the `RefreshView` flag and mark ancestors accordingly.
+    if (lView[FLAGS] & 64 /* LViewFlags.Dirty */) {
+        lView[FLAGS] |= 1024 /* LViewFlags.RefreshView */;
+    }
     if (requiresRefreshOrTraversal(lView)) {
         markAncestorsForTraversal(lView);
     }
-    else if (lView[FLAGS] & 64 /* LViewFlags.Dirty */) {
-        if (getEnsureDirtyViewsAreAlwaysReachable()) {
-            lView[FLAGS] |= 1024 /* LViewFlags.RefreshView */;
-            markAncestorsForTraversal(lView);
-        }
-        else {
-            lView[ENVIRONMENT].changeDetectionScheduler?.notify();
-        }
-    }
 }
 /**
  * Ensures views above the given `lView` are traversed during change detection even when they are
@@ -6677,25 +6658,47 @@ function getOutputDestroyRef(ref) {
 }
 
 /**
- * The `output` function allows declaration of outputs in directives and
- * components.
+ * The `output` function allows declaration of Angular outputs in
+ * directives and components.
+ *
+ * You can use outputs to emit values to parent directives and component.
+ * Parents can subscribe to changes via:
  *
- * Initializes an output that can emit values to consumers of your
- * directive/component.
+ * - template event bindings. For example, `(myOutput)="doSomething($event)"`
+ * - programmatic subscription by using `OutputRef#subscribe`.
  *
  * @usageNotes
- * Initialize an output in your directive by declaring a
- * class field and initializing it with the `output()` function.
+ *
+ * To use `output()`, import the function from `@angular/core`.
+ *
+ * ```
+ * import {output} from '@angular/core`;
+ * ```
+ *
+ * Inside your component, introduce a new class member and initialize
+ * it with a call to `output`.
  *
  * ```ts
- * @Directive({..})
+ * @Directive({
+ *   ...
+ * })
  * export class MyDir {
- *   nameChange = output<string>();     // OutputEmitterRef<string>
- *   onClick = output();                // OutputEmitterRef<void>
+ *   nameChange = output<string>();    // OutputEmitterRef<string>
+ *   onClick    = output();            // OutputEmitterRef<void>
+ * }
+ * ```
+ *
+ * You can emit values to consumers of your directive, by using
+ * the `emit` method from `OutputEmitterRef`.
+ *
+ * ```ts
+ * updateName(newName: string): void {
+ *   this.nameChange.emit(newName);
  * }
  * ```
  *
  * @developerPreview
+ * @initializerApiFunction {"showTypesInSignaturePreview": true}
  */
 function output(opts) {
     ngDevMode && assertInInjectionContext(output);
@@ -6711,29 +6714,52 @@ function inputRequiredFunction(opts) {
     return createInputSignal(REQUIRED_UNSET_VALUE, opts);
 }
 /**
- * The `input` function allows declaration of inputs in directives and
- * components.
+ * The `input` function allows declaration of Angular inputs in directives
+ * and components.
+ *
+ * There are two variants of inputs that can be declared:
+ *
+ *   1. **Optional inputs** with an initial value.
+ *   2. **Required inputs** that consumers need to set.
  *
- * Initializes an input with an initial value. If no explicit value
- * is specified, Angular will use `undefined`.
+ * By default, the `input` function will declare optional inputs that
+ * always have an initial value. Required inputs can be declared
+ * using the `input.required()` function.
  *
- * Consider using `input.required` for inputs that don't need an
- * initial value.
+ * Inputs are signals. The values of an input are exposed as a `Signal`.
+ * The signal always holds the latest value of the input that is bound
+ * from the parent.
  *
  * @usageNotes
- * Initialize an input in your directive or component by declaring a
- * class field and initializing it with the `input()` function.
+ * To use signal-based inputs, import `input` from `@angular/core`.
+ *
+ * ```
+ * import {input} from '@angular/core`;
+ * ```
+ *
+ * Inside your component, introduce a new class member and initialize
+ * it with a call to `input` or `input.required`.
  *
  * ```ts
- * @Directive({..})
- * export class MyDir {
- *   firstName = input<string>();            // string|undefined
- *   lastName = input.required<string>();    // string
- *   age = input(0);                         // number
+ * @Component({
+ *   ...
+ * })
+ * export class UserProfileComponent {
+ *   firstName = input<string>();             // Signal<string|undefined>
+ *   lastName  = input.required<string>();    // Signal<string>
+ *   age       = input(0)                     // Signal<number>
  * }
  * ```
  *
+ * Inside your component template, you can display values of the inputs
+ * by calling the signal.
+ *
+ * ```html
+ * <span>{{firstName()}}</span>
+ * ```
+ *
  * @developerPreview
+ * @initializerApiFunction
  */
 const input = (() => {
     // Note: This may be considered a side-effect, but nothing will depend on
@@ -7938,7 +7964,7 @@ function getDocument() {
 }
 
 /**
- * A [DI token](guide/glossary#di-token "DI token definition") representing a string ID, used
+ * A DI token representing a string ID, used
  * primarily for prefixing application attributes and CSS styles when
  * {@link ViewEncapsulation#Emulated} is being used.
  *
@@ -7987,7 +8013,7 @@ const PLATFORM_ID = new InjectionToken(ngDevMode ? 'Platform ID' : '', {
     factory: () => 'unknown', // set a default platform name, when none set explicitly
 });
 /**
- * A [DI token](guide/glossary#di-token "DI token definition") that indicates the root directory of
+ * A DI token that indicates the root directory of
  * the application
  * @publicApi
  * @deprecated
@@ -8201,6 +8227,7 @@ const NUM_ROOT_NODES = 'r';
 const TEMPLATE_ID = 'i'; // as it's also an "id"
 const NODES = 'n';
 const DISCONNECTED_NODES = 'd';
+const I18N_DATA = 'l';
 
 /**
  * The name of the key used in the TransferState collection,
@@ -8469,6 +8496,9 @@ function getNgContainerSize(hydrationInfo, index) {
     }
     return size;
 }
+function isSerializedElementContainer(hydrationInfo, index) {
+    return hydrationInfo.data[ELEMENT_CONTAINERS]?.[index] !== undefined;
+}
 function getSerializedContainerViews(hydrationInfo, index) {
     return hydrationInfo.data[CONTAINERS]?.[index] ?? null;
 }
@@ -8484,6 +8514,18 @@ function calcSerializedContainerSize(hydrationInfo, index) {
     }
     return numNodes;
 }
+/**
+ * Attempt to initialize the `disconnectedNodes` field of the given
+ * `DehydratedView`. Returns the initialized value.
+ */
+function initDisconnectedNodes(hydrationInfo) {
+    // Check if we are processing disconnected info for the first time.
+    if (typeof hydrationInfo.disconnectedNodes === 'undefined') {
+        const nodeIds = hydrationInfo.data[DISCONNECTED_NODES];
+        hydrationInfo.disconnectedNodes = nodeIds ? new Set(nodeIds) : null;
+    }
+    return hydrationInfo.disconnectedNodes;
+}
 /**
  * Checks whether a node is annotated as "disconnected", i.e. not present
  * in the DOM at serialization time. We should not attempt hydration for
@@ -8495,7 +8537,51 @@ function isDisconnectedNode$1(hydrationInfo, index) {
         const nodeIds = hydrationInfo.data[DISCONNECTED_NODES];
         hydrationInfo.disconnectedNodes = nodeIds ? new Set(nodeIds) : null;
     }
-    return !!hydrationInfo.disconnectedNodes?.has(index);
+    return !!initDisconnectedNodes(hydrationInfo)?.has(index);
+}
+/**
+ * Helper function to prepare text nodes for serialization by ensuring
+ * that seperate logical text blocks in the DOM remain separate after
+ * serialization.
+ */
+function processTextNodeBeforeSerialization(context, node) {
+    // Handle cases where text nodes can be lost after DOM serialization:
+    //  1. When there is an *empty text node* in DOM: in this case, this
+    //     node would not make it into the serialized string and as a result,
+    //     this node wouldn't be created in a browser. This would result in
+    //     a mismatch during the hydration, where the runtime logic would expect
+    //     a text node to be present in live DOM, but no text node would exist.
+    //     Example: `<span>{{ name }}</span>` when the `name` is an empty string.
+    //     This would result in `<span></span>` string after serialization and
+    //     in a browser only the `span` element would be created. To resolve that,
+    //     an extra comment node is appended in place of an empty text node and
+    //     that special comment node is replaced with an empty text node *before*
+    //     hydration.
+    //  2. When there are 2 consecutive text nodes present in the DOM.
+    //     Example: `<div>Hello <ng-container *ngIf="true">world</ng-container></div>`.
+    //     In this scenario, the live DOM would look like this:
+    //       <div>#text('Hello ') #text('world') #comment('container')</div>
+    //     Serialized string would look like this: `<div>Hello world<!--container--></div>`.
+    //     The live DOM in a browser after that would be:
+    //       <div>#text('Hello world') #comment('container')</div>
+    //     Notice how 2 text nodes are now "merged" into one. This would cause hydration
+    //     logic to fail, since it'd expect 2 text nodes being present, not one.
+    //     To fix this, we insert a special comment node in between those text nodes, so
+    //     serialized representation is: `<div>Hello <!--ngtns-->world<!--container--></div>`.
+    //     This forces browser to create 2 text nodes separated by a comment node.
+    //     Before running a hydration process, this special comment node is removed, so the
+    //     live DOM has exactly the same state as it was before serialization.
+    // Collect this node as required special annotation only when its
+    // contents is empty. Otherwise, such text node would be present on
+    // the client after server-side rendering and no special handling needed.
+    const el = node;
+    const corruptedTextNodes = context.corruptedTextNodes;
+    if (el.textContent === '') {
+        corruptedTextNodes.set(el, "ngetn" /* TextNodeMarker.EmptyNode */);
+    }
+    else if (el.nextSibling?.nodeType === Node.TEXT_NODE) {
+        corruptedTextNodes.set(el, "ngtns" /* TextNodeMarker.Separator */);
+    }
 }
 
 /**
@@ -12700,7 +12786,7 @@ function detectChangesInViewWhileDirty(lView, mode) {
     const lastIsRefreshingViewsValue = isRefreshingViews();
     try {
         setIsRefreshingViews(true);
-        detectChangesInView$1(lView, mode);
+        detectChangesInView(lView, mode);
         let retries = 0;
         // If after running change detection, this view still needs to be refreshed or there are
         // descendants views that need to be refreshed due to re-dirtying during the change detection
@@ -12716,7 +12802,7 @@ function detectChangesInViewWhileDirty(lView, mode) {
             retries++;
             // Even if this view is detached, we still detect changes in targeted mode because this was
             // the root of the change detection run.
-            detectChangesInView$1(lView, 1 /* ChangeDetectionMode.Targeted */);
+            detectChangesInView(lView, 1 /* ChangeDetectionMode.Targeted */);
         }
     }
     finally {
@@ -12951,7 +13037,7 @@ function detectChangesInViewIfAttached(lView, mode) {
     if (!viewAttachedToChangeDetector(lView)) {
         return;
     }
-    detectChangesInView$1(lView, mode);
+    detectChangesInView(lView, mode);
 }
 /**
  * Visits a view as part of change detection traversal.
@@ -12963,7 +13049,7 @@ function detectChangesInViewIfAttached(lView, mode) {
  * The view is not refreshed, but descendants are traversed in `ChangeDetectionMode.Targeted` if the
  * view HasChildViewsToRefresh flag is set.
  */
-function detectChangesInView$1(lView, mode) {
+function detectChangesInView(lView, mode) {
     const isInCheckNoChangesPass = ngDevMode && isInCheckNoChangesMode();
     const tView = lView[TVIEW];
     const flags = lView[FLAGS];
@@ -13774,109 +13860,245 @@ function shorten(input, maxLength = 50) {
 }
 
 /**
- * Removes all dehydrated views from a given LContainer:
- * both in internal data structure, as well as removing
- * corresponding DOM nodes that belong to that dehydrated view.
+ * Find a node in front of which `currentTNode` should be inserted (takes i18n into account).
+ *
+ * This method determines the `RNode` in front of which we should insert the `currentRNode`. This
+ * takes `TNode.insertBeforeIndex` into account.
+ *
+ * @param parentTNode parent `TNode`
+ * @param currentTNode current `TNode` (The node which we would like to insert into the DOM)
+ * @param lView current `LView`
  */
-function removeDehydratedViews(lContainer) {
-    const views = lContainer[DEHYDRATED_VIEWS] ?? [];
-    const parentLView = lContainer[PARENT];
-    const renderer = parentLView[RENDERER];
-    for (const view of views) {
-        removeDehydratedView(view, renderer);
-        ngDevMode && ngDevMode.dehydratedViewsRemoved++;
+function getInsertInFrontOfRNodeWithI18n(parentTNode, currentTNode, lView) {
+    const tNodeInsertBeforeIndex = currentTNode.insertBeforeIndex;
+    const insertBeforeIndex = Array.isArray(tNodeInsertBeforeIndex) ? tNodeInsertBeforeIndex[0] : tNodeInsertBeforeIndex;
+    if (insertBeforeIndex === null) {
+        return getInsertInFrontOfRNodeWithNoI18n(parentTNode, currentTNode, lView);
+    }
+    else {
+        ngDevMode && assertIndexInRange(lView, insertBeforeIndex);
+        return unwrapRNode(lView[insertBeforeIndex]);
     }
-    // Reset the value to an empty array to indicate that no
-    // further processing of dehydrated views is needed for
-    // this view container (i.e. do not trigger the lookup process
-    // once again in case a `ViewContainerRef` is created later).
-    lContainer[DEHYDRATED_VIEWS] = EMPTY_ARRAY;
 }
 /**
- * Helper function to remove all nodes from a dehydrated view.
+ * Process `TNode.insertBeforeIndex` by adding i18n text nodes.
+ *
+ * See `TNode.insertBeforeIndex`
  */
-function removeDehydratedView(dehydratedView, renderer) {
-    let nodesRemoved = 0;
-    let currentRNode = dehydratedView.firstChild;
-    if (currentRNode) {
-        const numNodes = dehydratedView.data[NUM_ROOT_NODES];
-        while (nodesRemoved < numNodes) {
-            ngDevMode && validateSiblingNodeExists(currentRNode);
-            const nextSibling = currentRNode.nextSibling;
-            nativeRemoveNode(renderer, currentRNode, false);
-            currentRNode = nextSibling;
-            nodesRemoved++;
+function processI18nInsertBefore(renderer, childTNode, lView, childRNode, parentRElement) {
+    const tNodeInsertBeforeIndex = childTNode.insertBeforeIndex;
+    if (Array.isArray(tNodeInsertBeforeIndex)) {
+        // An array indicates that there are i18n nodes that need to be added as children of this
+        // `childRNode`. These i18n nodes were created before this `childRNode` was available and so
+        // only now can be added. The first element of the array is the normal index where we should
+        // insert the `childRNode`. Additional elements are the extra nodes to be added as children of
+        // `childRNode`.
+        ngDevMode && assertDomNode(childRNode);
+        let i18nParent = childRNode;
+        let anchorRNode = null;
+        if (!(childTNode.type & 3 /* TNodeType.AnyRNode */)) {
+            anchorRNode = i18nParent;
+            i18nParent = parentRElement;
+        }
+        if (i18nParent !== null && childTNode.componentOffset === -1) {
+            for (let i = 1; i < tNodeInsertBeforeIndex.length; i++) {
+                // No need to `unwrapRNode` because all of the indexes point to i18n text nodes.
+                // see `assertDomNode` below.
+                const i18nChild = lView[tNodeInsertBeforeIndex[i]];
+                nativeInsertBefore(renderer, i18nParent, i18nChild, anchorRNode, false);
+            }
         }
     }
 }
+
 /**
- * Walks over all views within this LContainer invokes dehydrated views
- * cleanup function for each one.
+ * Add `tNode` to `previousTNodes` list and update relevant `TNode`s in `previousTNodes` list
+ * `tNode.insertBeforeIndex`.
+ *
+ * Things to keep in mind:
+ * 1. All i18n text nodes are encoded as `TNodeType.Element` and are created eagerly by the
+ *    `ɵɵi18nStart` instruction.
+ * 2. All `TNodeType.Placeholder` `TNodes` are elements which will be created later by
+ *    `ɵɵelementStart` instruction.
+ * 3. `ɵɵelementStart` instruction will create `TNode`s in the ascending `TNode.index` order. (So a
+ *    smaller index `TNode` is guaranteed to be created before a larger one)
+ *
+ * We use the above three invariants to determine `TNode.insertBeforeIndex`.
+ *
+ * In an ideal world `TNode.insertBeforeIndex` would always be `TNode.next.index`. However,
+ * this will not work because `TNode.next.index` may be larger than `TNode.index` which means that
+ * the next node is not yet created and therefore we can't insert in front of it.
+ *
+ * Rule1: `TNode.insertBeforeIndex = null` if `TNode.next === null` (Initial condition, as we don't
+ *        know if there will be further `TNode`s inserted after.)
+ * Rule2: If `previousTNode` is created after the `tNode` being inserted, then
+ *        `previousTNode.insertBeforeNode = tNode.index` (So when a new `tNode` is added we check
+ *        previous to see if we can update its `insertBeforeTNode`)
+ *
+ * See `TNode.insertBeforeIndex` for more context.
+ *
+ * @param previousTNodes A list of previous TNodes so that we can easily traverse `TNode`s in
+ *     reverse order. (If `TNode` would have `previous` this would not be necessary.)
+ * @param newTNode A TNode to add to the `previousTNodes` list.
  */
-function cleanupLContainer(lContainer) {
-    removeDehydratedViews(lContainer);
-    for (let i = CONTAINER_HEADER_OFFSET; i < lContainer.length; i++) {
-        cleanupLView(lContainer[i]);
+function addTNodeAndUpdateInsertBeforeIndex(previousTNodes, newTNode) {
+    // Start with Rule1
+    ngDevMode &&
+        assertEqual(newTNode.insertBeforeIndex, null, 'We expect that insertBeforeIndex is not set');
+    previousTNodes.push(newTNode);
+    if (previousTNodes.length > 1) {
+        for (let i = previousTNodes.length - 2; i >= 0; i--) {
+            const existingTNode = previousTNodes[i];
+            // Text nodes are created eagerly and so they don't need their `indexBeforeIndex` updated.
+            // It is safe to ignore them.
+            if (!isI18nText(existingTNode)) {
+                if (isNewTNodeCreatedBefore(existingTNode, newTNode) &&
+                    getInsertBeforeIndex(existingTNode) === null) {
+                    // If it was created before us in time, (and it does not yet have `insertBeforeIndex`)
+                    // then add the `insertBeforeIndex`.
+                    setInsertBeforeIndex(existingTNode, newTNode.index);
+                }
+            }
+        }
     }
 }
+function isI18nText(tNode) {
+    return !(tNode.type & 64 /* TNodeType.Placeholder */);
+}
+function isNewTNodeCreatedBefore(existingTNode, newTNode) {
+    return isI18nText(newTNode) || existingTNode.index > newTNode.index;
+}
+function getInsertBeforeIndex(tNode) {
+    const index = tNode.insertBeforeIndex;
+    return Array.isArray(index) ? index[0] : index;
+}
+function setInsertBeforeIndex(tNode, value) {
+    const index = tNode.insertBeforeIndex;
+    if (Array.isArray(index)) {
+        // Array is stored if we have to insert child nodes. See `TNode.insertBeforeIndex`
+        index[0] = value;
+    }
+    else {
+        setI18nHandling(getInsertInFrontOfRNodeWithI18n, processI18nInsertBefore);
+        tNode.insertBeforeIndex = value;
+    }
+}
+
 /**
- * Removes any remaining dehydrated i18n nodes from a given LView,
- * both in internal data structure, as well as removing the
- * corresponding DOM nodes.
+ * Retrieve `TIcu` at a given `index`.
+ *
+ * The `TIcu` can be stored either directly (if it is nested ICU) OR
+ * it is stored inside tho `TIcuContainer` if it is top level ICU.
+ *
+ * The reason for this is that the top level ICU need a `TNode` so that they are part of the render
+ * tree, but nested ICU's have no TNode, because we don't know ahead of time if the nested ICU is
+ * expressed (parent ICU may have selected a case which does not contain it.)
+ *
+ * @param tView Current `TView`.
+ * @param index Index where the value should be read from.
  */
-function cleanupDehydratedI18nNodes(lView) {
-    const i18nNodes = lView[HYDRATION]?.i18nNodes;
-    if (i18nNodes) {
-        const renderer = lView[RENDERER];
-        for (const node of i18nNodes.values()) {
-            nativeRemoveNode(renderer, node, false);
-        }
-        lView[HYDRATION].i18nNodes = undefined;
+function getTIcu(tView, index) {
+    const value = tView.data[index];
+    if (value === null || typeof value === 'string')
+        return null;
+    if (ngDevMode &&
+        !(value.hasOwnProperty('tView') || value.hasOwnProperty('currentCaseLViewIndex'))) {
+        throwError('We expect to get \'null\'|\'TIcu\'|\'TIcuContainer\', but got: ' + value);
     }
+    // Here the `value.hasOwnProperty('currentCaseLViewIndex')` is a polymorphic read as it can be
+    // either TIcu or TIcuContainerNode. This is not ideal, but we still think it is OK because it
+    // will be just two cases which fits into the browser inline cache (inline cache can take up to
+    // 4)
+    const tIcu = value.hasOwnProperty('currentCaseLViewIndex') ? value :
+        value.value;
+    ngDevMode && assertTIcu(tIcu);
+    return tIcu;
 }
 /**
- * Walks over `LContainer`s and components registered within
- * this LView and invokes dehydrated views cleanup function for each one.
+ * Store `TIcu` at a give `index`.
+ *
+ * The `TIcu` can be stored either directly (if it is nested ICU) OR
+ * it is stored inside tho `TIcuContainer` if it is top level ICU.
+ *
+ * The reason for this is that the top level ICU need a `TNode` so that they are part of the render
+ * tree, but nested ICU's have no TNode, because we don't know ahead of time if the nested ICU is
+ * expressed (parent ICU may have selected a case which does not contain it.)
+ *
+ * @param tView Current `TView`.
+ * @param index Index where the value should be stored at in `Tview.data`
+ * @param tIcu The TIcu to store.
  */
-function cleanupLView(lView) {
-    cleanupDehydratedI18nNodes(lView);
-    const tView = lView[TVIEW];
-    for (let i = HEADER_OFFSET; i < tView.bindingStartIndex; i++) {
-        if (isLContainer(lView[i])) {
-            const lContainer = lView[i];
-            cleanupLContainer(lContainer);
-        }
-        else if (isLView(lView[i])) {
-            // This is a component, enter the `cleanupLView` recursively.
-            cleanupLView(lView[i]);
-        }
+function setTIcu(tView, index, tIcu) {
+    const tNode = tView.data[index];
+    ngDevMode &&
+        assertEqual(tNode === null || tNode.hasOwnProperty('tView'), true, 'We expect to get \'null\'|\'TIcuContainer\'');
+    if (tNode === null) {
+        tView.data[index] = tIcu;
+    }
+    else {
+        ngDevMode && assertTNodeType(tNode, 32 /* TNodeType.Icu */);
+        tNode.value = tIcu;
     }
 }
 /**
- * Walks over all views registered within the ApplicationRef and removes
- * all dehydrated views from all `LContainer`s along the way.
+ * Set `TNode.insertBeforeIndex` taking the `Array` into account.
+ *
+ * See `TNode.insertBeforeIndex`
  */
-function cleanupDehydratedViews(appRef) {
-    const viewRefs = appRef._views;
-    for (const viewRef of viewRefs) {
-        const lNode = getLNodeForHydration(viewRef);
-        // An `lView` might be `null` if a `ViewRef` represents
-        // an embedded view (not a component view).
-        if (lNode !== null && lNode[HOST] !== null) {
-            if (isLView(lNode)) {
-                cleanupLView(lNode);
-            }
-            else {
-                // Cleanup in the root component view
-                const componentLView = lNode[HOST];
-                cleanupLView(componentLView);
-                // Cleanup in all views within this view container
-                cleanupLContainer(lNode);
-            }
-            ngDevMode && ngDevMode.dehydratedViewsCleanupRuns++;
-        }
+function setTNodeInsertBeforeIndex(tNode, index) {
+    ngDevMode && assertTNode(tNode);
+    let insertBeforeIndex = tNode.insertBeforeIndex;
+    if (insertBeforeIndex === null) {
+        setI18nHandling(getInsertInFrontOfRNodeWithI18n, processI18nInsertBefore);
+        insertBeforeIndex = tNode.insertBeforeIndex =
+            [null /* may be updated to number later */, index];
+    }
+    else {
+        assertEqual(Array.isArray(insertBeforeIndex), true, 'Expecting array here');
+        insertBeforeIndex.push(index);
     }
 }
+/**
+ * Create `TNode.type=TNodeType.Placeholder` node.
+ *
+ * See `TNodeType.Placeholder` for more information.
+ */
+function createTNodePlaceholder(tView, previousTNodes, index) {
+    const tNode = createTNodeAtIndex(tView, index, 64 /* TNodeType.Placeholder */, null, null);
+    addTNodeAndUpdateInsertBeforeIndex(previousTNodes, tNode);
+    return tNode;
+}
+/**
+ * Returns current ICU case.
+ *
+ * ICU cases are stored as index into the `TIcu.cases`.
+ * At times it is necessary to communicate that the ICU case just switched and that next ICU update
+ * should update all bindings regardless of the mask. In such a case the we store negative numbers
+ * for cases which have just been switched. This function removes the negative flag.
+ */
+function getCurrentICUCaseIndex(tIcu, lView) {
+    const currentCase = lView[tIcu.currentCaseLViewIndex];
+    return currentCase === null ? currentCase : (currentCase < 0 ? ~currentCase : currentCase);
+}
+function getParentFromIcuCreateOpCode(mergedCode) {
+    return mergedCode >>> 17 /* IcuCreateOpCode.SHIFT_PARENT */;
+}
+function getRefFromIcuCreateOpCode(mergedCode) {
+    return (mergedCode & 131070 /* IcuCreateOpCode.MASK_REF */) >>> 1 /* IcuCreateOpCode.SHIFT_REF */;
+}
+function getInstructionFromIcuCreateOpCode(mergedCode) {
+    return mergedCode & 1 /* IcuCreateOpCode.MASK_INSTRUCTION */;
+}
+function icuCreateOpCode(opCode, parentIdx, refIdx) {
+    ngDevMode && assertGreaterThanOrEqual(parentIdx, 0, 'Missing parent index');
+    ngDevMode && assertGreaterThan(refIdx, 0, 'Missing ref index');
+    return opCode | parentIdx << 17 /* IcuCreateOpCode.SHIFT_PARENT */ | refIdx << 1 /* IcuCreateOpCode.SHIFT_REF */;
+}
+// Returns whether the given value corresponds to a root template message,
+// or a sub-template.
+function isRootTemplateMessage(subTemplateIndex) {
+    return subTemplateIndex === -1;
+}
 
 /**
  * Regexp that extracts a reference node information from the compressed node location.
@@ -13968,13 +14190,22 @@ function isDisconnectedNode(tNode, lView) {
 function locateI18nRNodeByIndex(hydrationInfo, noOffsetIndex) {
     const i18nNodes = hydrationInfo.i18nNodes;
     if (i18nNodes) {
-        const native = i18nNodes.get(noOffsetIndex);
-        if (native) {
-            i18nNodes.delete(noOffsetIndex);
-        }
-        return native;
+        return i18nNodes.get(noOffsetIndex);
     }
-    return null;
+    return undefined;
+}
+/**
+ * Attempt to locate an RNode by a path, if it exists.
+ *
+ * @param hydrationInfo The hydration annotation data
+ * @param lView the current lView
+ * @param noOffsetIndex the instruction index
+ * @returns an RNode that corresponds to the instruction index or null if no path exists
+ */
+function tryLocateRNodeByPath(hydrationInfo, lView, noOffsetIndex) {
+    const nodes = hydrationInfo.data[NODES];
+    const path = nodes?.[noOffsetIndex];
+    return path ? locateRNodeByPath(path, lView) : null;
 }
 /**
  * Locate a node in DOM tree that corresponds to a given TNode.
@@ -13988,7 +14219,7 @@ function locateI18nRNodeByIndex(hydrationInfo, noOffsetIndex) {
 function locateNextRNode(hydrationInfo, tView, lView, tNode) {
     const noOffsetIndex = getNoOffsetIndex(tNode);
     let native = locateI18nRNodeByIndex(hydrationInfo, noOffsetIndex);
-    if (!native) {
+    if (native === undefined) {
         const nodes = hydrationInfo.data[NODES];
         if (nodes?.[noOffsetIndex]) {
             // We know the exact location of the node.
@@ -14178,7 +14409,7 @@ function calcPathBetween(from, to, fromNodeName) {
  * Invoked at serialization time (on the server) when a set of navigation
  * instructions needs to be generated for a TNode.
  */
-function calcPathForNode(tNode, lView) {
+function calcPathForNode(tNode, lView, excludedParentNodes) {
     let parentTNode = tNode.parent;
     let parentIndex;
     let parentRNode;
@@ -14190,7 +14421,12 @@ function calcPathForNode(tNode, lView) {
     // a content of an element is projected and used, when a parent element
     // itself remains detached from DOM. In this scenario we try to find a parent
     // element that is attached to DOM and can act as an anchor instead.
-    while (parentTNode !== null && isDisconnectedNode(parentTNode, lView)) {
+    //
+    // It can also happen that the parent node should be excluded, for example,
+    // because it belongs to an i18n block, which requires paths which aren't
+    // relative to other views in an i18n block.
+    while (parentTNode !== null &&
+        (isDisconnectedNode(parentTNode, lView) || (excludedParentNodes?.has(parentTNode.index)))) {
         parentTNode = parentTNode.parent;
     }
     if (parentTNode === null || !(parentTNode.type & 3 /* TNodeType.AnyRNode */)) {
@@ -14241,6 +14477,457 @@ function calcPathForNode(tNode, lView) {
     return path;
 }
 
+let _isI18nHydrationSupportEnabled = false;
+let _prepareI18nBlockForHydrationImpl = () => {
+    // noop unless `enablePrepareI18nBlockForHydrationImpl` is invoked.
+};
+function setIsI18nHydrationSupportEnabled(enabled) {
+    _isI18nHydrationSupportEnabled = enabled;
+}
+function isI18nHydrationSupportEnabled() {
+    return _isI18nHydrationSupportEnabled;
+}
+/**
+ * Prepares an i18n block and its children, located at the given
+ * view and instruction index, for hydration.
+ *
+ * @param lView lView with the i18n block
+ * @param index index of the i18n block in the lView
+ * @param parentTNode TNode of the parent of the i18n block
+ * @param subTemplateIndex sub-template index, or -1 for the main template
+ */
+function prepareI18nBlockForHydration(lView, index, parentTNode, subTemplateIndex) {
+    _prepareI18nBlockForHydrationImpl(lView, index, parentTNode, subTemplateIndex);
+}
+function enablePrepareI18nBlockForHydrationImpl() {
+    _prepareI18nBlockForHydrationImpl = prepareI18nBlockForHydrationImpl;
+}
+function isI18nHydrationEnabled(injector) {
+    injector = injector ?? inject(Injector);
+    return injector.get(IS_I18N_HYDRATION_ENABLED, false);
+}
+/**
+ * Collects, if not already cached, all of the indices in the
+ * given TView which are children of an i18n block.
+ *
+ * Since i18n blocks don't introduce a parent TNode, this is necessary
+ * in order to determine which indices in a LView are translated.
+ */
+function getOrComputeI18nChildren(tView, context) {
+    let i18nChildren = context.i18nChildren.get(tView);
+    if (i18nChildren === undefined) {
+        i18nChildren = collectI18nChildren(tView);
+        context.i18nChildren.set(tView, i18nChildren);
+    }
+    return i18nChildren;
+}
+function collectI18nChildren(tView) {
+    const children = new Set();
+    function collectI18nViews(node) {
+        children.add(node.index);
+        switch (node.kind) {
+            case 1 /* I18nNodeKind.ELEMENT */:
+            case 2 /* I18nNodeKind.PLACEHOLDER */: {
+                for (const childNode of node.children) {
+                    collectI18nViews(childNode);
+                }
+                break;
+            }
+            case 3 /* I18nNodeKind.ICU */: {
+                for (const caseNodes of node.cases) {
+                    for (const caseNode of caseNodes) {
+                        collectI18nViews(caseNode);
+                    }
+                }
+                break;
+            }
+        }
+    }
+    // Traverse through the AST of each i18n block in the LView,
+    // and collect every instruction index.
+    for (let i = HEADER_OFFSET; i < tView.bindingStartIndex; i++) {
+        const tI18n = tView.data[i];
+        if (!tI18n || !tI18n.ast) {
+            continue;
+        }
+        for (const node of tI18n.ast) {
+            collectI18nViews(node);
+        }
+    }
+    return children.size === 0 ? null : children;
+}
+/**
+ * Attempts to serialize i18n data for an i18n block, located at
+ * the given view and instruction index.
+ *
+ * @param lView lView with the i18n block
+ * @param index index of the i18n block in the lView
+ * @param context the hydration context
+ * @returns the i18n data, or null if there is no relevant data
+ */
+function trySerializeI18nBlock(lView, index, context) {
+    if (!context.isI18nHydrationEnabled) {
+        return null;
+    }
+    const tView = lView[TVIEW];
+    const tI18n = tView.data[index];
+    if (!tI18n || !tI18n.ast) {
+        return null;
+    }
+    const caseQueue = [];
+    tI18n.ast.forEach(node => serializeI18nBlock(lView, caseQueue, context, node));
+    return caseQueue.length > 0 ? caseQueue : null;
+}
+function serializeI18nBlock(lView, caseQueue, context, node) {
+    switch (node.kind) {
+        case 0 /* I18nNodeKind.TEXT */:
+            const rNode = unwrapRNode(lView[node.index]);
+            processTextNodeBeforeSerialization(context, rNode);
+            break;
+        case 1 /* I18nNodeKind.ELEMENT */:
+        case 2 /* I18nNodeKind.PLACEHOLDER */:
+            node.children.forEach(node => serializeI18nBlock(lView, caseQueue, context, node));
+            break;
+        case 3 /* I18nNodeKind.ICU */:
+            const currentCase = lView[node.currentCaseLViewIndex];
+            if (currentCase != null) {
+                // i18n uses a negative value to signal a change to a new case, so we
+                // need to invert it to get the proper value.
+                const caseIdx = currentCase < 0 ? ~currentCase : currentCase;
+                caseQueue.push(caseIdx);
+                node.cases[caseIdx].forEach(node => serializeI18nBlock(lView, caseQueue, context, node));
+            }
+            break;
+    }
+}
+function setCurrentNode(state, node) {
+    state.currentNode = node;
+}
+/**
+ * Marks the current RNode as the hydration root for the given
+ * AST node.
+ */
+function appendI18nNodeToCollection(context, state, astNode) {
+    const noOffsetIndex = astNode.index - HEADER_OFFSET;
+    const { disconnectedNodes } = context;
+    const currentNode = state.currentNode;
+    if (state.isConnected) {
+        context.i18nNodes.set(noOffsetIndex, currentNode);
+        // We expect the node to be connected, so ensure that it
+        // is not in the set, regardless of whether we found it,
+        // so that the downstream error handling can provide the
+        // proper context.
+        disconnectedNodes.delete(noOffsetIndex);
+    }
+    else {
+        disconnectedNodes.add(noOffsetIndex);
+    }
+    return currentNode;
+}
+/**
+ * Skip over some sibling nodes during hydration.
+ *
+ * Note: we use this instead of `siblingAfter` as it's expected that
+ * sometimes we might encounter null nodes. In those cases, we want to
+ * defer to downstream error handling to provide proper context.
+ */
+function skipSiblingNodes(state, skip) {
+    let currentNode = state.currentNode;
+    for (let i = 0; i < skip; i++) {
+        if (!currentNode) {
+            break;
+        }
+        currentNode = currentNode?.nextSibling ?? null;
+    }
+    return currentNode;
+}
+/**
+ * Fork the given state into a new state for hydrating children.
+ */
+function forkHydrationState(state, nextNode) {
+    return { currentNode: nextNode, isConnected: state.isConnected };
+}
+function prepareI18nBlockForHydrationImpl(lView, index, parentTNode, subTemplateIndex) {
+    if (!isI18nHydrationSupportEnabled()) {
+        return;
+    }
+    const hydrationInfo = lView[HYDRATION];
+    if (!hydrationInfo) {
+        return;
+    }
+    const tView = lView[TVIEW];
+    const tI18n = tView.data[index];
+    ngDevMode &&
+        assertDefined(tI18n, 'Expected i18n data to be present in a given TView slot during hydration');
+    function findHydrationRoot() {
+        if (isRootTemplateMessage(subTemplateIndex)) {
+            // This is the root of an i18n block. In this case, our hydration root will
+            // depend on where our parent TNode (i.e. the block with i18n applied) is
+            // in the DOM.
+            ngDevMode && assertDefined(parentTNode, 'Expected parent TNode while hydrating i18n root');
+            const rootNode = locateNextRNode(hydrationInfo, tView, lView, parentTNode);
+            // If this i18n block is attached to an <ng-container>, then we want to begin
+            // hydrating directly with the RNode. Otherwise, for a TNode with a physical DOM
+            // element, we want to recurse into the first child and begin there.
+            return (parentTNode.type & 8 /* TNodeType.ElementContainer */) ? rootNode : rootNode.firstChild;
+        }
+        // This is a nested template in an i18n block. In this case, the entire view
+        // is translated, and part of a dehydrated view in a container. This means that
+        // we can simply begin hydration with the first dehydrated child.
+        return hydrationInfo?.firstChild;
+    }
+    const currentNode = findHydrationRoot();
+    ngDevMode && assertDefined(currentNode, 'Expected root i18n node during hydration');
+    const disconnectedNodes = initDisconnectedNodes(hydrationInfo) ?? new Set();
+    const i18nNodes = hydrationInfo.i18nNodes ??= new Map();
+    const caseQueue = hydrationInfo.data[I18N_DATA]?.[index - HEADER_OFFSET] ?? [];
+    const dehydratedIcuData = hydrationInfo.dehydratedIcuData ??=
+        new Map();
+    collectI18nNodesFromDom({ hydrationInfo, lView, i18nNodes, disconnectedNodes, caseQueue, dehydratedIcuData }, { currentNode, isConnected: true }, tI18n.ast);
+    // Nodes from inactive ICU cases should be considered disconnected. We track them above
+    // because they aren't (and shouldn't be) serialized. Since we may mutate or create a
+    // new set, we need to be sure to write the expected value back to the DehydratedView.
+    hydrationInfo.disconnectedNodes = disconnectedNodes.size === 0 ? null : disconnectedNodes;
+}
+function collectI18nNodesFromDom(context, state, nodeOrNodes) {
+    if (Array.isArray(nodeOrNodes)) {
+        for (const node of nodeOrNodes) {
+            // If the node is being projected elsewhere, we need to temporarily
+            // branch the state to that location to continue hydration.
+            // Otherwise, we continue hydration from the current location.
+            const targetNode = tryLocateRNodeByPath(context.hydrationInfo, context.lView, node.index - HEADER_OFFSET);
+            const nextState = targetNode ? forkHydrationState(state, targetNode) : state;
+            collectI18nNodesFromDom(context, nextState, node);
+        }
+    }
+    else {
+        switch (nodeOrNodes.kind) {
+            case 0 /* I18nNodeKind.TEXT */: {
+                // Claim a text node for hydration
+                const currentNode = appendI18nNodeToCollection(context, state, nodeOrNodes);
+                setCurrentNode(state, currentNode?.nextSibling ?? null);
+                break;
+            }
+            case 1 /* I18nNodeKind.ELEMENT */: {
+                // Recurse into the current element's children...
+                collectI18nNodesFromDom(context, forkHydrationState(state, state.currentNode?.firstChild ?? null), nodeOrNodes.children);
+                // And claim the parent element itself.
+                const currentNode = appendI18nNodeToCollection(context, state, nodeOrNodes);
+                setCurrentNode(state, currentNode?.nextSibling ?? null);
+                break;
+            }
+            case 2 /* I18nNodeKind.PLACEHOLDER */: {
+                const noOffsetIndex = nodeOrNodes.index - HEADER_OFFSET;
+                const { hydrationInfo } = context;
+                const containerSize = getNgContainerSize(hydrationInfo, noOffsetIndex);
+                switch (nodeOrNodes.type) {
+                    case 0 /* I18nPlaceholderType.ELEMENT */: {
+                        // Hydration expects to find the head of the element.
+                        const currentNode = appendI18nNodeToCollection(context, state, nodeOrNodes);
+                        // A TNode for the node may not yet if we're hydrating during the first pass,
+                        // so use the serialized data to determine if this is an <ng-container>.
+                        if (isSerializedElementContainer(hydrationInfo, noOffsetIndex)) {
+                            // An <ng-container> doesn't have a physical DOM node, so we need to
+                            // continue hydrating from siblings.
+                            collectI18nNodesFromDom(context, state, nodeOrNodes.children);
+                            // Skip over the anchor element. It will be claimed by the
+                            // downstream container hydration.
+                            const nextNode = skipSiblingNodes(state, 1);
+                            setCurrentNode(state, nextNode);
+                        }
+                        else {
+                            // Non-container elements represent an actual node in the DOM, so we
+                            // need to continue hydration with the children, and claim the node.
+                            collectI18nNodesFromDom(context, forkHydrationState(state, state.currentNode?.firstChild ?? null), nodeOrNodes.children);
+                            setCurrentNode(state, currentNode?.nextSibling ?? null);
+                            // Elements can also be the anchor of a view container, so there may
+                            // be elements after this node that we need to skip.
+                            if (containerSize !== null) {
+                                // `+1` stands for an anchor node after all of the views in the container.
+                                const nextNode = skipSiblingNodes(state, containerSize + 1);
+                                setCurrentNode(state, nextNode);
+                            }
+                        }
+                        break;
+                    }
+                    case 1 /* I18nPlaceholderType.SUBTEMPLATE */: {
+                        ngDevMode &&
+                            assertNotEqual(containerSize, null, 'Expected a container size while hydrating i18n subtemplate');
+                        // Hydration expects to find the head of the template.
+                        appendI18nNodeToCollection(context, state, nodeOrNodes);
+                        // Skip over all of the template children, as well as the anchor
+                        // node, since the template itself will handle them instead.
+                        const nextNode = skipSiblingNodes(state, containerSize + 1);
+                        setCurrentNode(state, nextNode);
+                        break;
+                    }
+                }
+                break;
+            }
+            case 3 /* I18nNodeKind.ICU */: {
+                // If the current node is connected, we need to pop the next case from the
+                // queue, so that the active case is also considered connected.
+                const selectedCase = state.isConnected ? context.caseQueue.shift() : null;
+                const childState = { currentNode: null, isConnected: false };
+                // We traverse through each case, even if it's not active,
+                // so that we correctly populate disconnected nodes.
+                for (let i = 0; i < nodeOrNodes.cases.length; i++) {
+                    collectI18nNodesFromDom(context, i === selectedCase ? state : childState, nodeOrNodes.cases[i]);
+                }
+                if (selectedCase !== null) {
+                    // ICUs represent a branching state, and the selected case could be different
+                    // than what it was on the server. In that case, we need to be able to clean
+                    // up the nodes from the original case. To do that, we store the selected case.
+                    context.dehydratedIcuData.set(nodeOrNodes.index, { case: selectedCase, node: nodeOrNodes });
+                }
+                // Hydration expects to find the ICU anchor element.
+                const currentNode = appendI18nNodeToCollection(context, state, nodeOrNodes);
+                setCurrentNode(state, currentNode?.nextSibling ?? null);
+                break;
+            }
+        }
+    }
+}
+let _claimDehydratedIcuCaseImpl = () => {
+    // noop unless `enableClaimDehydratedIcuCaseImpl` is invoked
+};
+/**
+ * Mark the case for the ICU node at the given index in the view as claimed,
+ * allowing its nodes to be hydrated and not cleaned up.
+ */
+function claimDehydratedIcuCase(lView, icuIndex, caseIndex) {
+    _claimDehydratedIcuCaseImpl(lView, icuIndex, caseIndex);
+}
+function enableClaimDehydratedIcuCaseImpl() {
+    _claimDehydratedIcuCaseImpl = claimDehydratedIcuCaseImpl;
+}
+function claimDehydratedIcuCaseImpl(lView, icuIndex, caseIndex) {
+    const dehydratedIcuDataMap = lView[HYDRATION]?.dehydratedIcuData;
+    if (dehydratedIcuDataMap) {
+        const dehydratedIcuData = dehydratedIcuDataMap.get(icuIndex);
+        if (dehydratedIcuData?.case === caseIndex) {
+            // If the case we're attempting to claim matches the dehydrated one,
+            // we remove it from the map to mark it as "claimed."
+            dehydratedIcuDataMap.delete(icuIndex);
+        }
+    }
+}
+/**
+ * Clean up all i18n hydration data associated with the given view.
+ */
+function cleanupI18nHydrationData(lView) {
+    const hydrationInfo = lView[HYDRATION];
+    if (hydrationInfo) {
+        const { i18nNodes, dehydratedIcuData: dehydratedIcuDataMap } = hydrationInfo;
+        if (i18nNodes && dehydratedIcuDataMap) {
+            const renderer = lView[RENDERER];
+            for (const dehydratedIcuData of dehydratedIcuDataMap.values()) {
+                cleanupDehydratedIcuData(renderer, i18nNodes, dehydratedIcuData);
+            }
+        }
+        hydrationInfo.i18nNodes = undefined;
+        hydrationInfo.dehydratedIcuData = undefined;
+    }
+}
+function cleanupDehydratedIcuData(renderer, i18nNodes, dehydratedIcuData) {
+    for (const node of dehydratedIcuData.node.cases[dehydratedIcuData.case]) {
+        const rNode = i18nNodes.get(node.index - HEADER_OFFSET);
+        if (rNode) {
+            nativeRemoveNode(renderer, rNode, false);
+        }
+    }
+}
+
+/**
+ * Removes all dehydrated views from a given LContainer:
+ * both in internal data structure, as well as removing
+ * corresponding DOM nodes that belong to that dehydrated view.
+ */
+function removeDehydratedViews(lContainer) {
+    const views = lContainer[DEHYDRATED_VIEWS] ?? [];
+    const parentLView = lContainer[PARENT];
+    const renderer = parentLView[RENDERER];
+    for (const view of views) {
+        removeDehydratedView(view, renderer);
+        ngDevMode && ngDevMode.dehydratedViewsRemoved++;
+    }
+    // Reset the value to an empty array to indicate that no
+    // further processing of dehydrated views is needed for
+    // this view container (i.e. do not trigger the lookup process
+    // once again in case a `ViewContainerRef` is created later).
+    lContainer[DEHYDRATED_VIEWS] = EMPTY_ARRAY;
+}
+/**
+ * Helper function to remove all nodes from a dehydrated view.
+ */
+function removeDehydratedView(dehydratedView, renderer) {
+    let nodesRemoved = 0;
+    let currentRNode = dehydratedView.firstChild;
+    if (currentRNode) {
+        const numNodes = dehydratedView.data[NUM_ROOT_NODES];
+        while (nodesRemoved < numNodes) {
+            ngDevMode && validateSiblingNodeExists(currentRNode);
+            const nextSibling = currentRNode.nextSibling;
+            nativeRemoveNode(renderer, currentRNode, false);
+            currentRNode = nextSibling;
+            nodesRemoved++;
+        }
+    }
+}
+/**
+ * Walks over all views within this LContainer invokes dehydrated views
+ * cleanup function for each one.
+ */
+function cleanupLContainer(lContainer) {
+    removeDehydratedViews(lContainer);
+    for (let i = CONTAINER_HEADER_OFFSET; i < lContainer.length; i++) {
+        cleanupLView(lContainer[i]);
+    }
+}
+/**
+ * Walks over `LContainer`s and components registered within
+ * this LView and invokes dehydrated views cleanup function for each one.
+ */
+function cleanupLView(lView) {
+    cleanupI18nHydrationData(lView);
+    const tView = lView[TVIEW];
+    for (let i = HEADER_OFFSET; i < tView.bindingStartIndex; i++) {
+        if (isLContainer(lView[i])) {
+            const lContainer = lView[i];
+            cleanupLContainer(lContainer);
+        }
+        else if (isLView(lView[i])) {
+            // This is a component, enter the `cleanupLView` recursively.
+            cleanupLView(lView[i]);
+        }
+    }
+}
+/**
+ * Walks over all views registered within the ApplicationRef and removes
+ * all dehydrated views from all `LContainer`s along the way.
+ */
+function cleanupDehydratedViews(appRef) {
+    const viewRefs = appRef._views;
+    for (const viewRef of viewRefs) {
+        const lNode = getLNodeForHydration(viewRef);
+        // An `lView` might be `null` if a `ViewRef` represents
+        // an embedded view (not a component view).
+        if (lNode !== null && lNode[HOST] !== null) {
+            if (isLView(lNode)) {
+                cleanupLView(lNode);
+            }
+            else {
+                // Cleanup in the root component view
+                const componentLView = lNode[HOST];
+                cleanupLView(componentLView);
+                // Cleanup in all views within this view container
+                cleanupLContainer(lNode);
+            }
+            ngDevMode && ngDevMode.dehydratedViewsCleanupRuns++;
+        }
+    }
+}
+
 /**
  * Given a current DOM node and a serialized information about the views
  * in a container, walks over the DOM structure, collecting the list of
@@ -14319,6 +15006,9 @@ function findMatchingDehydratedView(lContainer, template) {
  */
 class ChangeDetectionScheduler {
 }
+/** Token used to indicate if zoneless was enabled via provideZonelessChangeDetection(). */
+const ZONELESS_ENABLED = new InjectionToken(typeof ngDevMode === 'undefined' || ngDevMode ? 'Zoneless enabled' : '', { providedIn: 'root', factory: () => false });
+const ZONELESS_SCHEDULER_DISABLED = new InjectionToken(typeof ngDevMode === 'undefined' || ngDevMode ? 'scheduler disabled' : '');
 
 /**
  * Represents a component created by a `ComponentFactory`.
@@ -14511,9 +15201,11 @@ function performanceMarkFeature(feature) {
  *
  * By running change detection after the first of `setTimeout` and `rAF` to execute, we get the
  * best of both worlds.
+ *
+ * @returns a function to cancel the scheduled callback
  */
-function getCallbackScheduler() {
-    // Note: the `getNativeRequestAnimationFrame` is used in the `NgZone` class, but we cannot use the
+function scheduleCallback(callback) {
+    // Note: the `scheduleCallback` is used in the `NgZone` class, but we cannot use the
     // `inject` function. The `NgZone` instance may be created manually, and thus the injection
     // context will be unavailable. This might be enough to check whether `requestAnimationFrame` is
     // available because otherwise, we'll fall back to `setTimeout`.
@@ -14521,36 +15213,29 @@ function getCallbackScheduler() {
     let nativeRequestAnimationFrame = hasRequestAnimationFrame ? _global['requestAnimationFrame'] : null;
     let nativeSetTimeout = _global['setTimeout'];
     if (typeof Zone !== 'undefined') {
-        // Note: zone.js sets original implementations on patched APIs behind the
-        // `__zone_symbol__OriginalDelegate` key (see `attachOriginToPatched`). Given the following
-        // example: `window.requestAnimationFrame.__zone_symbol__OriginalDelegate`; this would return an
-        // unpatched implementation of the `requestAnimationFrame`, which isn't intercepted by the
-        // Angular zone. We use the unpatched implementation to avoid another change detection when
-        // coalescing tasks.
-        const ORIGINAL_DELEGATE_SYMBOL = Zone.__symbol__('OriginalDelegate');
-        if (nativeRequestAnimationFrame) {
+        if (hasRequestAnimationFrame) {
             nativeRequestAnimationFrame =
-                nativeRequestAnimationFrame[ORIGINAL_DELEGATE_SYMBOL] ??
-                    nativeRequestAnimationFrame;
+                _global[Zone.__symbol__('requestAnimationFrame')] ?? nativeRequestAnimationFrame;
         }
-        nativeSetTimeout = nativeSetTimeout[ORIGINAL_DELEGATE_SYMBOL] ?? nativeSetTimeout;
+        nativeSetTimeout = _global[Zone.__symbol__('setTimeout')] ?? nativeSetTimeout;
     }
-    return (callback) => {
-        let executeCallback = true;
-        nativeSetTimeout(() => {
-            if (!executeCallback) {
-                return;
-            }
-            executeCallback = false;
-            callback();
-        });
-        nativeRequestAnimationFrame?.(() => {
-            if (!executeCallback) {
-                return;
-            }
-            executeCallback = false;
-            callback();
-        });
+    let executeCallback = true;
+    nativeSetTimeout(() => {
+        if (!executeCallback) {
+            return;
+        }
+        executeCallback = false;
+        callback();
+    });
+    nativeRequestAnimationFrame?.(() => {
+        if (!executeCallback) {
+            return;
+        }
+        executeCallback = false;
+        callback();
+    });
+    return () => {
+        executeCallback = false;
     };
 }
 
@@ -14708,7 +15393,7 @@ class NgZone {
             !shouldCoalesceRunChangeDetection && shouldCoalesceEventChangeDetection;
         self.shouldCoalesceRunChangeDetection = shouldCoalesceRunChangeDetection;
         self.callbackScheduled = false;
-        self.scheduleCallback = getCallbackScheduler();
+        self.scheduleCallback = scheduleCallback;
         forkInnerZoneWithAngularBehavior(self);
     }
     /**
@@ -16040,7 +16725,7 @@ function createRootComponent(componentView, rootComponentDef, rootDirectives, ho
 function setRootNodeAttributes(hostRenderer, componentDef, hostRNode, rootSelectorOrNode) {
     if (rootSelectorOrNode) {
         // The placeholder will be replaced with the actual version at build time.
-        setUpAttributes(hostRenderer, hostRNode, ['ng-version', '18.0.0-next.1']);
+        setUpAttributes(hostRenderer, hostRNode, ['ng-version', '18.0.0-next.3']);
     }
     else {
         // If host element is created as a part of this function call (i.e. `rootSelectorOrNode`
@@ -16095,7 +16780,7 @@ function LifecycleHooksFeature() {
  * (created by instantiating a `TemplateRef` with the `createEmbeddedView()` method).
  *
  * A view container instance can contain other view containers,
- * creating a [view hierarchy](guide/glossary#view-hierarchy).
+ * creating a view hierarchy.
  *
  * @usageNotes
  *
@@ -17093,6 +17778,7 @@ function viewChildRequiredFn(locator, opts) {
  * ```
  *
  * @developerPreview
+ * @initializerApiFunction
  */
 const viewChild = (() => {
     // Note: This may be considered a side-effect, but nothing will depend on
@@ -17117,6 +17803,9 @@ const viewChild = (() => {
  *   divEls = viewChildren<ElementRef>('el');   // Signal<ReadonlyArray<ElementRef>>
  * }
  * ```
+ *
+ * @initializerApiFunction
+ * @developerPreview
  */
 function viewChildren(locator, opts) {
     ngDevMode && assertInInjectionContext(viewChildren);
@@ -17147,6 +17836,9 @@ function contentChildRequiredFn(locator, opts) {
  *   headerRequired = contentChild.required(MyHeader);            // Signal<MyHeader>
  * }
  * ```
+ *
+ * @initializerApiFunction
+ * @developerPreview
  */
 const contentChild = (() => {
     // Note: This may be considered a side-effect, but nothing will depend on
@@ -17171,6 +17863,9 @@ const contentChild = (() => {
  *   headerEl = contentChildren<ElementRef>('h');   // Signal<ReadonlyArray<ElementRef>>
  * }
  * ```
+ *
+ * @initializerApiFunction
+ * @developerPreview
  */
 function contentChildren(locator, opts) {
     return createMultiResultQuerySignalFn();
@@ -17228,31 +17923,51 @@ function modelRequiredFunction() {
     return createModelSignal(REQUIRED_UNSET_VALUE);
 }
 /**
- * `model` declares a writeable signal that is exposed as an input/output pair on the containing
- * directive. The input name is taken either from the class member or from the `alias` option.
+ * `model` declares a writeable signal that is exposed as an input/output
+ * pair on the containing directive.
+ *
+ * The input name is taken either from the class member or from the `alias` option.
  * The output name is generated by taking the input name and appending `Change`.
  *
- * Initializes a model with an initial value. If no explicit value
- * is specified, Angular will use `undefined`.
+ * @usageNotes
+ *
+ * To use `model()`, import the function from `@angular/core`.
  *
- * Consider using `model.required` for models that don't need an
- * initial value.
+ * ```
+ * import {model} from '@angular/core`;
+ * ```
  *
- * @usageNotes
- * Initialize a model in your directive or component by declaring a
- * class field and initializing it with the `model()` or `model.required()`
- * function.
+ * Inside your component, introduce a new class member and initialize
+ * it with a call to `model` or `model.required`.
  *
  * ```ts
- * @Directive({..})
+ * @Directive({
+ *   ...
+ * })
  * export class MyDir {
- *   firstName = model<string>();            // string|undefined
- *   lastName = model.required<string>();    // string
- *   age = model(0);                         // number
+ *   firstName = model<string>();            // ModelSignal<string|undefined>
+ *   lastName  = model.required<string>();   // ModelSignal<string>
+ *   age       = model(0);                   // ModelSignal<number>
+ * }
+ * ```
+ *
+ * Inside your component template, you can display the value of a `model`
+ * by calling the signal.
+ *
+ * ```html
+ * <span>{{firstName()}}</span>
+ * ```
+ *
+ * Updating the `model` is equivalent to updating a writable signal.
+ *
+ * ```ts
+ * updateName(newFirstName: string): void {
+ *   this.firstName.set(newFirstName);
  * }
  * ```
  *
  * @developerPreview
+ * @initializerApiFunction
  */
 const model = (() => {
     // Note: This may be considered a side-effect, but nothing will depend on
@@ -18411,12 +19126,12 @@ function isDetachedByI18n(tNode) {
     return (tNode.flags & 32 /* TNodeFlags.isDetached */) === 32 /* TNodeFlags.isDetached */;
 }
 
-function templateFirstCreatePass(index, tView, lView, templateFn, decls, vars, tagName, attrsIndex, localRefsIndex) {
+function templateFirstCreatePass(index, tView, lView, templateFn, decls, vars, tagName, attrs, localRefsIndex) {
     ngDevMode && assertFirstCreatePass(tView);
     ngDevMode && ngDevMode.firstCreatePass++;
     const tViewConsts = tView.consts;
     // TODO(pk): refactor getOrCreateTNode to have the "create" only version
-    const tNode = getOrCreateTNode(tView, index, 4 /* TNodeType.Container */, tagName || null, getConstant(tViewConsts, attrsIndex));
+    const tNode = getOrCreateTNode(tView, index, 4 /* TNodeType.Container */, tagName || null, attrs || null);
     resolveDirectives(tView, lView, tNode, getConstant(tViewConsts, localRefsIndex));
     registerPostOrderHooks(tView, tNode);
     const embeddedTView = tNode.tView = createTView(2 /* TViewType.Embedded */, tNode, templateFn, decls, vars, tView.directiveRegistry, tView.pipeRegistry, null, tView.schemas, tViewConsts, null /* ssrId */);
@@ -18427,12 +19142,10 @@ function templateFirstCreatePass(index, tView, lView, templateFn, decls, vars, t
     return tNode;
 }
 /**
- * Creates an LContainer for an ng-template (dynamically-inserted view), e.g.
- *
- * <ng-template #foo>
- *    <div></div>
- * </ng-template>
+ * Creates an LContainer for an embedded view.
  *
+ * @param declarationLView LView in which the template was declared.
+ * @param declarationTView TView in which the template wa declared.
  * @param index The index of the container in the data array
  * @param templateFn Inline template
  * @param decls The number of nodes, local refs, and pipes for this template
@@ -18442,34 +19155,57 @@ function templateFirstCreatePass(index, tView, lView, templateFn, decls, vars, t
  * @param localRefs Index of the local references in the `consts` array.
  * @param localRefExtractor A function which extracts local-refs values from the template.
  *        Defaults to the current element associated with the local-ref.
- *
- * @codeGenApi
  */
-function ɵɵtemplate(index, templateFn, decls, vars, tagName, attrsIndex, localRefsIndex, localRefExtractor) {
-    const lView = getLView();
-    const tView = getTView();
+function declareTemplate(declarationLView, declarationTView, index, templateFn, decls, vars, tagName, attrs, localRefsIndex, localRefExtractor) {
     const adjustedIndex = index + HEADER_OFFSET;
-    const tNode = tView.firstCreatePass ? templateFirstCreatePass(adjustedIndex, tView, lView, templateFn, decls, vars, tagName, attrsIndex, localRefsIndex) :
-        tView.data[adjustedIndex];
+    const tNode = declarationTView.firstCreatePass ?
+        templateFirstCreatePass(adjustedIndex, declarationTView, declarationLView, templateFn, decls, vars, tagName, attrs, localRefsIndex) :
+        declarationTView.data[adjustedIndex];
     setCurrentTNode(tNode, false);
-    const comment = _locateOrCreateContainerAnchor(tView, lView, tNode, index);
+    const comment = _locateOrCreateContainerAnchor(declarationTView, declarationLView, tNode, index);
     if (wasLastNodeCreated()) {
-        appendChild(tView, lView, comment, tNode);
+        appendChild(declarationTView, declarationLView, comment, tNode);
     }
-    attachPatchData(comment, lView);
-    const lContainer = createLContainer(comment, lView, comment, tNode);
-    lView[adjustedIndex] = lContainer;
-    addToViewTree(lView, lContainer);
+    attachPatchData(comment, declarationLView);
+    const lContainer = createLContainer(comment, declarationLView, comment, tNode);
+    declarationLView[adjustedIndex] = lContainer;
+    addToViewTree(declarationLView, lContainer);
     // If hydration is enabled, looks up dehydrated views in the DOM
     // using hydration annotation info and stores those views on LContainer.
     // In client-only mode, this function is a noop.
-    populateDehydratedViewsInLContainer(lContainer, tNode, lView);
+    populateDehydratedViewsInLContainer(lContainer, tNode, declarationLView);
     if (isDirectiveHost(tNode)) {
-        createDirectivesInstances(tView, lView, tNode);
+        createDirectivesInstances(declarationTView, declarationLView, tNode);
     }
     if (localRefsIndex != null) {
-        saveResolvedLocalsInData(lView, tNode, localRefExtractor);
+        saveResolvedLocalsInData(declarationLView, tNode, localRefExtractor);
     }
+    return tNode;
+}
+/**
+ * Creates an LContainer for an ng-template (dynamically-inserted view), e.g.
+ *
+ * <ng-template #foo>
+ *    <div></div>
+ * </ng-template>
+ *
+ * @param index The index of the container in the data array
+ * @param templateFn Inline template
+ * @param decls The number of nodes, local refs, and pipes for this template
+ * @param vars The number of bindings for this template
+ * @param tagName The name of the container element, if applicable
+ * @param attrsIndex Index of template attributes in the `consts` array.
+ * @param localRefs Index of the local references in the `consts` array.
+ * @param localRefExtractor A function which extracts local-refs values from the template.
+ *        Defaults to the current element associated with the local-ref.
+ *
+ * @codeGenApi
+ */
+function ɵɵtemplate(index, templateFn, decls, vars, tagName, attrsIndex, localRefsIndex, localRefExtractor) {
+    const lView = getLView();
+    const tView = getTView();
+    const attrs = getConstant(tView.consts, attrsIndex);
+    declareTemplate(lView, tView, index, templateFn, decls, vars, tagName, attrs, localRefsIndex, localRefExtractor);
     return ɵɵtemplate;
 }
 let _locateOrCreateContainerAnchor = createContainerAnchorImpl;
@@ -19363,7 +20099,7 @@ function ɵɵdefer(index, primaryTmplIndex, dependencyResolverFn, loadingTmplInd
     const lView = getLView();
     const tView = getTView();
     const adjustedIndex = index + HEADER_OFFSET;
-    ɵɵtemplate(index, null, 0, 0);
+    const tNode = declareTemplate(lView, tView, index, null, 0, 0);
     if (tView.firstCreatePass) {
         performanceMarkFeature('NgDefer');
         const tDetails = {
@@ -19381,7 +20117,6 @@ function ɵɵdefer(index, primaryTmplIndex, dependencyResolverFn, loadingTmplInd
         enableTimerScheduling?.(tView, tDetails, placeholderConfigIndex, loadingConfigIndex);
         setTDeferBlockDetails(tView, adjustedIndex, tDetails);
     }
-    const tNode = getCurrentTNode();
     const lContainer = lView[adjustedIndex];
     // If hydration is enabled, looks up dehydrated views in the DOM
     // using hydration annotation info and stores those views on LContainer.
@@ -19672,6 +20407,14 @@ function renderDeferBlockState(newState, tNode, lContainer, skipTimerScheduling
         }
     }
 }
+/**
+ * Detects whether an injector is an instance of a `ChainedInjector`,
+ * created based on the `OutletInjector`.
+ */
+function isRouterOutletInjector(currentInjector) {
+    return (currentInjector instanceof ChainedInjector) &&
+        (currentInjector.injector.__ngOutletInjector);
+}
 /**
  * Applies changes to the DOM to reflect a given state.
  */
@@ -19698,14 +20441,20 @@ function applyDeferBlockState(newState, lDetails, lContainer, tNode, hostLView)
             const providers = tDetails.providers;
             if (providers && providers.length > 0) {
                 const parentInjector = hostLView[INJECTOR];
-                const parentEnvInjector = parentInjector.get(EnvironmentInjector);
-                injector =
-                    parentEnvInjector.get(CachedInjectorService)
-                        .getOrCreateInjector(tDetails, parentEnvInjector, providers, ngDevMode ? 'DeferBlock Injector' : '');
+                // Note: we have a special case for Router's `OutletInjector`,
+                // since it's not an instance of the `EnvironmentInjector`, so
+                // we can't inject it. Once the `OutletInjector` is replaced
+                // with the `EnvironmentInjector` in Router's code, this special
+                // handling can be removed.
+                const parentEnvInjector = isRouterOutletInjector(parentInjector) ?
+                    parentInjector :
+                    parentInjector.get(EnvironmentInjector);
+                injector = parentEnvInjector.get(CachedInjectorService)
+                    .getOrCreateInjector(tDetails, parentEnvInjector, providers, ngDevMode ? 'DeferBlock Injector' : '');
             }
         }
         const dehydratedView = findMatchingDehydratedView(lContainer, activeBlockTNode.tView.ssrId);
-        const embeddedLView = createAndRenderEmbeddedLView(hostLView, activeBlockTNode, null, { dehydratedView, embeddedViewInjector: injector });
+        const embeddedLView = createAndRenderEmbeddedLView(hostLView, activeBlockTNode, null, { dehydratedView, injector });
         addLViewToLContainer(lContainer, embeddedLView, viewIndex, shouldAddViewToDom(activeBlockTNode, dehydratedView));
         markViewDirty(embeddedLView);
     }
@@ -22669,41 +23418,47 @@ class UniqueValueMultiKeyMap {
  * built-in "if" and "switch". On the high level this instruction is responsible for adding and
  * removing views selected by a conditional expression.
  *
- * @param containerIndex index of a container in a host view (indexed from HEADER_OFFSET) where
- *     conditional views should be inserted.
  * @param matchingTemplateIndex index of a template TNode representing a conditional view to be
  *     inserted; -1 represents a special case when there is no view to insert.
  * @codeGenApi
  */
 function ɵɵconditional(containerIndex, matchingTemplateIndex, value) {
+    // TODO: we could remove the containerIndex argument to this instruction now (!)
     performanceMarkFeature('NgControlFlow');
     const hostLView = getLView();
     const bindingIndex = nextBindingIndex();
-    const lContainer = getLContainer(hostLView, HEADER_OFFSET + containerIndex);
+    const prevMatchingTemplateIndex = hostLView[bindingIndex] !== NO_CHANGE ? hostLView[bindingIndex] : -1;
+    const prevContainer = prevMatchingTemplateIndex !== -1 ?
+        getLContainer(hostLView, HEADER_OFFSET + prevMatchingTemplateIndex) :
+        undefined;
     const viewInContainerIdx = 0;
     if (bindingUpdated(hostLView, bindingIndex, matchingTemplateIndex)) {
         const prevConsumer = setActiveConsumer$1(null);
         try {
             // The index of the view to show changed - remove the previously displayed one
             // (it is a noop if there are no active views in a container).
-            removeLViewFromLContainer(lContainer, viewInContainerIdx);
+            if (prevContainer !== undefined) {
+                removeLViewFromLContainer(prevContainer, viewInContainerIdx);
+            }
             // Index -1 is a special case where none of the conditions evaluates to
             // a truthy value and as the consequence we've got no view to show.
             if (matchingTemplateIndex !== -1) {
-                const templateTNode = getExistingTNode(hostLView[TVIEW], HEADER_OFFSET + matchingTemplateIndex);
-                const dehydratedView = findMatchingDehydratedView(lContainer, templateTNode.tView.ssrId);
+                const nextLContainerIndex = HEADER_OFFSET + matchingTemplateIndex;
+                const nextContainer = getLContainer(hostLView, nextLContainerIndex);
+                const templateTNode = getExistingTNode(hostLView[TVIEW], nextLContainerIndex);
+                const dehydratedView = findMatchingDehydratedView(nextContainer, templateTNode.tView.ssrId);
                 const embeddedLView = createAndRenderEmbeddedLView(hostLView, templateTNode, value, { dehydratedView });
-                addLViewToLContainer(lContainer, embeddedLView, viewInContainerIdx, shouldAddViewToDom(templateTNode, dehydratedView));
+                addLViewToLContainer(nextContainer, embeddedLView, viewInContainerIdx, shouldAddViewToDom(templateTNode, dehydratedView));
             }
         }
         finally {
             setActiveConsumer$1(prevConsumer);
         }
     }
-    else {
+    else if (prevContainer !== undefined) {
         // We might keep displaying the same template but the actual value of the expression could have
         // changed - re-bind in context.
-        const lView = getLViewFromLContainer(lContainer, viewInContainerIdx);
+        const lView = getLViewFromLContainer(prevContainer, viewInContainerIdx);
         if (lView !== undefined) {
             lView[CONTEXT] = value;
         }
@@ -22777,6 +23532,8 @@ function ɵɵrepeaterCreate(index, templateFn, decls, vars, tagName, attrsIndex,
     performanceMarkFeature('NgControlFlow');
     ngDevMode &&
         assertFunction(trackByFn, `A track expression must be a function, was ${typeof trackByFn} instead.`);
+    const lView = getLView();
+    const tView = getTView();
     const hasEmptyBlock = emptyTemplateFn !== undefined;
     const hostLView = getLView();
     const boundTrackBy = trackByUsesComponentInstance ?
@@ -22786,13 +23543,13 @@ function ɵɵrepeaterCreate(index, templateFn, decls, vars, tagName, attrsIndex,
         trackByFn;
     const metadata = new RepeaterMetadata(hasEmptyBlock, boundTrackBy);
     hostLView[HEADER_OFFSET + index] = metadata;
-    ɵɵtemplate(index + 1, templateFn, decls, vars, tagName, attrsIndex);
+    declareTemplate(lView, tView, index + 1, templateFn, decls, vars, tagName, getConstant(tView.consts, attrsIndex));
     if (hasEmptyBlock) {
         ngDevMode &&
             assertDefined(emptyDecls, 'Missing number of declarations for the empty repeater block.');
         ngDevMode &&
             assertDefined(emptyVars, 'Missing number of bindings for the empty repeater block.');
-        ɵɵtemplate(index + 2, emptyTemplateFn, emptyDecls, emptyVars, emptyTagName, emptyAttrsIndex);
+        declareTemplate(lView, tView, index + 2, emptyTemplateFn, emptyDecls, emptyVars, emptyTagName, getConstant(tView.consts, emptyAttrsIndex));
     }
 }
 class LiveCollectionLContainerImpl extends LiveCollection {
@@ -23547,242 +24304,6 @@ function getLocaleId() {
     return LOCALE_ID$1;
 }
 
-/**
- * Find a node in front of which `currentTNode` should be inserted (takes i18n into account).
- *
- * This method determines the `RNode` in front of which we should insert the `currentRNode`. This
- * takes `TNode.insertBeforeIndex` into account.
- *
- * @param parentTNode parent `TNode`
- * @param currentTNode current `TNode` (The node which we would like to insert into the DOM)
- * @param lView current `LView`
- */
-function getInsertInFrontOfRNodeWithI18n(parentTNode, currentTNode, lView) {
-    const tNodeInsertBeforeIndex = currentTNode.insertBeforeIndex;
-    const insertBeforeIndex = Array.isArray(tNodeInsertBeforeIndex) ? tNodeInsertBeforeIndex[0] : tNodeInsertBeforeIndex;
-    if (insertBeforeIndex === null) {
-        return getInsertInFrontOfRNodeWithNoI18n(parentTNode, currentTNode, lView);
-    }
-    else {
-        ngDevMode && assertIndexInRange(lView, insertBeforeIndex);
-        return unwrapRNode(lView[insertBeforeIndex]);
-    }
-}
-/**
- * Process `TNode.insertBeforeIndex` by adding i18n text nodes.
- *
- * See `TNode.insertBeforeIndex`
- */
-function processI18nInsertBefore(renderer, childTNode, lView, childRNode, parentRElement) {
-    const tNodeInsertBeforeIndex = childTNode.insertBeforeIndex;
-    if (Array.isArray(tNodeInsertBeforeIndex)) {
-        // An array indicates that there are i18n nodes that need to be added as children of this
-        // `childRNode`. These i18n nodes were created before this `childRNode` was available and so
-        // only now can be added. The first element of the array is the normal index where we should
-        // insert the `childRNode`. Additional elements are the extra nodes to be added as children of
-        // `childRNode`.
-        ngDevMode && assertDomNode(childRNode);
-        let i18nParent = childRNode;
-        let anchorRNode = null;
-        if (!(childTNode.type & 3 /* TNodeType.AnyRNode */)) {
-            anchorRNode = i18nParent;
-            i18nParent = parentRElement;
-        }
-        if (i18nParent !== null && childTNode.componentOffset === -1) {
-            for (let i = 1; i < tNodeInsertBeforeIndex.length; i++) {
-                // No need to `unwrapRNode` because all of the indexes point to i18n text nodes.
-                // see `assertDomNode` below.
-                const i18nChild = lView[tNodeInsertBeforeIndex[i]];
-                nativeInsertBefore(renderer, i18nParent, i18nChild, anchorRNode, false);
-            }
-        }
-    }
-}
-
-/**
- * Add `tNode` to `previousTNodes` list and update relevant `TNode`s in `previousTNodes` list
- * `tNode.insertBeforeIndex`.
- *
- * Things to keep in mind:
- * 1. All i18n text nodes are encoded as `TNodeType.Element` and are created eagerly by the
- *    `ɵɵi18nStart` instruction.
- * 2. All `TNodeType.Placeholder` `TNodes` are elements which will be created later by
- *    `ɵɵelementStart` instruction.
- * 3. `ɵɵelementStart` instruction will create `TNode`s in the ascending `TNode.index` order. (So a
- *    smaller index `TNode` is guaranteed to be created before a larger one)
- *
- * We use the above three invariants to determine `TNode.insertBeforeIndex`.
- *
- * In an ideal world `TNode.insertBeforeIndex` would always be `TNode.next.index`. However,
- * this will not work because `TNode.next.index` may be larger than `TNode.index` which means that
- * the next node is not yet created and therefore we can't insert in front of it.
- *
- * Rule1: `TNode.insertBeforeIndex = null` if `TNode.next === null` (Initial condition, as we don't
- *        know if there will be further `TNode`s inserted after.)
- * Rule2: If `previousTNode` is created after the `tNode` being inserted, then
- *        `previousTNode.insertBeforeNode = tNode.index` (So when a new `tNode` is added we check
- *        previous to see if we can update its `insertBeforeTNode`)
- *
- * See `TNode.insertBeforeIndex` for more context.
- *
- * @param previousTNodes A list of previous TNodes so that we can easily traverse `TNode`s in
- *     reverse order. (If `TNode` would have `previous` this would not be necessary.)
- * @param newTNode A TNode to add to the `previousTNodes` list.
- */
-function addTNodeAndUpdateInsertBeforeIndex(previousTNodes, newTNode) {
-    // Start with Rule1
-    ngDevMode &&
-        assertEqual(newTNode.insertBeforeIndex, null, 'We expect that insertBeforeIndex is not set');
-    previousTNodes.push(newTNode);
-    if (previousTNodes.length > 1) {
-        for (let i = previousTNodes.length - 2; i >= 0; i--) {
-            const existingTNode = previousTNodes[i];
-            // Text nodes are created eagerly and so they don't need their `indexBeforeIndex` updated.
-            // It is safe to ignore them.
-            if (!isI18nText(existingTNode)) {
-                if (isNewTNodeCreatedBefore(existingTNode, newTNode) &&
-                    getInsertBeforeIndex(existingTNode) === null) {
-                    // If it was created before us in time, (and it does not yet have `insertBeforeIndex`)
-                    // then add the `insertBeforeIndex`.
-                    setInsertBeforeIndex(existingTNode, newTNode.index);
-                }
-            }
-        }
-    }
-}
-function isI18nText(tNode) {
-    return !(tNode.type & 64 /* TNodeType.Placeholder */);
-}
-function isNewTNodeCreatedBefore(existingTNode, newTNode) {
-    return isI18nText(newTNode) || existingTNode.index > newTNode.index;
-}
-function getInsertBeforeIndex(tNode) {
-    const index = tNode.insertBeforeIndex;
-    return Array.isArray(index) ? index[0] : index;
-}
-function setInsertBeforeIndex(tNode, value) {
-    const index = tNode.insertBeforeIndex;
-    if (Array.isArray(index)) {
-        // Array is stored if we have to insert child nodes. See `TNode.insertBeforeIndex`
-        index[0] = value;
-    }
-    else {
-        setI18nHandling(getInsertInFrontOfRNodeWithI18n, processI18nInsertBefore);
-        tNode.insertBeforeIndex = value;
-    }
-}
-
-/**
- * Retrieve `TIcu` at a given `index`.
- *
- * The `TIcu` can be stored either directly (if it is nested ICU) OR
- * it is stored inside tho `TIcuContainer` if it is top level ICU.
- *
- * The reason for this is that the top level ICU need a `TNode` so that they are part of the render
- * tree, but nested ICU's have no TNode, because we don't know ahead of time if the nested ICU is
- * expressed (parent ICU may have selected a case which does not contain it.)
- *
- * @param tView Current `TView`.
- * @param index Index where the value should be read from.
- */
-function getTIcu(tView, index) {
-    const value = tView.data[index];
-    if (value === null || typeof value === 'string')
-        return null;
-    if (ngDevMode &&
-        !(value.hasOwnProperty('tView') || value.hasOwnProperty('currentCaseLViewIndex'))) {
-        throwError('We expect to get \'null\'|\'TIcu\'|\'TIcuContainer\', but got: ' + value);
-    }
-    // Here the `value.hasOwnProperty('currentCaseLViewIndex')` is a polymorphic read as it can be
-    // either TIcu or TIcuContainerNode. This is not ideal, but we still think it is OK because it
-    // will be just two cases which fits into the browser inline cache (inline cache can take up to
-    // 4)
-    const tIcu = value.hasOwnProperty('currentCaseLViewIndex') ? value :
-        value.value;
-    ngDevMode && assertTIcu(tIcu);
-    return tIcu;
-}
-/**
- * Store `TIcu` at a give `index`.
- *
- * The `TIcu` can be stored either directly (if it is nested ICU) OR
- * it is stored inside tho `TIcuContainer` if it is top level ICU.
- *
- * The reason for this is that the top level ICU need a `TNode` so that they are part of the render
- * tree, but nested ICU's have no TNode, because we don't know ahead of time if the nested ICU is
- * expressed (parent ICU may have selected a case which does not contain it.)
- *
- * @param tView Current `TView`.
- * @param index Index where the value should be stored at in `Tview.data`
- * @param tIcu The TIcu to store.
- */
-function setTIcu(tView, index, tIcu) {
-    const tNode = tView.data[index];
-    ngDevMode &&
-        assertEqual(tNode === null || tNode.hasOwnProperty('tView'), true, 'We expect to get \'null\'|\'TIcuContainer\'');
-    if (tNode === null) {
-        tView.data[index] = tIcu;
-    }
-    else {
-        ngDevMode && assertTNodeType(tNode, 32 /* TNodeType.Icu */);
-        tNode.value = tIcu;
-    }
-}
-/**
- * Set `TNode.insertBeforeIndex` taking the `Array` into account.
- *
- * See `TNode.insertBeforeIndex`
- */
-function setTNodeInsertBeforeIndex(tNode, index) {
-    ngDevMode && assertTNode(tNode);
-    let insertBeforeIndex = tNode.insertBeforeIndex;
-    if (insertBeforeIndex === null) {
-        setI18nHandling(getInsertInFrontOfRNodeWithI18n, processI18nInsertBefore);
-        insertBeforeIndex = tNode.insertBeforeIndex =
-            [null /* may be updated to number later */, index];
-    }
-    else {
-        assertEqual(Array.isArray(insertBeforeIndex), true, 'Expecting array here');
-        insertBeforeIndex.push(index);
-    }
-}
-/**
- * Create `TNode.type=TNodeType.Placeholder` node.
- *
- * See `TNodeType.Placeholder` for more information.
- */
-function createTNodePlaceholder(tView, previousTNodes, index) {
-    const tNode = createTNodeAtIndex(tView, index, 64 /* TNodeType.Placeholder */, null, null);
-    addTNodeAndUpdateInsertBeforeIndex(previousTNodes, tNode);
-    return tNode;
-}
-/**
- * Returns current ICU case.
- *
- * ICU cases are stored as index into the `TIcu.cases`.
- * At times it is necessary to communicate that the ICU case just switched and that next ICU update
- * should update all bindings regardless of the mask. In such a case the we store negative numbers
- * for cases which have just been switched. This function removes the negative flag.
- */
-function getCurrentICUCaseIndex(tIcu, lView) {
-    const currentCase = lView[tIcu.currentCaseLViewIndex];
-    return currentCase === null ? currentCase : (currentCase < 0 ? ~currentCase : currentCase);
-}
-function getParentFromIcuCreateOpCode(mergedCode) {
-    return mergedCode >>> 17 /* IcuCreateOpCode.SHIFT_PARENT */;
-}
-function getRefFromIcuCreateOpCode(mergedCode) {
-    return (mergedCode & 131070 /* IcuCreateOpCode.MASK_REF */) >>> 1 /* IcuCreateOpCode.SHIFT_REF */;
-}
-function getInstructionFromIcuCreateOpCode(mergedCode) {
-    return mergedCode & 1 /* IcuCreateOpCode.MASK_INSTRUCTION */;
-}
-function icuCreateOpCode(opCode, parentIdx, refIdx) {
-    ngDevMode && assertGreaterThanOrEqual(parentIdx, 0, 'Missing parent index');
-    ngDevMode && assertGreaterThan(refIdx, 0, 'Missing ref index');
-    return opCode | parentIdx << 17 /* IcuCreateOpCode.SHIFT_PARENT */ | refIdx << 1 /* IcuCreateOpCode.SHIFT_REF */;
-}
-
 /**
  * Keep track of which input bindings in `ɵɵi18nExp` have changed.
  *
@@ -23845,9 +24366,27 @@ let _locateOrCreateNode = (lView, index, textOrName, nodeType) => {
     return createNodeWithoutHydration(lView, textOrName, nodeType);
 };
 function locateOrCreateNodeImpl(lView, index, textOrName, nodeType) {
-    // TODO: Add support for hydration
-    lastNodeWasCreated(true);
-    return createNodeWithoutHydration(lView, textOrName, nodeType);
+    const hydrationInfo = lView[HYDRATION];
+    const noOffsetIndex = index - HEADER_OFFSET;
+    const isNodeCreationMode = !isI18nHydrationSupportEnabled() || !hydrationInfo ||
+        isInSkipHydrationBlock$1() || isDisconnectedNode$1(hydrationInfo, noOffsetIndex);
+    lastNodeWasCreated(isNodeCreationMode);
+    if (isNodeCreationMode) {
+        return createNodeWithoutHydration(lView, textOrName, nodeType);
+    }
+    const native = locateI18nRNodeByIndex(hydrationInfo, noOffsetIndex);
+    // TODO: Improve error handling
+    //
+    // Other hydration paths use validateMatchingNode() in order to provide
+    // detailed information in development mode about the expected DOM.
+    // However, not every node in an i18n block has a TNode. Instead, we
+    // need to be able to use the AST to generate a similar message.
+    ngDevMode && assertDefined(native, 'expected native element');
+    ngDevMode && assertEqual(native.nodeType, nodeType, 'expected matching nodeType');
+    ngDevMode && nodeType === Node.ELEMENT_NODE &&
+        assertEqual(native.tagName.toLowerCase(), textOrName.toLowerCase(), 'expecting matching tagName');
+    ngDevMode && markRNodeAsClaimedByHydration(native);
+    return native;
 }
 function enableLocateOrCreateI18nNodeImpl() {
     _locateOrCreateNode = locateOrCreateNodeImpl;
@@ -24139,6 +24678,7 @@ function applyIcuSwitchCase(tView, tIcu, lView, value) {
                 ngDevMode && assertDomNode(anchorRNode);
                 applyMutableOpCodes(tView, tIcu.create[caseIndex], lView, anchorRNode);
             }
+            claimDehydratedIcuCase(lView, tIcu.anchorIdx, caseIndex);
         }
     }
 }
@@ -24789,9 +25329,6 @@ function countBindings(opCodes) {
 function toMaskBit(bindingIndex) {
     return 1 << Math.min(bindingIndex, 31);
 }
-function isRootTemplateMessage(subTemplateIndex) {
-    return subTemplateIndex === -1;
-}
 /**
  * Removes everything inside the sub-templates of a message.
  */
@@ -25295,6 +25832,7 @@ function ɵɵi18nStart(index, messageIndex, subTemplateIndex = -1) {
     const insertInFrontOf = parentTNode && (parentTNode.type & 8 /* TNodeType.ElementContainer */) ?
         lView[parentTNode.index] :
         null;
+    prepareI18nBlockForHydration(lView, adjustedIndex, parentTNode, subTemplateIndex);
     applyCreateOpCodes(lView, tI18n.create, parentRNode, insertInFrontOf);
     setInI18nBlock(true);
 }
@@ -25737,30 +26275,52 @@ function ɵɵprojectionDef(projectionSlots) {
  * Inserts previously re-distributed projected nodes. This instruction must be preceded by a call
  * to the projectionDef instruction.
  *
- * @param nodeIndex
- * @param selectorIndex:
- *        - 0 when the selector is `*` (or unspecified as this is the default value),
- *        - 1 based index of the selector from the {@link projectionDef}
+ * @param nodeIndex Index of the projection node.
+ * @param selectorIndex Index of the slot selector.
+ *  - 0 when the selector is `*` (or unspecified as this is the default value),
+ *  - 1 based index of the selector from the {@link projectionDef}
+ * @param attrs Static attributes set on the `ng-content` node.
+ * @param fallbackTemplateFn Template function with fallback content.
+ *   Will be rendered if the slot is empty at runtime.
+ * @param fallbackDecls Number of declarations in the fallback template.
+ * @param fallbackVars Number of variables in the fallback template.
  *
  * @codeGenApi
  */
-function ɵɵprojection(nodeIndex, selectorIndex = 0, attrs) {
+function ɵɵprojection(nodeIndex, selectorIndex = 0, attrs, fallbackTemplateFn, fallbackDecls, fallbackVars) {
     const lView = getLView();
     const tView = getTView();
     const tProjectionNode = getOrCreateTNode(tView, HEADER_OFFSET + nodeIndex, 16 /* TNodeType.Projection */, null, attrs || null);
     // We can't use viewData[HOST_NODE] because projection nodes can be nested in embedded views.
-    if (tProjectionNode.projection === null)
+    if (tProjectionNode.projection === null) {
         tProjectionNode.projection = selectorIndex;
-    // `<ng-content>` has no content
+    }
+    // `<ng-content>` has no content. Even if there's fallback
+    // content, the fallback is shown next to it.
     setCurrentTNodeAsNotParent();
     const hydrationInfo = lView[HYDRATION];
     const isNodeCreationMode = !hydrationInfo || isInSkipHydrationBlock$1();
-    if (isNodeCreationMode &&
+    const componentHostNode = lView[DECLARATION_COMPONENT_VIEW][T_HOST];
+    const isEmpty = componentHostNode.projection[tProjectionNode.projection] === null;
+    if (isEmpty && fallbackTemplateFn) {
+        insertFallbackContent(lView, tView, nodeIndex, fallbackTemplateFn, fallbackDecls, fallbackVars, attrs);
+    }
+    else if (isNodeCreationMode &&
         (tProjectionNode.flags & 32 /* TNodeFlags.isDetached */) !== 32 /* TNodeFlags.isDetached */) {
         // re-distribution of projectable nodes is stored on a component's view level
         applyProjection(tView, lView, tProjectionNode);
     }
 }
+/** Inserts the fallback content of a projection slot. Assumes there's no projected content. */
+function insertFallbackContent(lView, tView, projectionIndex, templateFn, decls, vars, attrs) {
+    const fallbackIndex = projectionIndex + 1;
+    const fallbackTNode = declareTemplate(lView, tView, fallbackIndex, templateFn, decls, vars, null, attrs);
+    const fallbackLContainer = lView[HEADER_OFFSET + fallbackIndex];
+    ngDevMode && assertLContainer(fallbackLContainer);
+    const dehydratedView = findMatchingDehydratedView(fallbackLContainer, fallbackTNode.tView.ssrId);
+    const fallbackLView = createAndRenderEmbeddedLView(lView, fallbackTNode, undefined, { dehydratedView });
+    addLViewToLContainer(fallbackLContainer, fallbackLView, 0, shouldAddViewToDom(fallbackTNode, dehydratedView));
+}
 
 /**
  *
@@ -29804,7 +30364,7 @@ class Version {
 /**
  * @publicApi
  */
-const VERSION = new Version('18.0.0-next.1');
+const VERSION = new Version('18.0.0-next.3');
 
 class Console {
     log(message) {
@@ -29987,7 +30547,7 @@ function handleInstanceCreatedByInjectorEvent(context, data) {
     }
     const environmentInjector = context.injector.get(EnvironmentInjector, null, { optional: true });
     // Standalone components should have an environment injector. If one cannot be
-    // found we may be in a test case for low level functionality that did not explictly
+    // found we may be in a test case for low level functionality that did not explicitly
     // setup this injector. In those cases, we simply ignore this event.
     if (environmentInjector === null) {
         return;
@@ -30566,8 +31126,11 @@ function getInjectorParent(injector) {
     else if (injector instanceof NullInjector) {
         return null;
     }
+    else if (injector instanceof ChainedInjector) {
+        return injector.parentInjector;
+    }
     else {
-        throwError('getInjectorParent only support injectors of type R3Injector, NodeInjector, NullInjector');
+        throwError('getInjectorParent only support injectors of type R3Injector, NodeInjector, NullInjector, ChainedInjector');
     }
     const parentLocation = getParentInjectorLocation(tNode, lView);
     if (hasParentInjector(parentLocation)) {
@@ -30584,7 +31147,7 @@ function getInjectorParent(injector) {
         // todo(aleksanderbodurri): ideally nothing in packages/core should deal
         // directly with router concerns. Refactor this so that we can make the jump from
         // NodeInjector -> OutletInjector -> NodeInjector
-        // without explictly relying on types contracts from packages/router
+        // without explicitly relying on types contracts from packages/router
         const injectorParent = chainedInjector.injector?.parent;
         if (injectorParent instanceof NodeInjector) {
             return injectorParent;
@@ -30606,8 +31169,8 @@ function getModuleInjectorOfNodeInjector(injector) {
     else {
         throwError('getModuleInjectorOfNodeInjector must be called with a NodeInjector');
     }
-    const chainedInjector = lView[INJECTOR];
-    const moduleInjector = chainedInjector.parentInjector;
+    const inj = lView[INJECTOR];
+    const moduleInjector = (inj instanceof ChainedInjector) ? inj.parentInjector : inj.parent;
     if (!moduleInjector) {
         throwError('NodeInjector must have some connection to the module injector tree');
     }
@@ -30985,7 +31548,7 @@ function isSubscribable(obj) {
 }
 
 /**
- * A [DI token](guide/glossary#di-token "DI token definition") that you can use to provide
+ * A DI token that you can use to provide
  * one or more initialization functions.
  *
  * The provided functions are injected at application startup and executed during
@@ -31169,7 +31732,7 @@ class ApplicationInitStatus {
     }], () => [], null); })();
 
 /**
- * A [DI token](guide/glossary#di-token "DI token definition") that provides a set of callbacks to
+ * A DI token that provides a set of callbacks to
  * be called for every component that is bootstrapped.
  *
  * Each callback must take a `ComponentRef` instance and return nothing.
@@ -31336,6 +31899,7 @@ class ApplicationRef {
         this._views = [];
         this.internalErrorHandler = inject(INTERNAL_APPLICATION_ERROR_HANDLER);
         this.afterRenderEffectManager = inject(AfterRenderEventManager);
+        this.zonelessEnabled = inject(ZONELESS_ENABLED);
         // Needed for ComponentFixture temporarily during migration of autoDetect behavior
         // Eventually the hostView of the fixture should just attach to ApplicationRef.
         this.externalTestViews = new Set();
@@ -31493,20 +32057,20 @@ class ApplicationRef {
                 const isFirstPass = runs === 0;
                 this.beforeRender.next(isFirstPass);
                 for (let { _lView, notifyErrorHandler } of this._views) {
-                    detectChangesInViewIfRequired(_lView, isFirstPass, notifyErrorHandler);
+                    detectChangesInViewIfRequired(_lView, notifyErrorHandler, isFirstPass, this.zonelessEnabled);
                 }
             }
             runs++;
             afterRenderEffectManager.executeInternalCallbacks();
             // If we have a newly dirty view after running internal callbacks, recheck the views again
             // before running user-provided callbacks
-            if ([...this.externalTestViews.keys(), ...this._views].some(({ _lView }) => shouldRecheckView(_lView))) {
+            if ([...this.externalTestViews.keys(), ...this._views].some(({ _lView }) => requiresRefreshOrTraversal(_lView))) {
                 continue;
             }
             afterRenderEffectManager.execute();
             // If after running all afterRender callbacks we have no more views that need to be refreshed,
             // we can break out of the loop
-            if (![...this.externalTestViews.keys(), ...this._views].some(({ _lView }) => shouldRecheckView(_lView))) {
+            if (![...this.externalTestViews.keys(), ...this._views].some(({ _lView }) => requiresRefreshOrTraversal(_lView))) {
                 break;
             }
         }
@@ -31639,18 +32203,12 @@ function whenStable(applicationRef) {
     applicationRef.onDestroy(() => whenStableStore?.delete(applicationRef));
     return whenStablePromise;
 }
-function detectChangesInViewIfRequired(lView, isFirstPass, notifyErrorHandler) {
+function detectChangesInViewIfRequired(lView, notifyErrorHandler, isFirstPass, zonelessEnabled) {
     // When re-checking, only check views which actually need it.
-    if (!isFirstPass && !shouldRecheckView(lView)) {
+    if (!isFirstPass && !requiresRefreshOrTraversal(lView)) {
         return;
     }
-    detectChangesInView(lView, notifyErrorHandler, isFirstPass);
-}
-function shouldRecheckView(view) {
-    return requiresRefreshOrTraversal(view);
-}
-function detectChangesInView(lView, notifyErrorHandler, isFirstPass) {
-    const mode = isFirstPass || lView[FLAGS] & 64 /* LViewFlags.Dirty */ ?
+    const mode = (isFirstPass && !zonelessEnabled) ?
         0 /* ChangeDetectionMode.Global */ :
         1 /* ChangeDetectionMode.Targeted */;
     detectChangesInternal(lView, notifyErrorHandler, mode);
@@ -31809,9 +32367,130 @@ function _lastDefined(args) {
     return undefined;
 }
 
+class ChangeDetectionSchedulerImpl {
+    constructor() {
+        this.appRef = inject(ApplicationRef);
+        this.taskService = inject(PendingTasks);
+        this.pendingRenderTaskId = null;
+        this.shouldRefreshViews = false;
+        this.ngZone = inject(NgZone);
+        this.runningTick = false;
+        this.cancelScheduledCallback = null;
+        this.zonelessEnabled = inject(ZONELESS_ENABLED);
+        this.disableScheduling = inject(ZONELESS_SCHEDULER_DISABLED, { optional: true }) ?? false;
+        this.zoneIsDefined = typeof Zone !== 'undefined';
+        // 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(type = 0 /* NotificationType.RefreshViews */) {
+        // When the only source of notification is an afterRender hook will skip straight to the hooks
+        // rather than refreshing views in ApplicationRef.tick
+        this.shouldRefreshViews ||= type === 0 /* NotificationType.RefreshViews */;
+        if (!this.shouldScheduleTick()) {
+            return;
+        }
+        this.pendingRenderTaskId = this.taskService.add();
+        // TODO(atscott): This zone.root.run can maybe just be removed when we more
+        // effectively get the unpatched versions of setTimeout and rAF (#55092)
+        if (typeof Zone !== 'undefined' && Zone.root?.run) {
+            Zone.root.run(() => {
+                this.cancelScheduledCallback = scheduleCallback(() => {
+                    this.tick(this.shouldRefreshViews);
+                });
+            });
+        }
+        else {
+            this.cancelScheduledCallback = scheduleCallback(() => {
+                this.tick(this.shouldRefreshViews);
+            });
+        }
+    }
+    shouldScheduleTick() {
+        if (this.disableScheduling) {
+            return false;
+        }
+        // already scheduled or running
+        if (this.pendingRenderTaskId !== null || this.runningTick) {
+            return false;
+        }
+        // If we're inside the zone don't bother with scheduler. Zone will stabilize
+        // eventually and run change detection.
+        if (this.zoneIsDefined && NgZone.isInAngularZone()) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Calls ApplicationRef._tick inside the `NgZone`.
+     *
+     * Calling `tick` directly runs change detection and cancels any change detection that had been
+     * scheduled previously.
+     *
+     * @param shouldRefreshViews Passed directly to `ApplicationRef._tick` and skips straight to
+     *     render hooks when `false`.
+     */
+    tick(shouldRefreshViews) {
+        // When ngZone.run below exits, onMicrotaskEmpty may emit if the zone is
+        // stable. We want to prevent double ticking so we track whether the tick is
+        // already running and skip it if so.
+        if (this.runningTick || this.appRef.destroyed) {
+            return;
+        }
+        try {
+            this.ngZone.run(() => {
+                this.runningTick = true;
+                this.appRef._tick(shouldRefreshViews);
+            });
+        }
+        finally {
+            this.cleanup();
+        }
+    }
+    ngOnDestroy() {
+        this.cleanup();
+    }
+    cleanup() {
+        this.shouldRefreshViews = false;
+        this.runningTick = false;
+        this.cancelScheduledCallback?.();
+        this.cancelScheduledCallback = null;
+        // If this is the last task, the service will synchronously emit a stable
+        // notification. If there is a subscriber that then acts in a way that
+        // tries to notify the scheduler again, we need to be able to respond to
+        // schedule a new change detection. Therefore, we should clear the task ID
+        // before removing it from the pending tasks (or the tasks service should
+        // not synchronously emit stable, similar to how Zone stableness only
+        // happens if it's still stable after a microtask).
+        if (this.pendingRenderTaskId !== null) {
+            const taskId = this.pendingRenderTaskId;
+            this.pendingRenderTaskId = null;
+            this.taskService.remove(taskId);
+        }
+    }
+    static { this.ɵfac = function ChangeDetectionSchedulerImpl_Factory(t) { return new (t || ChangeDetectionSchedulerImpl)(); }; }
+    static { this.ɵprov = /*@__PURE__*/ ɵɵdefineInjectable({ token: ChangeDetectionSchedulerImpl, factory: ChangeDetectionSchedulerImpl.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(ChangeDetectionSchedulerImpl, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], () => [], null); })();
+function provideZonelessChangeDetection() {
+    return makeEnvironmentProviders([
+        { provide: ChangeDetectionScheduler, useExisting: ChangeDetectionSchedulerImpl },
+        { provide: NgZone, useClass: NoopNgZone },
+        { provide: ZONELESS_ENABLED, useValue: true },
+    ]);
+}
+
 class NgZoneChangeDetectionScheduler {
     constructor() {
         this.zone = inject(NgZone);
+        this.changeDetectionScheduler = inject(ChangeDetectionScheduler, { optional: true });
         this.applicationRef = inject(ApplicationRef);
     }
     initialize() {
@@ -31821,7 +32500,12 @@ class NgZoneChangeDetectionScheduler {
         this._onMicrotaskEmptySubscription = this.zone.onMicrotaskEmpty.subscribe({
             next: () => {
                 this.zone.run(() => {
-                    this.applicationRef.tick();
+                    if (this.changeDetectionScheduler) {
+                        this.changeDetectionScheduler.tick(true /* shouldRefreshViews */);
+                    }
+                    else {
+                        this.applicationRef.tick();
+                    }
                 });
             }
         });
@@ -31841,7 +32525,24 @@ class NgZoneChangeDetectionScheduler {
  * with the bootstrapModule API.
  */
 const PROVIDED_NG_ZONE = new InjectionToken((typeof ngDevMode === 'undefined' || ngDevMode) ? 'provideZoneChangeDetection token' : '');
-function internalProvideZoneChangeDetection(ngZoneFactory) {
+/**
+ * Configures change detection scheduling when using ZoneJS.
+ */
+var SchedulingMode;
+(function (SchedulingMode) {
+    /**
+     * Change detection will run when the `NgZone.onMicrotaskEmpty` observable emits.
+     * Change detection will also be scheduled to run whenever Angular is notified
+     * of a change. This includes calling `ChangeDetectorRef.markForCheck`,
+     * setting a `signal` value, and attaching a view.
+     */
+    SchedulingMode[SchedulingMode["Hybrid"] = 0] = "Hybrid";
+    /**
+     * Change detection will only run when the `NgZone.onMicrotaskEmpty` observable emits.
+     */
+    SchedulingMode[SchedulingMode["NgZoneOnly"] = 1] = "NgZoneOnly";
+})(SchedulingMode || (SchedulingMode = {}));
+function internalProvideZoneChangeDetection({ ngZoneFactory, schedulingMode }) {
     return [
         { provide: NgZone, useFactory: ngZoneFactory },
         {
@@ -31868,6 +32569,14 @@ function internalProvideZoneChangeDetection(ngZoneFactory) {
             }
         },
         { provide: INTERNAL_APPLICATION_ERROR_HANDLER, useFactory: ngZoneApplicationErrorHandlerFactory },
+        // Always disable scheduler whenever explicitly disabled, even if Hybrid was specified elsewhere
+        schedulingMode === SchedulingMode.NgZoneOnly ?
+            { provide: ZONELESS_SCHEDULER_DISABLED, useValue: true } :
+            [],
+        // Only provide scheduler when explicitly enabled
+        schedulingMode === SchedulingMode.Hybrid ?
+            { provide: ChangeDetectionScheduler, useExisting: ChangeDetectionSchedulerImpl } :
+            [],
     ];
 }
 function ngZoneApplicationErrorHandlerFactory() {
@@ -31896,7 +32605,8 @@ function ngZoneApplicationErrorHandlerFactory() {
  * @see {@link NgZoneOptions}
  */
 function provideZoneChangeDetection(options) {
-    const zoneProviders = internalProvideZoneChangeDetection(() => new NgZone(getNgZoneOptions(options)));
+    const schedulingMode = options?.schedulingMode;
+    const zoneProviders = internalProvideZoneChangeDetection({ ngZoneFactory: () => new NgZone(getNgZoneOptions(options)), schedulingMode });
     return makeEnvironmentProviders([
         (typeof ngDevMode === 'undefined' || ngDevMode) ? { provide: PROVIDED_NG_ZONE, useValue: true } :
             [],
@@ -32174,7 +32884,8 @@ class PlatformRef {
         // Do not try to replace ngZone.run with ApplicationRef#run because ApplicationRef would then be
         // created outside of the Angular zone.
         return ngZone.run(() => {
-            const moduleRef = createNgModuleRefWithProviders(moduleFactory.moduleType, this.injector, internalProvideZoneChangeDetection(() => ngZone));
+            const schedulingMode = options?.schedulingMode;
+            const moduleRef = createNgModuleRefWithProviders(moduleFactory.moduleType, this.injector, internalProvideZoneChangeDetection({ ngZoneFactory: () => ngZone, schedulingMode }));
             if ((typeof ngDevMode === 'undefined' || ngDevMode) &&
                 moduleRef.injector.get(PROVIDED_NG_ZONE, null) !== null) {
                 throw new RuntimeError(207 /* RuntimeErrorCode.PROVIDER_IN_WRONG_CONTEXT */, '`bootstrapModule` does not support `provideZoneChangeDetection`. Use `BootstrapOptions` instead.');
@@ -32556,7 +33267,7 @@ function createViewRef(tNode, lView, isPipe) {
 }
 
 /**
- * Represents an Angular [view](guide/glossary#view "Definition").
+ * Represents an Angular view.
  *
  * @see {@link ChangeDetectorRef#usage-notes Change detection usage}
  *
@@ -32565,8 +33276,8 @@ function createViewRef(tNode, lView, isPipe) {
 class ViewRef extends ChangeDetectorRef {
 }
 /**
- * Represents an Angular [view](guide/glossary#view) in a view container.
- * An [embedded view](guide/glossary#view-hierarchy) can be referenced from a component
+ * Represents an Angular view in a view container.
+ * An embedded view can be referenced from a component
  * other than the hosting component whose template defines it, or it can be defined
  * independently by a `TemplateRef`.
  *
@@ -35043,59 +35754,6 @@ function internalCreateApplication(config) {
     }
 }
 
-class ChangeDetectionSchedulerImpl {
-    constructor() {
-        this.appRef = inject(ApplicationRef);
-        this.taskService = inject(PendingTasks);
-        this.pendingRenderTaskId = null;
-        this.shouldRefreshViews = false;
-        this.schedule = getCallbackScheduler();
-    }
-    notify(type = 0 /* NotificationType.RefreshViews */) {
-        // When the only source of notification is an afterRender hook will skip straight to the hooks
-        // rather than refreshing views in ApplicationRef.tick
-        this.shouldRefreshViews ||= type === 0 /* NotificationType.RefreshViews */;
-        if (this.pendingRenderTaskId !== null) {
-            return;
-        }
-        this.pendingRenderTaskId = this.taskService.add();
-        this.schedule(() => {
-            this.tick();
-        });
-    }
-    tick() {
-        try {
-            if (!this.appRef.destroyed) {
-                this.appRef._tick(this.shouldRefreshViews);
-            }
-        }
-        finally {
-            this.shouldRefreshViews = false;
-            // If this is the last task, the service will synchronously emit a stable notification. If
-            // there is a subscriber that then acts in a way that tries to notify the scheduler again,
-            // we need to be able to respond to schedule a new change detection. Therefore, we should
-            // clear the task ID before removing it from the pending tasks (or the tasks service should
-            // not synchronously emit stable, similar to how Zone stableness only happens if it's still
-            // stable after a microtask).
-            const taskId = this.pendingRenderTaskId;
-            this.pendingRenderTaskId = null;
-            this.taskService.remove(taskId);
-        }
-    }
-    static { this.ɵfac = function ChangeDetectionSchedulerImpl_Factory(t) { return new (t || ChangeDetectionSchedulerImpl)(); }; }
-    static { this.ɵprov = /*@__PURE__*/ ɵɵdefineInjectable({ token: ChangeDetectionSchedulerImpl, factory: ChangeDetectionSchedulerImpl.ɵfac, providedIn: 'root' }); }
-}
-(() => { (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(ChangeDetectionSchedulerImpl, [{
-        type: Injectable,
-        args: [{ providedIn: 'root' }]
-    }], null, null); })();
-function provideZonelessChangeDetection() {
-    return makeEnvironmentProviders([
-        { provide: ChangeDetectionScheduler, useExisting: ChangeDetectionSchedulerImpl },
-        { provide: NgZone, useClass: NoopNgZone },
-    ]);
-}
-
 /**
  * Retrieves all defer blocks in a given LView.
  *
@@ -35132,226 +35790,6 @@ function getDeferBlocks(lView, deferBlocks) {
     }
 }
 
-/**
- * Indicates whether the hydration-related code was added,
- * prevents adding it multiple times.
- */
-let isHydrationSupportEnabled = false;
-/**
- * Indicates whether support for hydrating i18n blocks is enabled.
- */
-let _isI18nHydrationSupportEnabled = false;
-/**
- * Defines a period of time that Angular waits for the `ApplicationRef.isStable` to emit `true`.
- * If there was no event with the `true` value during this time, Angular reports a warning.
- */
-const APPLICATION_IS_STABLE_TIMEOUT = 10_000;
-/**
- * Brings the necessary hydration code in tree-shakable manner.
- * The code is only present when the `provideClientHydration` is
- * invoked. Otherwise, this code is tree-shaken away during the
- * build optimization step.
- *
- * This technique allows us to swap implementations of methods so
- * tree shaking works appropriately when hydration is disabled or
- * enabled. It brings in the appropriate version of the method that
- * supports hydration only when enabled.
- */
-function enableHydrationRuntimeSupport() {
-    if (!isHydrationSupportEnabled) {
-        isHydrationSupportEnabled = true;
-        enableRetrieveHydrationInfoImpl();
-        enableLocateOrCreateElementNodeImpl();
-        enableLocateOrCreateTextNodeImpl();
-        enableLocateOrCreateElementContainerNodeImpl();
-        enableLocateOrCreateContainerAnchorImpl();
-        enableLocateOrCreateContainerRefImpl();
-        enableFindMatchingDehydratedViewImpl();
-        enableApplyRootElementTransformImpl();
-        enableLocateOrCreateI18nNodeImpl();
-    }
-}
-/**
- * Outputs a message with hydration stats into a console.
- */
-function printHydrationStats(injector) {
-    const console = injector.get(Console);
-    const message = `Angular hydrated ${ngDevMode.hydratedComponents} component(s) ` +
-        `and ${ngDevMode.hydratedNodes} node(s), ` +
-        `${ngDevMode.componentsSkippedHydration} component(s) were skipped. ` +
-        `Learn more at https://angular.io/guide/hydration.`;
-    // tslint:disable-next-line:no-console
-    console.log(message);
-}
-/**
- * Returns a Promise that is resolved when an application becomes stable.
- */
-function whenStableWithTimeout(appRef, injector) {
-    const whenStablePromise = whenStable(appRef);
-    if (typeof ngDevMode !== 'undefined' && ngDevMode) {
-        const timeoutTime = APPLICATION_IS_STABLE_TIMEOUT;
-        const console = injector.get(Console);
-        const ngZone = injector.get(NgZone);
-        // The following call should not and does not prevent the app to become stable
-        // We cannot use RxJS timer here because the app would remain unstable.
-        // This also avoids an extra change detection cycle.
-        const timeoutId = ngZone.runOutsideAngular(() => {
-            return setTimeout(() => logWarningOnStableTimedout(timeoutTime, console), timeoutTime);
-        });
-        whenStablePromise.finally(() => clearTimeout(timeoutId));
-    }
-    return whenStablePromise;
-}
-/**
- * Returns a set of providers required to setup hydration support
- * for an application that is server side rendered. This function is
- * included into the `provideClientHydration` public API function from
- * the `platform-browser` package.
- *
- * The function sets up an internal flag that would be recognized during
- * the server side rendering time as well, so there is no need to
- * configure or change anything in NgUniversal to enable the feature.
- */
-function withDomHydration() {
-    return makeEnvironmentProviders([
-        {
-            provide: IS_HYDRATION_DOM_REUSE_ENABLED,
-            useFactory: () => {
-                let isEnabled = true;
-                if (isPlatformBrowser()) {
-                    // On the client, verify that the server response contains
-                    // hydration annotations. Otherwise, keep hydration disabled.
-                    const transferState = inject(TransferState, { optional: true });
-                    isEnabled = !!transferState?.get(NGH_DATA_KEY, null);
-                    if (!isEnabled && (typeof ngDevMode !== 'undefined' && ngDevMode)) {
-                        const console = inject(Console);
-                        const message = formatRuntimeError(-505 /* RuntimeErrorCode.MISSING_HYDRATION_ANNOTATIONS */, 'Angular hydration was requested on the client, but there was no ' +
-                            'serialized information present in the server response, ' +
-                            'thus hydration was not enabled. ' +
-                            'Make sure the `provideClientHydration()` is included into the list ' +
-                            'of providers in the server part of the application configuration.');
-                        // tslint:disable-next-line:no-console
-                        console.warn(message);
-                    }
-                }
-                if (isEnabled) {
-                    performanceMarkFeature('NgHydration');
-                }
-                return isEnabled;
-            },
-        },
-        {
-            provide: ENVIRONMENT_INITIALIZER,
-            useValue: () => {
-                _isI18nHydrationSupportEnabled = !!inject(IS_I18N_HYDRATION_ENABLED, { optional: true });
-                // Since this function is used across both server and client,
-                // make sure that the runtime code is only added when invoked
-                // on the client. Moving forward, the `isPlatformBrowser` check should
-                // be replaced with a tree-shakable alternative (e.g. `isServer`
-                // flag).
-                if (isPlatformBrowser() && inject(IS_HYDRATION_DOM_REUSE_ENABLED)) {
-                    verifySsrContentsIntegrity();
-                    enableHydrationRuntimeSupport();
-                }
-            },
-            multi: true,
-        },
-        {
-            provide: PRESERVE_HOST_CONTENT,
-            useFactory: () => {
-                // Preserve host element content only in a browser
-                // environment and when hydration is configured properly.
-                // On a server, an application is rendered from scratch,
-                // so the host content needs to be empty.
-                return isPlatformBrowser() && inject(IS_HYDRATION_DOM_REUSE_ENABLED);
-            }
-        },
-        {
-            provide: APP_BOOTSTRAP_LISTENER,
-            useFactory: () => {
-                if (isPlatformBrowser() && inject(IS_HYDRATION_DOM_REUSE_ENABLED)) {
-                    const appRef = inject(ApplicationRef);
-                    const injector = inject(Injector);
-                    return () => {
-                        // Wait until an app becomes stable and cleanup all views that
-                        // were not claimed during the application bootstrap process.
-                        // The timing is similar to when we start the serialization process
-                        // on the server.
-                        //
-                        // Note: the cleanup task *MUST* be scheduled within the Angular zone
-                        // to ensure that change detection is properly run afterward.
-                        whenStableWithTimeout(appRef, injector).then(() => {
-                            NgZone.assertInAngularZone();
-                            cleanupDehydratedViews(appRef);
-                            if (typeof ngDevMode !== 'undefined' && ngDevMode) {
-                                printHydrationStats(injector);
-                            }
-                        });
-                    };
-                }
-                return () => { }; // noop
-            },
-            multi: true,
-        }
-    ]);
-}
-/**
- * Returns a set of providers required to setup support for i18n hydration.
- * Requires hydration to be enabled separately.
- */
-function withI18nHydration() {
-    return makeEnvironmentProviders([
-        {
-            provide: IS_I18N_HYDRATION_ENABLED,
-            useValue: true,
-        },
-    ]);
-}
-/**
- * Returns whether i18n hydration support is enabled.
- */
-function isI18nHydrationSupportEnabled() {
-    return _isI18nHydrationSupportEnabled;
-}
-/**
- *
- * @param time The time in ms until the stable timedout warning message is logged
- */
-function logWarningOnStableTimedout(time, console) {
-    const message = `Angular hydration expected the ApplicationRef.isStable() to emit \`true\`, but it ` +
-        `didn't happen within ${time}ms. Angular hydration logic depends on the application becoming stable ` +
-        `as a signal to complete hydration process.`;
-    console.warn(formatRuntimeError(-506 /* RuntimeErrorCode.HYDRATION_STABLE_TIMEDOUT */, message));
-}
-/**
- * Verifies whether the DOM contains a special marker added during SSR time to make sure
- * there is no SSR'ed contents transformations happen after SSR is completed. Typically that
- * happens either by CDN or during the build process as an optimization to remove comment nodes.
- * Hydration process requires comment nodes produced by Angular to locate correct DOM segments.
- * When this special marker is *not* present - throw an error and do not proceed with hydration,
- * since it will not be able to function correctly.
- *
- * Note: this function is invoked only on the client, so it's safe to use DOM APIs.
- */
-function verifySsrContentsIntegrity() {
-    const doc = getDocument();
-    let hydrationMarker;
-    for (const node of doc.body.childNodes) {
-        if (node.nodeType === Node.COMMENT_NODE &&
-            node.textContent?.trim() === SSR_CONTENT_INTEGRITY_MARKER) {
-            hydrationMarker = node;
-            break;
-        }
-    }
-    if (!hydrationMarker) {
-        throw new RuntimeError(-507 /* RuntimeErrorCode.MISSING_SSR_CONTENT_INTEGRITY_MARKER */, typeof ngDevMode !== 'undefined' && ngDevMode &&
-            'Angular hydration logic detected that HTML content of this page was modified after it ' +
-                'was produced during server side rendering. Make sure that there are no optimizations ' +
-                'that remove comment nodes from HTML enabled on your CDN. Angular hydration ' +
-                'relies on HTML produced by the server, including whitespaces and comment nodes.');
-    }
-}
-
 /**
  * A collection that tracks all serialized views (`ngh` DOM annotations)
  * to avoid duplication. An attempt to add a duplicate view results in the
@@ -35462,6 +35900,8 @@ function annotateLContainerForHydration(lContainer, context) {
  * @param doc A reference to the current Document instance.
  */
 function annotateForHydration(appRef, doc) {
+    const injector = appRef.injector;
+    const isI18nHydrationEnabledVal = isI18nHydrationEnabled(injector);
     const serializedViewCollection = new SerializedViewCollection();
     const corruptedTextNodes = new Map();
     const viewRefs = appRef._views;
@@ -35473,6 +35913,8 @@ function annotateForHydration(appRef, doc) {
             const context = {
                 serializedViewCollection,
                 corruptedTextNodes,
+                isI18nHydrationEnabled: isI18nHydrationEnabledVal,
+                i18nChildren: new Map(),
             };
             if (isLContainer(lNode)) {
                 annotateLContainerForHydration(lNode, context);
@@ -35489,7 +35931,7 @@ function annotateForHydration(appRef, doc) {
     // hydration logic was setup and enabled correctly. Otherwise, if a client
     // hydration doesn't find a key in the transfer state - an error is produced.
     const serializedViews = serializedViewCollection.getAll();
-    const transferState = appRef.injector.get(TransferState);
+    const transferState = injector.get(TransferState);
     transferState.set(NGH_DATA_KEY, serializedViews);
 }
 /**
@@ -35570,10 +36012,10 @@ function serializeLContainer(lContainer, context) {
  * needs to take to locate a node) and stores it in the `NODES` section of the
  * current serialized view.
  */
-function appendSerializedNodePath(ngh, tNode, lView) {
+function appendSerializedNodePath(ngh, tNode, lView, excludedParentNodes) {
     const noOffsetIndex = tNode.index - HEADER_OFFSET;
     ngh[NODES] ??= {};
-    ngh[NODES][noOffsetIndex] = calcPathForNode(tNode, lView);
+    ngh[NODES][noOffsetIndex] = calcPathForNode(tNode, lView, excludedParentNodes);
 }
 /**
  * Helper function to append information about a disconnected node.
@@ -35599,10 +36041,19 @@ function appendDisconnectedNodeIndex(ngh, tNode) {
 function serializeLView(lView, context) {
     const ngh = {};
     const tView = lView[TVIEW];
+    const i18nChildren = getOrComputeI18nChildren(tView, context);
     // Iterate over DOM element references in an LView.
     for (let i = HEADER_OFFSET; i < tView.bindingStartIndex; i++) {
         const tNode = tView.data[i];
         const noOffsetIndex = i - HEADER_OFFSET;
+        // Attempt to serialize any i18n data for the given slot. We do this first, as i18n
+        // has its own process for serialization.
+        const i18nData = trySerializeI18nBlock(lView, i, context);
+        if (i18nData) {
+            ngh[I18N_DATA] ??= {};
+            ngh[I18N_DATA][noOffsetIndex] = i18nData;
+            continue;
+        }
         // Skip processing of a given slot in the following cases:
         // - Local refs (e.g. <div #localRef>) take up an extra slot in LViews
         //   to store the same element. In this case, there is no information in
@@ -35612,6 +36063,12 @@ function serializeLView(lView, context) {
         if (!isTNodeShape(tNode)) {
             continue;
         }
+        // Skip any nodes that are in an i18n block but are considered detached (i.e. not
+        // present in the template). These nodes are disconnected from the DOM tree, and
+        // so we don't want to serialize any information about them.
+        if (isDetachedByI18n(tNode)) {
+            continue;
+        }
         // Check if a native node that represents a given TNode is disconnected from the DOM tree.
         // Such nodes must be excluded from the hydration (since the hydration won't be able to
         // find them), so the TNode ids are collected and used at runtime to skip the hydration.
@@ -35643,7 +36100,7 @@ function serializeLView(lView, context) {
                             appendDisconnectedNodeIndex(ngh, projectionHeadTNode);
                         }
                         else {
-                            appendSerializedNodePath(ngh, projectionHeadTNode, lView);
+                            appendSerializedNodePath(ngh, projectionHeadTNode, lView, i18nChildren);
                         }
                     }
                 }
@@ -35660,7 +36117,7 @@ function serializeLView(lView, context) {
                 }
             }
         }
-        conditionallyAnnotateNodePath(ngh, tNode, lView);
+        conditionallyAnnotateNodePath(ngh, tNode, lView, i18nChildren);
         if (isLContainer(lView[i])) {
             // Serialize information about a template.
             const embeddedTView = tNode.tView;
@@ -35710,47 +36167,13 @@ function serializeLView(lView, context) {
                 }
                 if (nextTNode && !isInSkipHydrationBlock(nextTNode)) {
                     // Handle a tNode after the `<ng-content>` slot.
-                    appendSerializedNodePath(ngh, nextTNode, lView);
+                    appendSerializedNodePath(ngh, nextTNode, lView, i18nChildren);
                 }
             }
             else {
-                // Handle cases where text nodes can be lost after DOM serialization:
-                //  1. When there is an *empty text node* in DOM: in this case, this
-                //     node would not make it into the serialized string and as a result,
-                //     this node wouldn't be created in a browser. This would result in
-                //     a mismatch during the hydration, where the runtime logic would expect
-                //     a text node to be present in live DOM, but no text node would exist.
-                //     Example: `<span>{{ name }}</span>` when the `name` is an empty string.
-                //     This would result in `<span></span>` string after serialization and
-                //     in a browser only the `span` element would be created. To resolve that,
-                //     an extra comment node is appended in place of an empty text node and
-                //     that special comment node is replaced with an empty text node *before*
-                //     hydration.
-                //  2. When there are 2 consecutive text nodes present in the DOM.
-                //     Example: `<div>Hello <ng-container *ngIf="true">world</ng-container></div>`.
-                //     In this scenario, the live DOM would look like this:
-                //       <div>#text('Hello ') #text('world') #comment('container')</div>
-                //     Serialized string would look like this: `<div>Hello world<!--container--></div>`.
-                //     The live DOM in a browser after that would be:
-                //       <div>#text('Hello world') #comment('container')</div>
-                //     Notice how 2 text nodes are now "merged" into one. This would cause hydration
-                //     logic to fail, since it'd expect 2 text nodes being present, not one.
-                //     To fix this, we insert a special comment node in between those text nodes, so
-                //     serialized representation is: `<div>Hello <!--ngtns-->world<!--container--></div>`.
-                //     This forces browser to create 2 text nodes separated by a comment node.
-                //     Before running a hydration process, this special comment node is removed, so the
-                //     live DOM has exactly the same state as it was before serialization.
                 if (tNode.type & 1 /* TNodeType.Text */) {
                     const rNode = unwrapRNode(lView[i]);
-                    // Collect this node as required special annotation only when its
-                    // contents is empty. Otherwise, such text node would be present on
-                    // the client after server-side rendering and no special handling needed.
-                    if (rNode.textContent === '') {
-                        context.corruptedTextNodes.set(rNode, "ngetn" /* TextNodeMarker.EmptyNode */);
-                    }
-                    else if (rNode.nextSibling?.nodeType === Node.TEXT_NODE) {
-                        context.corruptedTextNodes.set(rNode, "ngtns" /* TextNodeMarker.Separator */);
-                    }
+                    processTextNodeBeforeSerialization(context, rNode);
                 }
             }
         }
@@ -35763,17 +36186,17 @@ function serializeLView(lView, context) {
  *  1. If `tNode.projectionNext` is different from `tNode.next` - it means that
  *     the next `tNode` after projection is different from the one in the original
  *     template. Since hydration relies on `tNode.next`, this serialized info
- *     if required to help runtime code find the node at the correct location.
+ *     is required to help runtime code find the node at the correct location.
  *  2. In certain content projection-based use-cases, it's possible that only
  *     a content of a projected element is rendered. In this case, content nodes
  *     require an extra annotation, since runtime logic can't rely on parent-child
  *     connection to identify the location of a node.
  */
-function conditionallyAnnotateNodePath(ngh, tNode, lView) {
+function conditionallyAnnotateNodePath(ngh, tNode, lView, excludedParentNodes) {
     // Handle case #1 described above.
     if (tNode.projectionNext && tNode.projectionNext !== tNode.next &&
         !isInSkipHydrationBlock(tNode.projectionNext)) {
-        appendSerializedNodePath(ngh, tNode.projectionNext, lView);
+        appendSerializedNodePath(ngh, tNode.projectionNext, lView, excludedParentNodes);
     }
     // Handle case #2 described above.
     // Note: we only do that for the first node (i.e. when `tNode.prev === null`),
@@ -35781,7 +36204,7 @@ function conditionallyAnnotateNodePath(ngh, tNode, lView) {
     // annotation is needed.
     if (tNode.prev === null && tNode.parent !== null && isDisconnectedNode(tNode.parent, lView) &&
         !isDisconnectedNode(tNode, lView)) {
-        appendSerializedNodePath(ngh, tNode, lView);
+        appendSerializedNodePath(ngh, tNode, lView, excludedParentNodes);
     }
 }
 /**
@@ -35857,6 +36280,248 @@ function isContentProjectedNode(tNode) {
     return false;
 }
 
+/**
+ * Indicates whether the hydration-related code was added,
+ * prevents adding it multiple times.
+ */
+let isHydrationSupportEnabled = false;
+/**
+ * Indicates whether the i18n-related code was added,
+ * prevents adding it multiple times.
+ *
+ * Note: This merely controls whether the code is loaded,
+ * while `setIsI18nHydrationSupportEnabled` determines
+ * whether i18n blocks are serialized or hydrated.
+ */
+let isI18nHydrationRuntimeSupportEnabled = false;
+/**
+ * Defines a period of time that Angular waits for the `ApplicationRef.isStable` to emit `true`.
+ * If there was no event with the `true` value during this time, Angular reports a warning.
+ */
+const APPLICATION_IS_STABLE_TIMEOUT = 10_000;
+/**
+ * Brings the necessary hydration code in tree-shakable manner.
+ * The code is only present when the `provideClientHydration` is
+ * invoked. Otherwise, this code is tree-shaken away during the
+ * build optimization step.
+ *
+ * This technique allows us to swap implementations of methods so
+ * tree shaking works appropriately when hydration is disabled or
+ * enabled. It brings in the appropriate version of the method that
+ * supports hydration only when enabled.
+ */
+function enableHydrationRuntimeSupport() {
+    if (!isHydrationSupportEnabled) {
+        isHydrationSupportEnabled = true;
+        enableRetrieveHydrationInfoImpl();
+        enableLocateOrCreateElementNodeImpl();
+        enableLocateOrCreateTextNodeImpl();
+        enableLocateOrCreateElementContainerNodeImpl();
+        enableLocateOrCreateContainerAnchorImpl();
+        enableLocateOrCreateContainerRefImpl();
+        enableFindMatchingDehydratedViewImpl();
+        enableApplyRootElementTransformImpl();
+    }
+}
+/**
+ * Brings the necessary i18n hydration code in tree-shakable manner.
+ * Similar to `enableHydrationRuntimeSupport`, the code is only
+ * present when `withI18nSupport` is invoked.
+ */
+function enableI18nHydrationRuntimeSupport() {
+    if (!isI18nHydrationRuntimeSupportEnabled) {
+        isI18nHydrationRuntimeSupportEnabled = true;
+        enableLocateOrCreateI18nNodeImpl();
+        enablePrepareI18nBlockForHydrationImpl();
+        enableClaimDehydratedIcuCaseImpl();
+    }
+}
+/**
+ * Outputs a message with hydration stats into a console.
+ */
+function printHydrationStats(injector) {
+    const console = injector.get(Console);
+    const message = `Angular hydrated ${ngDevMode.hydratedComponents} component(s) ` +
+        `and ${ngDevMode.hydratedNodes} node(s), ` +
+        `${ngDevMode.componentsSkippedHydration} component(s) were skipped. ` +
+        `Learn more at https://angular.io/guide/hydration.`;
+    // tslint:disable-next-line:no-console
+    console.log(message);
+}
+/**
+ * Returns a Promise that is resolved when an application becomes stable.
+ */
+function whenStableWithTimeout(appRef, injector) {
+    const whenStablePromise = whenStable(appRef);
+    if (typeof ngDevMode !== 'undefined' && ngDevMode) {
+        const timeoutTime = APPLICATION_IS_STABLE_TIMEOUT;
+        const console = injector.get(Console);
+        const ngZone = injector.get(NgZone);
+        // The following call should not and does not prevent the app to become stable
+        // We cannot use RxJS timer here because the app would remain unstable.
+        // This also avoids an extra change detection cycle.
+        const timeoutId = ngZone.runOutsideAngular(() => {
+            return setTimeout(() => logWarningOnStableTimedout(timeoutTime, console), timeoutTime);
+        });
+        whenStablePromise.finally(() => clearTimeout(timeoutId));
+    }
+    return whenStablePromise;
+}
+/**
+ * Returns a set of providers required to setup hydration support
+ * for an application that is server side rendered. This function is
+ * included into the `provideClientHydration` public API function from
+ * the `platform-browser` package.
+ *
+ * The function sets up an internal flag that would be recognized during
+ * the server side rendering time as well, so there is no need to
+ * configure or change anything in NgUniversal to enable the feature.
+ */
+function withDomHydration() {
+    return makeEnvironmentProviders([
+        {
+            provide: IS_HYDRATION_DOM_REUSE_ENABLED,
+            useFactory: () => {
+                let isEnabled = true;
+                if (isPlatformBrowser()) {
+                    // On the client, verify that the server response contains
+                    // hydration annotations. Otherwise, keep hydration disabled.
+                    const transferState = inject(TransferState, { optional: true });
+                    isEnabled = !!transferState?.get(NGH_DATA_KEY, null);
+                    if (!isEnabled && (typeof ngDevMode !== 'undefined' && ngDevMode)) {
+                        const console = inject(Console);
+                        const message = formatRuntimeError(-505 /* RuntimeErrorCode.MISSING_HYDRATION_ANNOTATIONS */, 'Angular hydration was requested on the client, but there was no ' +
+                            'serialized information present in the server response, ' +
+                            'thus hydration was not enabled. ' +
+                            'Make sure the `provideClientHydration()` is included into the list ' +
+                            'of providers in the server part of the application configuration.');
+                        // tslint:disable-next-line:no-console
+                        console.warn(message);
+                    }
+                }
+                if (isEnabled) {
+                    performanceMarkFeature('NgHydration');
+                }
+                return isEnabled;
+            },
+        },
+        {
+            provide: ENVIRONMENT_INITIALIZER,
+            useValue: () => {
+                // i18n support is enabled by calling withI18nSupport(), but there's
+                // no way to turn it off (e.g. for tests), so we turn it off by default.
+                setIsI18nHydrationSupportEnabled(false);
+                // Since this function is used across both server and client,
+                // make sure that the runtime code is only added when invoked
+                // on the client. Moving forward, the `isPlatformBrowser` check should
+                // be replaced with a tree-shakable alternative (e.g. `isServer`
+                // flag).
+                if (isPlatformBrowser() && inject(IS_HYDRATION_DOM_REUSE_ENABLED)) {
+                    verifySsrContentsIntegrity();
+                    enableHydrationRuntimeSupport();
+                }
+            },
+            multi: true,
+        },
+        {
+            provide: PRESERVE_HOST_CONTENT,
+            useFactory: () => {
+                // Preserve host element content only in a browser
+                // environment and when hydration is configured properly.
+                // On a server, an application is rendered from scratch,
+                // so the host content needs to be empty.
+                return isPlatformBrowser() && inject(IS_HYDRATION_DOM_REUSE_ENABLED);
+            }
+        },
+        {
+            provide: APP_BOOTSTRAP_LISTENER,
+            useFactory: () => {
+                if (isPlatformBrowser() && inject(IS_HYDRATION_DOM_REUSE_ENABLED)) {
+                    const appRef = inject(ApplicationRef);
+                    const injector = inject(Injector);
+                    return () => {
+                        // Wait until an app becomes stable and cleanup all views that
+                        // were not claimed during the application bootstrap process.
+                        // The timing is similar to when we start the serialization process
+                        // on the server.
+                        //
+                        // Note: the cleanup task *MUST* be scheduled within the Angular zone
+                        // to ensure that change detection is properly run afterward.
+                        whenStableWithTimeout(appRef, injector).then(() => {
+                            NgZone.assertInAngularZone();
+                            cleanupDehydratedViews(appRef);
+                            if (typeof ngDevMode !== 'undefined' && ngDevMode) {
+                                printHydrationStats(injector);
+                            }
+                        });
+                    };
+                }
+                return () => { }; // noop
+            },
+            multi: true,
+        }
+    ]);
+}
+/**
+ * Returns a set of providers required to setup support for i18n hydration.
+ * Requires hydration to be enabled separately.
+ */
+function withI18nSupport() {
+    return [
+        {
+            provide: IS_I18N_HYDRATION_ENABLED,
+            useValue: true,
+        },
+        {
+            provide: ENVIRONMENT_INITIALIZER,
+            useValue: () => {
+                enableI18nHydrationRuntimeSupport();
+                setIsI18nHydrationSupportEnabled(true);
+                performanceMarkFeature('NgI18nHydration');
+            },
+            multi: true,
+        },
+    ];
+}
+/**
+ *
+ * @param time The time in ms until the stable timedout warning message is logged
+ */
+function logWarningOnStableTimedout(time, console) {
+    const message = `Angular hydration expected the ApplicationRef.isStable() to emit \`true\`, but it ` +
+        `didn't happen within ${time}ms. Angular hydration logic depends on the application becoming stable ` +
+        `as a signal to complete hydration process.`;
+    console.warn(formatRuntimeError(-506 /* RuntimeErrorCode.HYDRATION_STABLE_TIMEDOUT */, message));
+}
+/**
+ * Verifies whether the DOM contains a special marker added during SSR time to make sure
+ * there is no SSR'ed contents transformations happen after SSR is completed. Typically that
+ * happens either by CDN or during the build process as an optimization to remove comment nodes.
+ * Hydration process requires comment nodes produced by Angular to locate correct DOM segments.
+ * When this special marker is *not* present - throw an error and do not proceed with hydration,
+ * since it will not be able to function correctly.
+ *
+ * Note: this function is invoked only on the client, so it's safe to use DOM APIs.
+ */
+function verifySsrContentsIntegrity() {
+    const doc = getDocument();
+    let hydrationMarker;
+    for (const node of doc.body.childNodes) {
+        if (node.nodeType === Node.COMMENT_NODE &&
+            node.textContent?.trim() === SSR_CONTENT_INTEGRITY_MARKER) {
+            hydrationMarker = node;
+            break;
+        }
+    }
+    if (!hydrationMarker) {
+        throw new RuntimeError(-507 /* RuntimeErrorCode.MISSING_SSR_CONTENT_INTEGRITY_MARKER */, typeof ngDevMode !== 'undefined' && ngDevMode &&
+            'Angular hydration logic detected that HTML content of this page was modified after it ' +
+                'was produced during server side rendering. Make sure that there are no optimizations ' +
+                'that remove comment nodes from HTML enabled on your CDN. Angular hydration ' +
+                'relies on HTML produced by the server, including whitespaces and comment nodes.');
+    }
+}
+
 /**
  * Queue a state update to be performed asynchronously.
  *
@@ -35938,6 +36603,17 @@ function ɵɵngDeclareDirective(decl) {
 function ɵɵngDeclareClassMetadata(decl) {
     setClassMetadata(decl.type, decl.decorators, decl.ctorParameters ?? null, decl.propDecorators ?? null);
 }
+/**
+ * Evaluates the class metadata of a component that contains deferred blocks.
+ *
+ * @codeGenApi
+ */
+function ɵɵngDeclareClassMetadataAsync(decl) {
+    setClassMetadataAsync(decl.type, decl.resolveDeferredDeps, (...types) => {
+        const meta = decl.resolveMetadata(...types);
+        setClassMetadata(decl.type, meta.decorators, meta.ctorParameters, meta.propDecorators);
+    });
+}
 /**
  * Compiles a partial component declaration object into a full component definition object.
  *
@@ -36392,5 +37068,5 @@ if (typeof ngDevMode !== 'undefined' && ngDevMode) {
  * Generated bundle index. Do not edit.
  */
 
-export { ANIMATION_MODULE_TYPE, APP_BOOTSTRAP_LISTENER, APP_ID, APP_INITIALIZER, AfterRenderPhase, ApplicationInitStatus, ApplicationModule, ApplicationRef, Attribute, COMPILER_OPTIONS, CSP_NONCE, CUSTOM_ELEMENTS_SCHEMA, ChangeDetectionStrategy, ChangeDetectorRef, Compiler, CompilerFactory, Component, ComponentFactory$1 as ComponentFactory, ComponentFactoryResolver$1 as ComponentFactoryResolver, ComponentRef$1 as ComponentRef, ContentChild, ContentChildren, DEFAULT_CURRENCY_CODE, DebugElement, DebugEventListener, DebugNode, DefaultIterableDiffer, DestroyRef, Directive, ENVIRONMENT_INITIALIZER, ElementRef, EmbeddedViewRef, EnvironmentInjector, ErrorHandler, EventEmitter, Host, HostAttributeToken, HostBinding, HostListener, INJECTOR$1 as INJECTOR, Inject, InjectFlags, Injectable, InjectionToken, Injector, Input, IterableDiffers, KeyValueDiffers, LOCALE_ID, MissingTranslationStrategy, ModuleWithComponentFactories, NO_ERRORS_SCHEMA, NgModule, NgModuleFactory$1 as NgModuleFactory, NgModuleRef$1 as NgModuleRef, NgProbeToken, NgZone, Optional, Output, OutputEmitterRef, PACKAGE_ROOT_URL, PLATFORM_ID, PLATFORM_INITIALIZER, Pipe, PlatformRef, Query, QueryList, Renderer2, RendererFactory2, RendererStyleFlags2, Sanitizer, SecurityContext, Self, SimpleChange, SkipSelf, TRANSLATIONS, TRANSLATIONS_FORMAT, TemplateRef, Testability, TestabilityRegistry, TransferState, Type, VERSION, Version, ViewChild, ViewChildren, ViewContainerRef, ViewEncapsulation$1 as ViewEncapsulation, ViewRef, afterNextRender, afterRender, asNativeElements, assertInInjectionContext, assertNotInReactiveContext, assertPlatform, booleanAttribute, computed, contentChild, contentChildren, createComponent, createEnvironmentInjector, createNgModule, createNgModuleRef, createPlatform, createPlatformFactory, defineInjectable, destroyPlatform, effect, enableProdMode, forwardRef, getDebugNode, getModuleFactory, getNgModuleById, getPlatform, importProvidersFrom, inject, input, isDevMode, isSignal, isStandalone, makeEnvironmentProviders, makeStateKey, mergeApplicationConfig, model, numberAttribute, output, platformCore, provideZoneChangeDetection, reflectComponentType, resolveForwardRef, runInInjectionContext, setTestabilityGetter, signal, untracked, viewChild, viewChildren, ALLOW_MULTIPLE_PLATFORMS as ɵALLOW_MULTIPLE_PLATFORMS, AfterRenderEventManager as ɵAfterRenderEventManager, CONTAINER_HEADER_OFFSET as ɵCONTAINER_HEADER_OFFSET, ChangeDetectionScheduler as ɵChangeDetectionScheduler, ComponentFactory$1 as ɵComponentFactory, Console as ɵConsole, DEFAULT_LOCALE_ID as ɵDEFAULT_LOCALE_ID, DEFER_BLOCK_CONFIG as ɵDEFER_BLOCK_CONFIG, DEFER_BLOCK_DEPENDENCY_INTERCEPTOR as ɵDEFER_BLOCK_DEPENDENCY_INTERCEPTOR, DeferBlockBehavior as ɵDeferBlockBehavior, DeferBlockState as ɵDeferBlockState, EffectScheduler as ɵEffectScheduler, IMAGE_CONFIG as ɵIMAGE_CONFIG, IMAGE_CONFIG_DEFAULTS as ɵIMAGE_CONFIG_DEFAULTS, INJECTOR_SCOPE as ɵINJECTOR_SCOPE, ɵINPUT_SIGNAL_BRAND_WRITE_TYPE, IS_HYDRATION_DOM_REUSE_ENABLED as ɵIS_HYDRATION_DOM_REUSE_ENABLED, LContext as ɵLContext, LifecycleHooksFeature as ɵLifecycleHooksFeature, LocaleDataIndex as ɵLocaleDataIndex, NG_COMP_DEF as ɵNG_COMP_DEF, NG_DIR_DEF as ɵNG_DIR_DEF, NG_ELEMENT_ID as ɵNG_ELEMENT_ID, NG_INJ_DEF as ɵNG_INJ_DEF, NG_MOD_DEF as ɵNG_MOD_DEF, NG_PIPE_DEF as ɵNG_PIPE_DEF, NG_PROV_DEF as ɵNG_PROV_DEF, NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR as ɵNOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR, NO_CHANGE as ɵNO_CHANGE, NgModuleFactory as ɵNgModuleFactory, NoopNgZone as ɵNoopNgZone, PendingTasks as ɵPendingTasks, ReflectionCapabilities as ɵReflectionCapabilities, ComponentFactory as ɵRender3ComponentFactory, ComponentRef as ɵRender3ComponentRef, NgModuleRef as ɵRender3NgModuleRef, RuntimeError as ɵRuntimeError, SSR_CONTENT_INTEGRITY_MARKER as ɵSSR_CONTENT_INTEGRITY_MARKER, TESTABILITY as ɵTESTABILITY, TESTABILITY_GETTER as ɵTESTABILITY_GETTER, USE_RUNTIME_DEPS_TRACKER_FOR_JIT as ɵUSE_RUNTIME_DEPS_TRACKER_FOR_JIT, ViewRef$1 as ɵViewRef, XSS_SECURITY_URL as ɵXSS_SECURITY_URL, _sanitizeHtml as ɵ_sanitizeHtml, _sanitizeUrl as ɵ_sanitizeUrl, allowSanitizationBypassAndThrow as ɵallowSanitizationBypassAndThrow, annotateForHydration as ɵannotateForHydration, bypassSanitizationTrustHtml as ɵbypassSanitizationTrustHtml, bypassSanitizationTrustResourceUrl as ɵbypassSanitizationTrustResourceUrl, bypassSanitizationTrustScript as ɵbypassSanitizationTrustScript, bypassSanitizationTrustStyle as ɵbypassSanitizationTrustStyle, bypassSanitizationTrustUrl as ɵbypassSanitizationTrustUrl, clearResolutionOfComponentResourcesQueue as ɵclearResolutionOfComponentResourcesQueue, compileComponent as ɵcompileComponent, compileDirective as ɵcompileDirective, compileNgModule as ɵcompileNgModule, compileNgModuleDefs as ɵcompileNgModuleDefs, compileNgModuleFactory as ɵcompileNgModuleFactory, compilePipe as ɵcompilePipe, convertToBitFlags as ɵconvertToBitFlags, createInjector as ɵcreateInjector, defaultIterableDiffers as ɵdefaultIterableDiffers, defaultKeyValueDiffers as ɵdefaultKeyValueDiffers, depsTracker as ɵdepsTracker, detectChangesInViewIfRequired as ɵdetectChangesInViewIfRequired, devModeEqual as ɵdevModeEqual, findLocaleData as ɵfindLocaleData, flushModuleScopingQueueAsMuchAsPossible as ɵflushModuleScopingQueueAsMuchAsPossible, formatRuntimeError as ɵformatRuntimeError, generateStandaloneInDeclarationsError as ɵgenerateStandaloneInDeclarationsError, getAsyncClassMetadataFn as ɵgetAsyncClassMetadataFn, getDebugNode as ɵgetDebugNode, getDeferBlocks as ɵgetDeferBlocks, getDirectives as ɵgetDirectives, getEnsureDirtyViewsAreAlwaysReachable as ɵgetEnsureDirtyViewsAreAlwaysReachable, getHostElement as ɵgetHostElement, getInjectableDef as ɵgetInjectableDef, getLContext as ɵgetLContext, getLocaleCurrencyCode as ɵgetLocaleCurrencyCode, getLocalePluralCase as ɵgetLocalePluralCase, getOutputDestroyRef as ɵgetOutputDestroyRef, getSanitizationBypassType as ɵgetSanitizationBypassType, ɵgetUnknownElementStrictMode, ɵgetUnknownPropertyStrictMode, _global as ɵglobal, injectChangeDetectorRef as ɵinjectChangeDetectorRef, internalAfterNextRender as ɵinternalAfterNextRender, internalCreateApplication as ɵinternalCreateApplication, isBoundToModule as ɵisBoundToModule, isComponentDefPendingResolution as ɵisComponentDefPendingResolution, isEnvironmentProviders as ɵisEnvironmentProviders, isInjectable as ɵisInjectable, isNgModule as ɵisNgModule, isPromise as ɵisPromise, isSubscribable as ɵisSubscribable, noSideEffects as ɵnoSideEffects, patchComponentDefWithScope as ɵpatchComponentDefWithScope, performanceMarkFeature as ɵperformanceMarkFeature, provideZonelessChangeDetection as ɵprovideZonelessChangeDetection, queueStateUpdate as ɵqueueStateUpdate, readHydrationInfo as ɵreadHydrationInfo, registerLocaleData as ɵregisterLocaleData, renderDeferBlockState as ɵrenderDeferBlockState, resetCompiledComponents as ɵresetCompiledComponents, resetJitOptions as ɵresetJitOptions, resolveComponentResources as ɵresolveComponentResources, restoreComponentResolutionQueue as ɵrestoreComponentResolutionQueue, setAllowDuplicateNgModuleIdsForTest as ɵsetAllowDuplicateNgModuleIdsForTest, setAlternateWeakRefImpl as ɵsetAlternateWeakRefImpl, ɵsetClassDebugInfo, setClassMetadata as ɵsetClassMetadata, setClassMetadataAsync as ɵsetClassMetadataAsync, setCurrentInjector as ɵsetCurrentInjector, setDocument as ɵsetDocument, setEnsureDirtyViewsAreAlwaysReachable as ɵsetEnsureDirtyViewsAreAlwaysReachable, setInjectorProfilerContext as ɵsetInjectorProfilerContext, setLocaleId as ɵsetLocaleId, ɵsetUnknownElementStrictMode, ɵsetUnknownPropertyStrictMode, store as ɵstore, stringify as ɵstringify, transitiveScopesFor as ɵtransitiveScopesFor, triggerResourceLoading as ɵtriggerResourceLoading, truncateMiddle as ɵtruncateMiddle, unregisterAllLocaleData as ɵunregisterLocaleData, unwrapSafeValue as ɵunwrapSafeValue, ɵunwrapWritableSignal, whenStable as ɵwhenStable, withDomHydration as ɵwithDomHydration, withI18nHydration as ɵwithI18nHydration, ɵɵCopyDefinitionFeature, FactoryTarget as ɵɵFactoryTarget, ɵɵHostDirectivesFeature, ɵɵInheritDefinitionFeature, InputFlags as ɵɵInputFlags, ɵɵInputTransformsFeature, ɵɵNgOnChangesFeature, ɵɵProvidersFeature, ɵɵStandaloneFeature, ɵɵadvance, ɵɵattribute, ɵɵattributeInterpolate1, ɵɵattributeInterpolate2, ɵɵattributeInterpolate3, ɵɵattributeInterpolate4, ɵɵattributeInterpolate5, ɵɵattributeInterpolate6, ɵɵattributeInterpolate7, ɵɵattributeInterpolate8, ɵɵattributeInterpolateV, ɵɵclassMap, ɵɵclassMapInterpolate1, ɵɵclassMapInterpolate2, ɵɵclassMapInterpolate3, ɵɵclassMapInterpolate4, ɵɵclassMapInterpolate5, ɵɵclassMapInterpolate6, ɵɵclassMapInterpolate7, ɵɵclassMapInterpolate8, ɵɵclassMapInterpolateV, ɵɵclassProp, ɵɵcomponentInstance, ɵɵconditional, ɵɵcontentQuery, ɵɵcontentQuerySignal, ɵɵdefer, ɵɵdeferEnableTimerScheduling, ɵɵdeferOnHover, ɵɵdeferOnIdle, ɵɵdeferOnImmediate, ɵɵdeferOnInteraction, ɵɵdeferOnTimer, ɵɵdeferOnViewport, ɵɵdeferPrefetchOnHover, ɵɵdeferPrefetchOnIdle, ɵɵdeferPrefetchOnImmediate, ɵɵdeferPrefetchOnInteraction, ɵɵdeferPrefetchOnTimer, ɵɵdeferPrefetchOnViewport, ɵɵdeferPrefetchWhen, ɵɵdeferWhen, ɵɵdefineComponent, ɵɵdefineDirective, ɵɵdefineInjectable, ɵɵdefineInjector, ɵɵdefineNgModule, ɵɵdefinePipe, ɵɵdirectiveInject, ɵɵdisableBindings, ɵɵelement, ɵɵelementContainer, ɵɵelementContainerEnd, ɵɵelementContainerStart, ɵɵelementEnd, ɵɵelementStart, ɵɵenableBindings, ɵɵgetComponentDepsFactory, ɵɵgetCurrentView, ɵɵgetInheritedFactory, ɵɵhostProperty, ɵɵi18n, ɵɵi18nApply, ɵɵi18nAttributes, ɵɵi18nEnd, ɵɵi18nExp, ɵɵi18nPostprocess, ɵɵi18nStart, ɵɵinject, ɵɵinjectAttribute, ɵɵinvalidFactory, ɵɵinvalidFactoryDep, ɵɵlistener, ɵɵloadQuery, ɵɵnamespaceHTML, ɵɵnamespaceMathML, ɵɵnamespaceSVG, ɵɵnextContext, ɵɵngDeclareClassMetadata, ɵɵngDeclareComponent, ɵɵngDeclareDirective, ɵɵngDeclareFactory, ɵɵngDeclareInjectable, ɵɵngDeclareInjector, ɵɵngDeclareNgModule, ɵɵngDeclarePipe, ɵɵpipe, ɵɵpipeBind1, ɵɵpipeBind2, ɵɵpipeBind3, ɵɵpipeBind4, ɵɵpipeBindV, ɵɵprojection, ɵɵprojectionDef, ɵɵproperty, ɵɵpropertyInterpolate, ɵɵpropertyInterpolate1, ɵɵpropertyInterpolate2, ɵɵpropertyInterpolate3, ɵɵpropertyInterpolate4, ɵɵpropertyInterpolate5, ɵɵpropertyInterpolate6, ɵɵpropertyInterpolate7, ɵɵpropertyInterpolate8, ɵɵpropertyInterpolateV, ɵɵpureFunction0, ɵɵpureFunction1, ɵɵpureFunction2, ɵɵpureFunction3, ɵɵpureFunction4, ɵɵpureFunction5, ɵɵpureFunction6, ɵɵpureFunction7, ɵɵpureFunction8, ɵɵpureFunctionV, ɵɵqueryAdvance, ɵɵqueryRefresh, ɵɵreference, registerNgModuleType as ɵɵregisterNgModuleType, ɵɵrepeater, ɵɵrepeaterCreate, ɵɵrepeaterTrackByIdentity, ɵɵrepeaterTrackByIndex, ɵɵresetView, ɵɵresolveBody, ɵɵresolveDocument, ɵɵresolveWindow, ɵɵrestoreView, ɵɵsanitizeHtml, ɵɵsanitizeResourceUrl, ɵɵsanitizeScript, ɵɵsanitizeStyle, ɵɵsanitizeUrl, ɵɵsanitizeUrlOrResourceUrl, ɵɵsetComponentScope, ɵɵsetNgModuleScope, ɵɵstyleMap, ɵɵstyleMapInterpolate1, ɵɵstyleMapInterpolate2, ɵɵstyleMapInterpolate3, ɵɵstyleMapInterpolate4, ɵɵstyleMapInterpolate5, ɵɵstyleMapInterpolate6, ɵɵstyleMapInterpolate7, ɵɵstyleMapInterpolate8, ɵɵstyleMapInterpolateV, ɵɵstyleProp, ɵɵstylePropInterpolate1, ɵɵstylePropInterpolate2, ɵɵstylePropInterpolate3, ɵɵstylePropInterpolate4, ɵɵstylePropInterpolate5, ɵɵstylePropInterpolate6, ɵɵstylePropInterpolate7, ɵɵstylePropInterpolate8, ɵɵstylePropInterpolateV, ɵɵsyntheticHostListener, ɵɵsyntheticHostProperty, ɵɵtemplate, ɵɵtemplateRefExtractor, ɵɵtext, ɵɵtextInterpolate, ɵɵtextInterpolate1, ɵɵtextInterpolate2, ɵɵtextInterpolate3, ɵɵtextInterpolate4, ɵɵtextInterpolate5, ɵɵtextInterpolate6, ɵɵtextInterpolate7, ɵɵtextInterpolate8, ɵɵtextInterpolateV, ɵɵtrustConstantHtml, ɵɵtrustConstantResourceUrl, ɵɵtwoWayBindingSet, ɵɵtwoWayListener, ɵɵtwoWayProperty, ɵɵvalidateIframeAttribute, ɵɵviewQuery, ɵɵviewQuerySignal };
+export { ANIMATION_MODULE_TYPE, APP_BOOTSTRAP_LISTENER, APP_ID, APP_INITIALIZER, AfterRenderPhase, ApplicationInitStatus, ApplicationModule, ApplicationRef, Attribute, COMPILER_OPTIONS, CSP_NONCE, CUSTOM_ELEMENTS_SCHEMA, ChangeDetectionStrategy, ChangeDetectorRef, Compiler, CompilerFactory, Component, ComponentFactory$1 as ComponentFactory, ComponentFactoryResolver$1 as ComponentFactoryResolver, ComponentRef$1 as ComponentRef, ContentChild, ContentChildren, DEFAULT_CURRENCY_CODE, DebugElement, DebugEventListener, DebugNode, DefaultIterableDiffer, DestroyRef, Directive, ENVIRONMENT_INITIALIZER, ElementRef, EmbeddedViewRef, EnvironmentInjector, ErrorHandler, EventEmitter, Host, HostAttributeToken, HostBinding, HostListener, INJECTOR$1 as INJECTOR, Inject, InjectFlags, Injectable, InjectionToken, Injector, Input, IterableDiffers, KeyValueDiffers, LOCALE_ID, MissingTranslationStrategy, ModuleWithComponentFactories, NO_ERRORS_SCHEMA, NgModule, NgModuleFactory$1 as NgModuleFactory, NgModuleRef$1 as NgModuleRef, NgProbeToken, NgZone, Optional, Output, OutputEmitterRef, PACKAGE_ROOT_URL, PLATFORM_ID, PLATFORM_INITIALIZER, Pipe, PlatformRef, Query, QueryList, Renderer2, RendererFactory2, RendererStyleFlags2, Sanitizer, SecurityContext, Self, SimpleChange, SkipSelf, TRANSLATIONS, TRANSLATIONS_FORMAT, TemplateRef, Testability, TestabilityRegistry, TransferState, Type, VERSION, Version, ViewChild, ViewChildren, ViewContainerRef, ViewEncapsulation$1 as ViewEncapsulation, ViewRef, afterNextRender, afterRender, asNativeElements, assertInInjectionContext, assertNotInReactiveContext, assertPlatform, booleanAttribute, computed, contentChild, contentChildren, createComponent, createEnvironmentInjector, createNgModule, createNgModuleRef, createPlatform, createPlatformFactory, defineInjectable, destroyPlatform, effect, enableProdMode, forwardRef, getDebugNode, getModuleFactory, getNgModuleById, getPlatform, importProvidersFrom, inject, input, isDevMode, isSignal, isStandalone, makeEnvironmentProviders, makeStateKey, mergeApplicationConfig, model, numberAttribute, output, platformCore, provideZoneChangeDetection, reflectComponentType, resolveForwardRef, runInInjectionContext, setTestabilityGetter, signal, untracked, viewChild, viewChildren, ALLOW_MULTIPLE_PLATFORMS as ɵALLOW_MULTIPLE_PLATFORMS, AfterRenderEventManager as ɵAfterRenderEventManager, CONTAINER_HEADER_OFFSET as ɵCONTAINER_HEADER_OFFSET, ChangeDetectionScheduler as ɵChangeDetectionScheduler, ComponentFactory$1 as ɵComponentFactory, Console as ɵConsole, DEFAULT_LOCALE_ID as ɵDEFAULT_LOCALE_ID, DEFER_BLOCK_CONFIG as ɵDEFER_BLOCK_CONFIG, DEFER_BLOCK_DEPENDENCY_INTERCEPTOR as ɵDEFER_BLOCK_DEPENDENCY_INTERCEPTOR, DeferBlockBehavior as ɵDeferBlockBehavior, DeferBlockState as ɵDeferBlockState, EffectScheduler as ɵEffectScheduler, IMAGE_CONFIG as ɵIMAGE_CONFIG, IMAGE_CONFIG_DEFAULTS as ɵIMAGE_CONFIG_DEFAULTS, INJECTOR_SCOPE as ɵINJECTOR_SCOPE, ɵINPUT_SIGNAL_BRAND_WRITE_TYPE, IS_HYDRATION_DOM_REUSE_ENABLED as ɵIS_HYDRATION_DOM_REUSE_ENABLED, LContext as ɵLContext, LifecycleHooksFeature as ɵLifecycleHooksFeature, LocaleDataIndex as ɵLocaleDataIndex, NG_COMP_DEF as ɵNG_COMP_DEF, NG_DIR_DEF as ɵNG_DIR_DEF, NG_ELEMENT_ID as ɵNG_ELEMENT_ID, NG_INJ_DEF as ɵNG_INJ_DEF, NG_MOD_DEF as ɵNG_MOD_DEF, NG_PIPE_DEF as ɵNG_PIPE_DEF, NG_PROV_DEF as ɵNG_PROV_DEF, NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR as ɵNOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR, NO_CHANGE as ɵNO_CHANGE, NgModuleFactory as ɵNgModuleFactory, NoopNgZone as ɵNoopNgZone, PendingTasks as ɵPendingTasks, ReflectionCapabilities as ɵReflectionCapabilities, ComponentFactory as ɵRender3ComponentFactory, ComponentRef as ɵRender3ComponentRef, NgModuleRef as ɵRender3NgModuleRef, RuntimeError as ɵRuntimeError, SSR_CONTENT_INTEGRITY_MARKER as ɵSSR_CONTENT_INTEGRITY_MARKER, SchedulingMode as ɵSchedulingMode, TESTABILITY as ɵTESTABILITY, TESTABILITY_GETTER as ɵTESTABILITY_GETTER, USE_RUNTIME_DEPS_TRACKER_FOR_JIT as ɵUSE_RUNTIME_DEPS_TRACKER_FOR_JIT, ViewRef$1 as ɵViewRef, XSS_SECURITY_URL as ɵXSS_SECURITY_URL, ZONELESS_ENABLED as ɵZONELESS_ENABLED, _sanitizeHtml as ɵ_sanitizeHtml, _sanitizeUrl as ɵ_sanitizeUrl, allowSanitizationBypassAndThrow as ɵallowSanitizationBypassAndThrow, annotateForHydration as ɵannotateForHydration, bypassSanitizationTrustHtml as ɵbypassSanitizationTrustHtml, bypassSanitizationTrustResourceUrl as ɵbypassSanitizationTrustResourceUrl, bypassSanitizationTrustScript as ɵbypassSanitizationTrustScript, bypassSanitizationTrustStyle as ɵbypassSanitizationTrustStyle, bypassSanitizationTrustUrl as ɵbypassSanitizationTrustUrl, clearResolutionOfComponentResourcesQueue as ɵclearResolutionOfComponentResourcesQueue, compileComponent as ɵcompileComponent, compileDirective as ɵcompileDirective, compileNgModule as ɵcompileNgModule, compileNgModuleDefs as ɵcompileNgModuleDefs, compileNgModuleFactory as ɵcompileNgModuleFactory, compilePipe as ɵcompilePipe, convertToBitFlags as ɵconvertToBitFlags, createInjector as ɵcreateInjector, defaultIterableDiffers as ɵdefaultIterableDiffers, defaultKeyValueDiffers as ɵdefaultKeyValueDiffers, depsTracker as ɵdepsTracker, detectChangesInViewIfRequired as ɵdetectChangesInViewIfRequired, devModeEqual as ɵdevModeEqual, findLocaleData as ɵfindLocaleData, flushModuleScopingQueueAsMuchAsPossible as ɵflushModuleScopingQueueAsMuchAsPossible, formatRuntimeError as ɵformatRuntimeError, generateStandaloneInDeclarationsError as ɵgenerateStandaloneInDeclarationsError, getAsyncClassMetadataFn as ɵgetAsyncClassMetadataFn, getDebugNode as ɵgetDebugNode, getDeferBlocks as ɵgetDeferBlocks, getDirectives as ɵgetDirectives, getHostElement as ɵgetHostElement, getInjectableDef as ɵgetInjectableDef, getLContext as ɵgetLContext, getLocaleCurrencyCode as ɵgetLocaleCurrencyCode, getLocalePluralCase as ɵgetLocalePluralCase, getOutputDestroyRef as ɵgetOutputDestroyRef, getSanitizationBypassType as ɵgetSanitizationBypassType, ɵgetUnknownElementStrictMode, ɵgetUnknownPropertyStrictMode, _global as ɵglobal, injectChangeDetectorRef as ɵinjectChangeDetectorRef, internalAfterNextRender as ɵinternalAfterNextRender, internalCreateApplication as ɵinternalCreateApplication, isBoundToModule as ɵisBoundToModule, isComponentDefPendingResolution as ɵisComponentDefPendingResolution, isEnvironmentProviders as ɵisEnvironmentProviders, isInjectable as ɵisInjectable, isNgModule as ɵisNgModule, isPromise as ɵisPromise, isSubscribable as ɵisSubscribable, noSideEffects as ɵnoSideEffects, patchComponentDefWithScope as ɵpatchComponentDefWithScope, performanceMarkFeature as ɵperformanceMarkFeature, provideZonelessChangeDetection as ɵprovideZonelessChangeDetection, queueStateUpdate as ɵqueueStateUpdate, readHydrationInfo as ɵreadHydrationInfo, registerLocaleData as ɵregisterLocaleData, renderDeferBlockState as ɵrenderDeferBlockState, resetCompiledComponents as ɵresetCompiledComponents, resetJitOptions as ɵresetJitOptions, resolveComponentResources as ɵresolveComponentResources, restoreComponentResolutionQueue as ɵrestoreComponentResolutionQueue, setAllowDuplicateNgModuleIdsForTest as ɵsetAllowDuplicateNgModuleIdsForTest, setAlternateWeakRefImpl as ɵsetAlternateWeakRefImpl, ɵsetClassDebugInfo, setClassMetadata as ɵsetClassMetadata, setClassMetadataAsync as ɵsetClassMetadataAsync, setCurrentInjector as ɵsetCurrentInjector, setDocument as ɵsetDocument, setInjectorProfilerContext as ɵsetInjectorProfilerContext, setLocaleId as ɵsetLocaleId, ɵsetUnknownElementStrictMode, ɵsetUnknownPropertyStrictMode, store as ɵstore, stringify as ɵstringify, transitiveScopesFor as ɵtransitiveScopesFor, triggerResourceLoading as ɵtriggerResourceLoading, truncateMiddle as ɵtruncateMiddle, unregisterAllLocaleData as ɵunregisterLocaleData, unwrapSafeValue as ɵunwrapSafeValue, ɵunwrapWritableSignal, whenStable as ɵwhenStable, withDomHydration as ɵwithDomHydration, withI18nSupport as ɵwithI18nSupport, ɵɵCopyDefinitionFeature, FactoryTarget as ɵɵFactoryTarget, ɵɵHostDirectivesFeature, ɵɵInheritDefinitionFeature, InputFlags as ɵɵInputFlags, ɵɵInputTransformsFeature, ɵɵNgOnChangesFeature, ɵɵProvidersFeature, ɵɵStandaloneFeature, ɵɵadvance, ɵɵattribute, ɵɵattributeInterpolate1, ɵɵattributeInterpolate2, ɵɵattributeInterpolate3, ɵɵattributeInterpolate4, ɵɵattributeInterpolate5, ɵɵattributeInterpolate6, ɵɵattributeInterpolate7, ɵɵattributeInterpolate8, ɵɵattributeInterpolateV, ɵɵclassMap, ɵɵclassMapInterpolate1, ɵɵclassMapInterpolate2, ɵɵclassMapInterpolate3, ɵɵclassMapInterpolate4, ɵɵclassMapInterpolate5, ɵɵclassMapInterpolate6, ɵɵclassMapInterpolate7, ɵɵclassMapInterpolate8, ɵɵclassMapInterpolateV, ɵɵclassProp, ɵɵcomponentInstance, ɵɵconditional, ɵɵcontentQuery, ɵɵcontentQuerySignal, ɵɵdefer, ɵɵdeferEnableTimerScheduling, ɵɵdeferOnHover, ɵɵdeferOnIdle, ɵɵdeferOnImmediate, ɵɵdeferOnInteraction, ɵɵdeferOnTimer, ɵɵdeferOnViewport, ɵɵdeferPrefetchOnHover, ɵɵdeferPrefetchOnIdle, ɵɵdeferPrefetchOnImmediate, ɵɵdeferPrefetchOnInteraction, ɵɵdeferPrefetchOnTimer, ɵɵdeferPrefetchOnViewport, ɵɵdeferPrefetchWhen, ɵɵdeferWhen, ɵɵdefineComponent, ɵɵdefineDirective, ɵɵdefineInjectable, ɵɵdefineInjector, ɵɵdefineNgModule, ɵɵdefinePipe, ɵɵdirectiveInject, ɵɵdisableBindings, ɵɵelement, ɵɵelementContainer, ɵɵelementContainerEnd, ɵɵelementContainerStart, ɵɵelementEnd, ɵɵelementStart, ɵɵenableBindings, ɵɵgetComponentDepsFactory, ɵɵgetCurrentView, ɵɵgetInheritedFactory, ɵɵhostProperty, ɵɵi18n, ɵɵi18nApply, ɵɵi18nAttributes, ɵɵi18nEnd, ɵɵi18nExp, ɵɵi18nPostprocess, ɵɵi18nStart, ɵɵinject, ɵɵinjectAttribute, ɵɵinvalidFactory, ɵɵinvalidFactoryDep, ɵɵlistener, ɵɵloadQuery, ɵɵnamespaceHTML, ɵɵnamespaceMathML, ɵɵnamespaceSVG, ɵɵnextContext, ɵɵngDeclareClassMetadata, ɵɵngDeclareClassMetadataAsync, ɵɵngDeclareComponent, ɵɵngDeclareDirective, ɵɵngDeclareFactory, ɵɵngDeclareInjectable, ɵɵngDeclareInjector, ɵɵngDeclareNgModule, ɵɵngDeclarePipe, ɵɵpipe, ɵɵpipeBind1, ɵɵpipeBind2, ɵɵpipeBind3, ɵɵpipeBind4, ɵɵpipeBindV, ɵɵprojection, ɵɵprojectionDef, ɵɵproperty, ɵɵpropertyInterpolate, ɵɵpropertyInterpolate1, ɵɵpropertyInterpolate2, ɵɵpropertyInterpolate3, ɵɵpropertyInterpolate4, ɵɵpropertyInterpolate5, ɵɵpropertyInterpolate6, ɵɵpropertyInterpolate7, ɵɵpropertyInterpolate8, ɵɵpropertyInterpolateV, ɵɵpureFunction0, ɵɵpureFunction1, ɵɵpureFunction2, ɵɵpureFunction3, ɵɵpureFunction4, ɵɵpureFunction5, ɵɵpureFunction6, ɵɵpureFunction7, ɵɵpureFunction8, ɵɵpureFunctionV, ɵɵqueryAdvance, ɵɵqueryRefresh, ɵɵreference, registerNgModuleType as ɵɵregisterNgModuleType, ɵɵrepeater, ɵɵrepeaterCreate, ɵɵrepeaterTrackByIdentity, ɵɵrepeaterTrackByIndex, ɵɵresetView, ɵɵresolveBody, ɵɵresolveDocument, ɵɵresolveWindow, ɵɵrestoreView, ɵɵsanitizeHtml, ɵɵsanitizeResourceUrl, ɵɵsanitizeScript, ɵɵsanitizeStyle, ɵɵsanitizeUrl, ɵɵsanitizeUrlOrResourceUrl, ɵɵsetComponentScope, ɵɵsetNgModuleScope, ɵɵstyleMap, ɵɵstyleMapInterpolate1, ɵɵstyleMapInterpolate2, ɵɵstyleMapInterpolate3, ɵɵstyleMapInterpolate4, ɵɵstyleMapInterpolate5, ɵɵstyleMapInterpolate6, ɵɵstyleMapInterpolate7, ɵɵstyleMapInterpolate8, ɵɵstyleMapInterpolateV, ɵɵstyleProp, ɵɵstylePropInterpolate1, ɵɵstylePropInterpolate2, ɵɵstylePropInterpolate3, ɵɵstylePropInterpolate4, ɵɵstylePropInterpolate5, ɵɵstylePropInterpolate6, ɵɵstylePropInterpolate7, ɵɵstylePropInterpolate8, ɵɵstylePropInterpolateV, ɵɵsyntheticHostListener, ɵɵsyntheticHostProperty, ɵɵtemplate, ɵɵtemplateRefExtractor, ɵɵtext, ɵɵtextInterpolate, ɵɵtextInterpolate1, ɵɵtextInterpolate2, ɵɵtextInterpolate3, ɵɵtextInterpolate4, ɵɵtextInterpolate5, ɵɵtextInterpolate6, ɵɵtextInterpolate7, ɵɵtextInterpolate8, ɵɵtextInterpolateV, ɵɵtrustConstantHtml, ɵɵtrustConstantResourceUrl, ɵɵtwoWayBindingSet, ɵɵtwoWayListener, ɵɵtwoWayProperty, ɵɵvalidateIframeAttribute, ɵɵviewQuery, ɵɵviewQuerySignal };
 //# sourceMappingURL=core.mjs.map