@angular/core 16.0.0-next.4 → 16.0.0-next.5

package/{fesm2020 → fesm2022}/core.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v16.0.0-next.4
+ * @license Angular v16.0.0-next.5
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -620,6 +620,9 @@ const SOURCE = '__source';
  * - Injector instance: Use the injector for resolution.
  */
 let _currentInjector = undefined;
+function getCurrentInjector() {
+    return _currentInjector;
+}
 function setCurrentInjector(injector) {
     const former = _currentInjector;
     _currentInjector = injector;
@@ -628,7 +631,7 @@ function setCurrentInjector(injector) {
 function injectInjectorOnly(token, flags = InjectFlags.Default) {
     if (_currentInjector === undefined) {
         throw new RuntimeError(-203 /* RuntimeErrorCode.MISSING_INJECTION_CONTEXT */, ngDevMode &&
-            `inject() must be called from an injection context such as a constructor, a factory function, a field initializer, or a function used with \`EnvironmentInjector#runInContext\`.`);
+            `inject() must be called from an injection context such as a constructor, a factory function, a field initializer, or a function used with \`runInInjectionContext\`.`);
     }
     else if (_currentInjector === null) {
         return injectRootLimpMode(token, undefined, flags);
@@ -1971,6 +1974,8 @@ const ID = 20;
 const EMBEDDED_VIEW_INJECTOR = 21;
 const ON_DESTROY_HOOKS = 22;
 const HYDRATION = 23;
+const REACTIVE_TEMPLATE_CONSUMER = 24;
+const REACTIVE_HOST_BINDING_CONSUMER = 25;
 /**
  * Size of LView's header. Necessary to adjust for it when setting slots.
  *
@@ -1978,7 +1983,7 @@ const HYDRATION = 23;
  * instruction index into `LView` index. All other indexes should be in the `LView` index space and
  * there should be no need to refer to `HEADER_OFFSET` anywhere else.
  */
-const HEADER_OFFSET = 24;
+const HEADER_OFFSET = 26;
 // Note: This hack is necessary so we don't erroneously get a circular dependency
 // failure based on types.
 const unusedValueExportToPlacateAjd$4 = 1;
@@ -4354,126 +4359,6 @@ function makePropDecorator(name, props, parentClass, additionalProcessing) {
  */
 const Attribute = makeParamDecorator('Attribute', (attributeName) => ({ attributeName, __NG_ELEMENT_ID__: () => ɵɵinjectAttribute(attributeName) }));
 
-/**
- * Creates a token that can be used in a DI Provider.
- *
- * Use an `InjectionToken` whenever the type you are injecting is not reified (does not have a
- * runtime representation) such as when injecting an interface, callable type, array or
- * parameterized type.
- *
- * `InjectionToken` is parameterized on `T` which is the type of object which will be returned by
- * the `Injector`. This provides an additional level of type safety.
- *
- * ```
- * interface MyInterface {...}
- * const myInterface = injector.get(new InjectionToken<MyInterface>('SomeToken'));
- * // myInterface is inferred to be MyInterface.
- * ```
- *
- * When creating an `InjectionToken`, you can optionally specify a factory function which returns
- * (possibly by creating) a default value of the parameterized type `T`. This sets up the
- * `InjectionToken` using this factory as a provider as if it was defined explicitly in the
- * application's root injector. If the factory function, which takes zero arguments, needs to inject
- * dependencies, it can do so using the `inject` function.
- * As you can see in the Tree-shakable InjectionToken example below.
- *
- * Additionally, if a `factory` is specified you can also specify the `providedIn` option, which
- * overrides the above behavior and marks the token as belonging to a particular `@NgModule` (note:
- * this option is now deprecated). As mentioned above, `'root'` is the default value for
- * `providedIn`.
- *
- * The `providedIn: NgModule` and `providedIn: 'any'` options are deprecated.
- *
- * @usageNotes
- * ### Basic Examples
- *
- * ### Plain InjectionToken
- *
- * {@example core/di/ts/injector_spec.ts region='InjectionToken'}
- *
- * ### Tree-shakable InjectionToken
- *
- * {@example core/di/ts/injector_spec.ts region='ShakableInjectionToken'}
- *
- *
- * @publicApi
- */
-class InjectionToken {
-    /**
-     * @param _desc   Description for the token,
-     *                used only for debugging purposes,
-     *                it should but does not need to be unique
-     * @param options Options for the token's usage, as described above
-     */
-    constructor(_desc, options) {
-        this._desc = _desc;
-        /** @internal */
-        this.ngMetadataName = 'InjectionToken';
-        this.ɵprov = undefined;
-        if (typeof options == 'number') {
-            (typeof ngDevMode === 'undefined' || ngDevMode) &&
-                assertLessThan(options, 0, 'Only negative numbers are supported here');
-            // This is a special hack to assign __NG_ELEMENT_ID__ to this instance.
-            // See `InjectorMarkers`
-            this.__NG_ELEMENT_ID__ = options;
-        }
-        else if (options !== undefined) {
-            this.ɵprov = ɵɵdefineInjectable({
-                token: this,
-                providedIn: options.providedIn || 'root',
-                factory: options.factory,
-            });
-        }
-    }
-    /**
-     * @internal
-     */
-    get multi() {
-        return this;
-    }
-    toString() {
-        return `InjectionToken ${this._desc}`;
-    }
-}
-
-/**
- * A DI token that you can use to create a virtual [provider](guide/glossary#provider)
- * that will populate the `entryComponents` field of components and NgModules
- * based on its `useValue` property value.
- * All components that are referenced in the `useValue` value (either directly
- * or in a nested array or map) are added to the `entryComponents` property.
- *
- * @usageNotes
- *
- * The following example shows how the router can populate the `entryComponents`
- * field of an NgModule based on a router configuration that refers
- * to components.
- *
- * ```typescript
- * // helper function inside the router
- * function provideRoutes(routes) {
- *   return [
- *     {provide: ROUTES, useValue: routes},
- *     {provide: ANALYZE_FOR_ENTRY_COMPONENTS, useValue: routes, multi: true}
- *   ];
- * }
- *
- * // user code
- * let routes = [
- *   {path: '/root', component: RootComp},
- *   {path: '/teams', component: TeamsComp}
- * ];
- *
- * @NgModule({
- *   providers: [provideRoutes(routes)]
- * })
- * class ModuleWithRoutes {}
- * ```
- *
- * @publicApi
- * @deprecated Since 9.0.0. With Ivy, this property is no longer necessary.
- */
-const ANALYZE_FOR_ENTRY_COMPONENTS = new InjectionToken('AnalyzeForEntryComponents');
 // Stores the default value of `emitDistinctChangesOnly` when the `emitDistinctChangesOnly` is not
 // explicitly set.
 const emitDistinctChangesOnlyDefaultValue = true;
@@ -6462,6 +6347,8 @@ function detachView(lContainer, removeIndex) {
 function destroyLView(tView, lView) {
     if (!(lView[FLAGS] & 128 /* LViewFlags.Destroyed */)) {
         const renderer = lView[RENDERER];
+        lView[REACTIVE_TEMPLATE_CONSUMER]?.destroy();
+        lView[REACTIVE_HOST_BINDING_CONSUMER]?.destroy();
         if (renderer.destroyNode) {
             applyView(tView, lView, renderer, 3 /* WalkTNodeTreeAction.Destroy */, null, null);
         }
@@ -6862,15 +6749,12 @@ function nativeRemoveNode(renderer, rNode, isHostElement) {
     }
 }
 /**
- * Removes the contents of a given RElement using a given renderer.
+ * Clears the contents of a given RElement.
  *
- * @param renderer A renderer to be used
  * @param rElement the native RElement to be cleared
  */
-function clearElementContents(renderer, rElement) {
-    while (rElement.firstChild) {
-        nativeRemoveChild(renderer, rElement, rElement.firstChild, false);
-    }
+function clearElementContents(rElement) {
+    rElement.textContent = '';
 }
 /**
  * Performs the operation of `action` on the node. Typically this involves inserting or removing
@@ -8078,6 +7962,88 @@ function getSanitizer() {
     return lView && lView[SANITIZER];
 }
 
+/**
+ * Creates a token that can be used in a DI Provider.
+ *
+ * Use an `InjectionToken` whenever the type you are injecting is not reified (does not have a
+ * runtime representation) such as when injecting an interface, callable type, array or
+ * parameterized type.
+ *
+ * `InjectionToken` is parameterized on `T` which is the type of object which will be returned by
+ * the `Injector`. This provides an additional level of type safety.
+ *
+ * ```
+ * interface MyInterface {...}
+ * const myInterface = injector.get(new InjectionToken<MyInterface>('SomeToken'));
+ * // myInterface is inferred to be MyInterface.
+ * ```
+ *
+ * When creating an `InjectionToken`, you can optionally specify a factory function which returns
+ * (possibly by creating) a default value of the parameterized type `T`. This sets up the
+ * `InjectionToken` using this factory as a provider as if it was defined explicitly in the
+ * application's root injector. If the factory function, which takes zero arguments, needs to inject
+ * dependencies, it can do so using the `inject` function.
+ * As you can see in the Tree-shakable InjectionToken example below.
+ *
+ * Additionally, if a `factory` is specified you can also specify the `providedIn` option, which
+ * overrides the above behavior and marks the token as belonging to a particular `@NgModule` (note:
+ * this option is now deprecated). As mentioned above, `'root'` is the default value for
+ * `providedIn`.
+ *
+ * The `providedIn: NgModule` and `providedIn: 'any'` options are deprecated.
+ *
+ * @usageNotes
+ * ### Basic Examples
+ *
+ * ### Plain InjectionToken
+ *
+ * {@example core/di/ts/injector_spec.ts region='InjectionToken'}
+ *
+ * ### Tree-shakable InjectionToken
+ *
+ * {@example core/di/ts/injector_spec.ts region='ShakableInjectionToken'}
+ *
+ *
+ * @publicApi
+ */
+class InjectionToken {
+    /**
+     * @param _desc   Description for the token,
+     *                used only for debugging purposes,
+     *                it should but does not need to be unique
+     * @param options Options for the token's usage, as described above
+     */
+    constructor(_desc, options) {
+        this._desc = _desc;
+        /** @internal */
+        this.ngMetadataName = 'InjectionToken';
+        this.ɵprov = undefined;
+        if (typeof options == 'number') {
+            (typeof ngDevMode === 'undefined' || ngDevMode) &&
+                assertLessThan(options, 0, 'Only negative numbers are supported here');
+            // This is a special hack to assign __NG_ELEMENT_ID__ to this instance.
+            // See `InjectorMarkers`
+            this.__NG_ELEMENT_ID__ = options;
+        }
+        else if (options !== undefined) {
+            this.ɵprov = ɵɵdefineInjectable({
+                token: this,
+                providedIn: options.providedIn || 'root',
+                factory: options.factory,
+            });
+        }
+    }
+    /**
+     * @internal
+     */
+    get multi() {
+        return this;
+    }
+    toString() {
+        return `InjectionToken ${this._desc}`;
+    }
+}
+
 /**
  * A multi-provider token for initialization functions that will run upon construction of an
  * environment injector.
@@ -8181,7 +8147,7 @@ function internalImportProvidersFrom(checkForStandaloneCmp, ...sources) {
         // Narrow `source` to access the internal type analogue for `ModuleWithProviders`.
         const internalSource = source;
         if (walkProviderTree(internalSource, providersOut, [], dedup)) {
-            injectorTypesWithProviders || (injectorTypesWithProviders = []);
+            injectorTypesWithProviders ||= [];
             injectorTypesWithProviders.push(internalSource);
         }
     });
@@ -8277,7 +8243,7 @@ function walkProviderTree(container, providersOut, parents, dedup) {
             try {
                 deepForEach(injDef.imports, imported => {
                     if (walkProviderTree(imported, providersOut, parents, dedup)) {
-                        importTypesWithProviders || (importTypesWithProviders = []);
+                        importTypesWithProviders ||= [];
                         // If the processed import is an injector type with providers, we store it in the
                         // list of import types with providers, so that we can process those afterwards.
                         importTypesWithProviders.push(imported);
@@ -8935,6 +8901,13 @@ class TransferState {
         this.store = {};
         this.onSerializeCallbacks = {};
     }
+    /** @nocollapse */
+    static { this.ɵprov = 
+    /** @pureOrBreakMyCode */ ɵɵdefineInjectable({
+        token: TransferState,
+        providedIn: 'root',
+        factory: initTransferState,
+    }); }
     /**
      * Get the value corresponding to a key. Return `defaultValue` if key is not found.
      */
@@ -8989,13 +8962,6 @@ class TransferState {
         return JSON.stringify(this.store);
     }
 }
-/** @nocollapse */
-TransferState.ɵprov = 
-/** @pureOrBreakMyCode */ ɵɵdefineInjectable({
-    token: TransferState,
-    providedIn: 'root',
-    factory: initTransferState,
-});
 function retrieveTransferredState(doc, appId) {
     // Locate the script tag with the JSON data transferred from the server.
     // The id of the script tag is set to the Angular appId + 'state'.
@@ -9191,7 +9157,7 @@ function isRNodeClaimedForHydration(node) {
     return !!node.__claimed;
 }
 function setSegmentHead(hydrationInfo, index, node) {
-    hydrationInfo.segmentHeads ?? (hydrationInfo.segmentHeads = {});
+    hydrationInfo.segmentHeads ??= {};
     hydrationInfo.segmentHeads[index] = node;
 }
 function getSegmentHead(hydrationInfo, index) {
@@ -9236,7 +9202,7 @@ function calcSerializedContainerSize(hydrationInfo, index) {
  * in the DOM at serialization time. We should not attempt hydration for
  * such nodes and instead, use a regular "creation mode".
  */
-function isDisconnectedNode(hydrationInfo, index) {
+function isDisconnectedNode$1(hydrationInfo, index) {
     // Check if we are processing disconnected info for the first time.
     if (typeof hydrationInfo.disconnectedNodes === 'undefined') {
         const nodeIds = hydrationInfo.data[DISCONNECTED_NODES];
@@ -9270,7 +9236,7 @@ class ComponentFactory$1 {
 }
 
 function noComponentFactoryError(component) {
-    const error = Error(`No component factory found for ${stringify(component)}. Did you add it to @NgModule.entryComponents?`);
+    const error = Error(`No component factory found for ${stringify(component)}.`);
     error[ERROR_COMPONENT] = component;
     return error;
 }
@@ -9299,8 +9265,8 @@ class _NullComponentFactoryResolver {
  *     Component class can be used directly.
  */
 class ComponentFactoryResolver$1 {
+    static { this.NULL = ( /* @__PURE__ */new _NullComponentFactoryResolver()); }
 }
-ComponentFactoryResolver$1.NULL = ( /* @__PURE__ */new _NullComponentFactoryResolver());
 
 /**
  * Creates an ElementRef from the most recent node.
@@ -9339,12 +9305,12 @@ class ElementRef {
     constructor(nativeElement) {
         this.nativeElement = nativeElement;
     }
+    /**
+     * @internal
+     * @nocollapse
+     */
+    static { this.__NG_ELEMENT_ID__ = injectElementRef; }
 }
-/**
- * @internal
- * @nocollapse
- */
-ElementRef.__NG_ELEMENT_ID__ = injectElementRef;
 /**
  * Unwraps `ElementRef` and return the `nativeElement`.
  *
@@ -9378,12 +9344,12 @@ class RendererFactory2 {
  * @publicApi
  */
 class Renderer2 {
+    /**
+     * @internal
+     * @nocollapse
+     */
+    static { this.__NG_ELEMENT_ID__ = () => injectRenderer2(); }
 }
-/**
- * @internal
- * @nocollapse
- */
-Renderer2.__NG_ELEMENT_ID__ = () => injectRenderer2();
 /** Injects a Renderer2 for the current component. */
 function injectRenderer2() {
     // We need the Renderer to be based on the component that it's being injected into, however since
@@ -9400,13 +9366,13 @@ function injectRenderer2() {
  * @publicApi
  */
 class Sanitizer {
+    /** @nocollapse */
+    static { this.ɵprov = ɵɵdefineInjectable({
+        token: Sanitizer,
+        providedIn: 'root',
+        factory: () => null,
+    }); }
 }
-/** @nocollapse */
-Sanitizer.ɵprov = ɵɵdefineInjectable({
-    token: Sanitizer,
-    providedIn: 'root',
-    factory: () => null,
-});
 
 /**
  * @description Represents the version of Angular
@@ -9424,7 +9390,7 @@ class Version {
 /**
  * @publicApi
  */
-const VERSION = new Version('16.0.0-next.4');
+const VERSION = new Version('16.0.0-next.5');
 
 // This default value is when checking the hierarchy for a token.
 //
@@ -9675,39 +9641,318 @@ function getExpressionChangedErrorDetails(lView, bindingIndex, oldValue, newValu
     return { propName: undefined, oldValue, newValue };
 }
 
-/** A special value which designates that a value has not changed. */
-const NO_CHANGE = (typeof ngDevMode === 'undefined' || ngDevMode) ? { __brand__: 'NO_CHANGE' } : {};
+/**
+ * A `WeakRef`-compatible reference that fakes the API with a strong reference
+ * internally.
+ */
+class LeakyRef {
+    constructor(ref) {
+        this.ref = ref;
+    }
+    deref() {
+        return this.ref;
+    }
+}
+// `WeakRef` is not always defined in every TS environment where Angular is compiled. Instead,
+// read it off of the global context if available.
+// tslint:disable-next-line: no-toplevel-property-access
+let WeakRefImpl = _global['WeakRef'] ?? LeakyRef;
+function newWeakRef(value) {
+    if (typeof ngDevMode !== 'undefined' && ngDevMode && WeakRefImpl === undefined) {
+        throw new Error(`Angular requires a browser which supports the 'WeakRef' API`);
+    }
+    return new WeakRefImpl(value);
+}
+function setAlternateWeakRefImpl(impl) {
+    // no-op since the alternate impl is included by default by the framework. Remove once internal
+    // migration is complete.
+}
 
 /**
- * Advances to an element for later binding instructions.
+ * Counter tracking the next `ProducerId` or `ConsumerId`.
+ */
+let _nextReactiveId = 0;
+/**
+ * Tracks the currently active reactive consumer (or `null` if there is no active
+ * consumer).
+ */
+let activeConsumer = null;
+function setActiveConsumer(consumer) {
+    const prev = activeConsumer;
+    activeConsumer = consumer;
+    return prev;
+}
+/**
+ * A node in the reactive graph.
  *
- * Used in conjunction with instructions like {@link property} to act on elements with specified
- * indices, for example those created with {@link element} or {@link elementStart}.
+ * Nodes can be producers of reactive values, consumers of other reactive values, or both.
  *
- * ```ts
- * (rf: RenderFlags, ctx: any) => {
- *   if (rf & 1) {
- *     text(0, 'Hello');
- *     text(1, 'Goodbye')
- *     element(2, 'div');
- *   }
- *   if (rf & 2) {
- *     advance(2); // Advance twice to the <div>.
- *     property('title', 'test');
- *   }
- *  }
- * ```
- * @param delta Number of elements to advance forwards by.
+ * Producers are nodes that produce values, and can be depended upon by consumer nodes.
  *
- * @codeGenApi
+ * Producers expose a monotonic `valueVersion` counter, and are responsible for incrementing this
+ * version when their value semantically changes. Some producers may produce their values lazily and
+ * thus at times need to be polled for potential updates to their value (and by extension their
+ * `valueVersion`). This is accomplished via the `onProducerUpdateValueVersion` method for
+ * implemented by producers, which should perform whatever calculations are necessary to ensure
+ * `valueVersion` is up to date.
+ *
+ * Consumers are nodes that depend on the values of producers and are notified when those values
+ * might have changed.
+ *
+ * Consumers do not wrap the reads they consume themselves, but rather can be set as the active
+ * reader via `setActiveConsumer`. Reads of producers that happen while a consumer is active will
+ * result in those producers being added as dependencies of that consumer node.
+ *
+ * The set of dependencies of a consumer is dynamic. Implementers expose a monotonically increasing
+ * `trackingVersion` counter, which increments whenever the consumer is about to re-run any reactive
+ * reads it needs and establish a new set of dependencies as a result.
+ *
+ * Producers store the last `trackingVersion` they've seen from `Consumer`s which have read them.
+ * This allows a producer to identify whether its record of the dependency is current or stale, by
+ * comparing the consumer's `trackingVersion` to the version at which the dependency was
+ * last observed.
  */
-function ɵɵadvance(delta) {
-    ngDevMode && assertGreaterThan(delta, 0, 'Can only advance forward');
-    selectIndexInternal(getTView(), getLView(), getSelectedIndex() + delta, !!ngDevMode && isInCheckNoChangesMode());
-}
-function selectIndexInternal(tView, lView, index, checkNoChangesMode) {
-    ngDevMode && assertIndexInDeclRange(lView, index);
-    // Flush the initial hooks for elements in the view that have been added up to this point.
+class ReactiveNode {
+    constructor() {
+        this.id = _nextReactiveId++;
+        /**
+         * A cached weak reference to this node, which will be used in `ReactiveEdge`s.
+         */
+        this.ref = newWeakRef(this);
+        /**
+         * Edges to producers on which this node depends (in its consumer capacity).
+         */
+        this.producers = new Map();
+        /**
+         * Edges to consumers on which this node depends (in its producer capacity).
+         */
+        this.consumers = new Map();
+        /**
+         * Monotonically increasing counter representing a version of this `Consumer`'s
+         * dependencies.
+         */
+        this.trackingVersion = 0;
+        /**
+         * Monotonically increasing counter which increases when the value of this `Producer`
+         * semantically changes.
+         */
+        this.valueVersion = 0;
+    }
+    /**
+     * Polls dependencies of a consumer to determine if they have actually changed.
+     *
+     * If this returns `false`, then even though the consumer may have previously been notified of a
+     * change, the values of its dependencies have not actually changed and the consumer should not
+     * rerun any reactions.
+     */
+    consumerPollProducersForChange() {
+        for (const [producerId, edge] of this.producers) {
+            const producer = edge.producerNode.deref();
+            if (producer === undefined || edge.atTrackingVersion !== this.trackingVersion) {
+                // This dependency edge is stale, so remove it.
+                this.producers.delete(producerId);
+                producer?.consumers.delete(this.id);
+                continue;
+            }
+            if (producer.producerPollStatus(edge.seenValueVersion)) {
+                // One of the dependencies reports a real value change.
+                return true;
+            }
+        }
+        // No dependency reported a real value change, so the `Consumer` has also not been
+        // impacted.
+        return false;
+    }
+    /**
+     * Notify all consumers of this producer that its value may have changed.
+     */
+    producerMayHaveChanged() {
+        for (const [consumerId, edge] of this.consumers) {
+            const consumer = edge.consumerNode.deref();
+            if (consumer === undefined || consumer.trackingVersion !== edge.atTrackingVersion) {
+                this.consumers.delete(consumerId);
+                consumer?.producers.delete(this.id);
+                continue;
+            }
+            consumer.onConsumerDependencyMayHaveChanged();
+        }
+    }
+    /**
+     * Mark that this producer node has been accessed in the current reactive context.
+     */
+    producerAccessed() {
+        if (activeConsumer === null) {
+            return;
+        }
+        // Either create or update the dependency `Edge` in both directions.
+        let edge = activeConsumer.producers.get(this.id);
+        if (edge === undefined) {
+            edge = {
+                consumerNode: activeConsumer.ref,
+                producerNode: this.ref,
+                seenValueVersion: this.valueVersion,
+                atTrackingVersion: activeConsumer.trackingVersion,
+            };
+            activeConsumer.producers.set(this.id, edge);
+            this.consumers.set(activeConsumer.id, edge);
+        }
+        else {
+            edge.seenValueVersion = this.valueVersion;
+            edge.atTrackingVersion = activeConsumer.trackingVersion;
+        }
+    }
+    /**
+     * Whether this consumer currently has any producers registered.
+     */
+    get hasProducers() {
+        return this.producers.size > 0;
+    }
+    /**
+     * Checks if a `Producer` has a current value which is different than the value
+     * last seen at a specific version by a `Consumer` which recorded a dependency on
+     * this `Producer`.
+     */
+    producerPollStatus(lastSeenValueVersion) {
+        // `producer.valueVersion` may be stale, but a mismatch still means that the value
+        // last seen by the `Consumer` is also stale.
+        if (this.valueVersion !== lastSeenValueVersion) {
+            return true;
+        }
+        // Trigger the `Producer` to update its `valueVersion` if necessary.
+        this.onProducerUpdateValueVersion();
+        // At this point, we can trust `producer.valueVersion`.
+        return this.valueVersion !== lastSeenValueVersion;
+    }
+}
+
+/**
+ * Marks current view and all ancestors dirty.
+ *
+ * Returns the root view because it is found as a byproduct of marking the view tree
+ * dirty, and can be used by methods that consume markViewDirty() to easily schedule
+ * change detection. Otherwise, such methods would need to traverse up the view tree
+ * an additional time to get the root view and schedule a tick on it.
+ *
+ * @param lView The starting LView to mark dirty
+ * @returns the root LView
+ */
+function markViewDirty(lView) {
+    while (lView) {
+        lView[FLAGS] |= 32 /* LViewFlags.Dirty */;
+        const parent = getLViewParent(lView);
+        // Stop traversing up as soon as you find a root view that wasn't attached to any container
+        if (isRootView(lView) && !parent) {
+            return lView;
+        }
+        // continue otherwise
+        lView = parent;
+    }
+    return null;
+}
+
+const NG_DEV_MODE = typeof ngDevMode === 'undefined' || ngDevMode;
+class ReactiveLViewConsumer extends ReactiveNode {
+    constructor() {
+        super(...arguments);
+        this._lView = null;
+    }
+    set lView(lView) {
+        NG_DEV_MODE && assertEqual(this._lView, null, 'Consumer already associated with a view.');
+        this._lView = lView;
+    }
+    onConsumerDependencyMayHaveChanged() {
+        NG_DEV_MODE &&
+            assertDefined(this._lView, 'Updating a signal during template or host binding execution is not allowed.');
+        markViewDirty(this._lView);
+    }
+    onProducerUpdateValueVersion() {
+        // This type doesn't implement the producer side of a `ReactiveNode`.
+    }
+    get hasReadASignal() {
+        return this.hasProducers;
+    }
+    runInContext(fn, rf, ctx) {
+        const prevConsumer = setActiveConsumer(this);
+        this.trackingVersion++;
+        try {
+            fn(rf, ctx);
+        }
+        finally {
+            setActiveConsumer(prevConsumer);
+        }
+    }
+    destroy() {
+        // Incrementing the version means that every producer which tries to update this consumer will
+        // consider its record stale, and not notify.
+        this.trackingVersion++;
+    }
+}
+let currentConsumer = null;
+function getOrCreateCurrentLViewConsumer() {
+    currentConsumer ??= new ReactiveLViewConsumer();
+    return currentConsumer;
+}
+/**
+ * Create a new template consumer pointing at the specified LView.
+ * Sometimes, a previously created consumer may be reused, in order to save on allocations. In that
+ * case, the LView will be updated.
+ */
+function getReactiveLViewConsumer(lView, slot) {
+    return lView[slot] ?? getOrCreateCurrentLViewConsumer();
+}
+/**
+ * Assigns the `currentTemplateContext` to its LView's `REACTIVE_CONSUMER` slot if there are tracked
+ * producers.
+ *
+ * The presence of producers means that a signal was read while the consumer was the active
+ * consumer.
+ *
+ * If no producers are present, we do not assign the current template context. This also means we
+ * can just reuse the template context for the next LView.
+ */
+function commitLViewConsumerIfHasProducers(lView, slot) {
+    const consumer = getOrCreateCurrentLViewConsumer();
+    if (!consumer.hasReadASignal) {
+        return;
+    }
+    lView[slot] = currentConsumer;
+    consumer.lView = lView;
+    currentConsumer = new ReactiveLViewConsumer();
+}
+
+/** A special value which designates that a value has not changed. */
+const NO_CHANGE = (typeof ngDevMode === 'undefined' || ngDevMode) ? { __brand__: 'NO_CHANGE' } : {};
+
+/**
+ * Advances to an element for later binding instructions.
+ *
+ * Used in conjunction with instructions like {@link property} to act on elements with specified
+ * indices, for example those created with {@link element} or {@link elementStart}.
+ *
+ * ```ts
+ * (rf: RenderFlags, ctx: any) => {
+ *   if (rf & 1) {
+ *     text(0, 'Hello');
+ *     text(1, 'Goodbye')
+ *     element(2, 'div');
+ *   }
+ *   if (rf & 2) {
+ *     advance(2); // Advance twice to the <div>.
+ *     property('title', 'test');
+ *   }
+ *  }
+ * ```
+ * @param delta Number of elements to advance forwards by.
+ *
+ * @codeGenApi
+ */
+function ɵɵadvance(delta) {
+    ngDevMode && assertGreaterThan(delta, 0, 'Can only advance forward');
+    selectIndexInternal(getTView(), getLView(), getSelectedIndex() + delta, !!ngDevMode && isInCheckNoChangesMode());
+}
+function selectIndexInternal(tView, lView, index, checkNoChangesMode) {
+    ngDevMode && assertIndexInDeclRange(lView, index);
+    // Flush the initial hooks for elements in the view that have been added up to this point.
     // PERF WARNING: do NOT extract this to a separate function without running benchmarks
     if (!checkNoChangesMode) {
         const hooksInitPhaseCompleted = (lView[FLAGS] & 3 /* LViewFlags.InitPhaseStateMask */) === 3 /* InitPhaseState.InitPhaseCompleted */;
@@ -9757,6 +10002,22 @@ function runInInjectionContext(injector, fn) {
         setInjectImplementation(previousInjectImplementation);
     }
 }
+/**
+ * Asserts that the current stack frame is within an injection context and has access to `inject`.
+ *
+ * @param debugFn a reference to the function making the assertion (used for the error message).
+ *
+ * @publicApi
+ */
+function assertInInjectionContext(debugFn) {
+    // Taking a `Function` instead of a string name here prevents the unminified name of the function
+    // from being retained in the bundle regardless of minification.
+    if (!getInjectImplementation() && !getCurrentInjector()) {
+        throw new RuntimeError(-203 /* RuntimeErrorCode.MISSING_INJECTION_CONTEXT */, ngDevMode &&
+            (debugFn.name +
+                '() can only be used within an injection context such as a constructor, a factory function, a field initializer, or a function used with `runInInjectionContext`'));
+    }
+}
 
 /**
  * A mapping of the @angular/core API surface used in generated expressions to the actual symbols.
@@ -9909,6 +10170,8 @@ function createInjectorWithoutInjectorInstances(defType, parent = null, addition
  * @publicApi
  */
 class Injector {
+    static { this.THROW_IF_NOT_FOUND = THROW_IF_NOT_FOUND; }
+    static { this.NULL = ( /* @__PURE__ */new NullInjector()); }
     static create(options, parent) {
         if (Array.isArray(options)) {
             return createInjector({ name: '' }, parent, options, '');
@@ -9918,20 +10181,18 @@ class Injector {
             return createInjector({ name }, options.parent, options.providers, name);
         }
     }
+    /** @nocollapse */
+    static { this.ɵprov = ɵɵdefineInjectable({
+        token: Injector,
+        providedIn: 'any',
+        factory: () => ɵɵinject(INJECTOR),
+    }); }
+    /**
+     * @internal
+     * @nocollapse
+     */
+    static { this.__NG_ELEMENT_ID__ = -1 /* InjectorMarkers.Injector */; }
 }
-Injector.THROW_IF_NOT_FOUND = THROW_IF_NOT_FOUND;
-Injector.NULL = ( /* @__PURE__ */new NullInjector());
-/** @nocollapse */
-Injector.ɵprov = ɵɵdefineInjectable({
-    token: Injector,
-    providedIn: 'any',
-    factory: () => ɵɵinject(INJECTOR),
-});
-/**
- * @internal
- * @nocollapse
- */
-Injector.__NG_ELEMENT_ID__ = -1 /* InjectorMarkers.Injector */;
 
 function findFirstClosedCycle(keys) {
     const res = [];
@@ -10532,6 +10793,7 @@ class ReflectiveInjector {
     }
 }
 class ReflectiveInjector_ {
+    static { this.INJECTOR_KEY = ( /* @__PURE__ */ReflectiveKey.get(Injector)); }
     /**
      * Private
      */
@@ -10687,7 +10949,6 @@ class ReflectiveInjector_ {
         return this.displayName;
     }
 }
-ReflectiveInjector_.INJECTOR_KEY = ( /* @__PURE__ */ReflectiveKey.get(Injector));
 function _mapProviders(injector, fn) {
     const res = [];
     for (let i = 0; i < injector._providers.length; ++i) {
@@ -10761,6 +11022,7 @@ function processHostBindingOpCodes(tView, lView) {
     const hostBindingOpCodes = tView.hostBindingOpCodes;
     if (hostBindingOpCodes === null)
         return;
+    const consumer = getReactiveLViewConsumer(lView, REACTIVE_HOST_BINDING_CONSUMER);
     try {
         for (let i = 0; i < hostBindingOpCodes.length; i++) {
             const opCode = hostBindingOpCodes[i];
@@ -10775,11 +11037,13 @@ function processHostBindingOpCodes(tView, lView) {
                 const hostBindingFn = hostBindingOpCodes[++i];
                 setBindingRootForHostBindings(bindingRootIndx, directiveIdx);
                 const context = lView[directiveIdx];
-                hostBindingFn(2 /* RenderFlags.Update */, context);
+                consumer.runInContext(hostBindingFn, 2 /* RenderFlags.Update */, context);
             }
         }
     }
     finally {
+        lView[REACTIVE_HOST_BINDING_CONSUMER] === null &&
+            commitLViewConsumerIfHasProducers(lView, REACTIVE_HOST_BINDING_CONSUMER);
         setSelectedIndex(-1);
     }
 }
@@ -10835,6 +11099,7 @@ function createLView(parentLView, tView, context, flags, host, tHostNode, render
     lView[ID] = getUniqueLViewId();
     lView[HYDRATION] = hydrationInfo;
     lView[EMBEDDED_VIEW_INJECTOR] = embeddedViewInjector;
+    lView[REACTIVE_TEMPLATE_CONSUMER] = null;
     ngDevMode &&
         assertEqual(tView.type == 2 /* TViewType.Embedded */ ? parentLView !== null : true, true, 'Embedded views must have parentLView');
     lView[DECLARATION_COMPONENT_VIEW] =
@@ -11119,6 +11384,7 @@ function refreshView(tView, lView, templateFn, context) {
     }
 }
 function executeTemplate(tView, lView, templateFn, rf, context) {
+    const consumer = getReactiveLViewConsumer(lView, REACTIVE_TEMPLATE_CONSUMER);
     const prevSelectedIndex = getSelectedIndex();
     const isUpdatePhase = rf & 2 /* RenderFlags.Update */;
     try {
@@ -11130,9 +11396,12 @@ function executeTemplate(tView, lView, templateFn, rf, context) {
         }
         const preHookType = isUpdatePhase ? 2 /* ProfilerEvent.TemplateUpdateStart */ : 0 /* ProfilerEvent.TemplateCreateStart */;
         profiler(preHookType, context);
-        templateFn(rf, context);
+        consumer.runInContext(templateFn, rf, context);
     }
     finally {
+        if (lView[REACTIVE_TEMPLATE_CONSUMER] === null) {
+            commitLViewConsumerIfHasProducers(lView, REACTIVE_TEMPLATE_CONSUMER);
+        }
         setSelectedIndex(prevSelectedIndex);
         const postHookType = isUpdatePhase ? 3 /* ProfilerEvent.TemplateUpdateEnd */ : 1 /* ProfilerEvent.TemplateCreateEnd */;
         profiler(postHookType, context);
@@ -12236,30 +12505,6 @@ function addToViewTree(lView, lViewOrLContainer) {
 ///////////////////////////////
 //// Change detection
 ///////////////////////////////
-/**
- * Marks current view and all ancestors dirty.
- *
- * Returns the root view because it is found as a byproduct of marking the view tree
- * dirty, and can be used by methods that consume markViewDirty() to easily schedule
- * change detection. Otherwise, such methods would need to traverse up the view tree
- * an additional time to get the root view and schedule a tick on it.
- *
- * @param lView The starting LView to mark dirty
- * @returns the root LView
- */
-function markViewDirty(lView) {
-    while (lView) {
-        lView[FLAGS] |= 32 /* LViewFlags.Dirty */;
-        const parent = getLViewParent(lView);
-        // Stop traversing up as soon as you find a root view that wasn't attached to any container
-        if (isRootView(lView) && !parent) {
-            return lView;
-        }
-        // continue otherwise
-        lView = parent;
-    }
-    return null;
-}
 function detectChangesInternal(tView, lView, context, notifyErrorHandler = true) {
     const rendererFactory = lView[RENDERER_FACTORY];
     // Check no changes mode is a dev only mode used to verify that bindings have not changed
@@ -12940,6 +13185,7 @@ class ComponentRef extends ComponentRef$1 {
         this.location = location;
         this._rootLView = _rootLView;
         this._tNode = _tNode;
+        this.previousInputValues = null;
         this.instance = instance;
         this.hostView = this.changeDetectorRef = new RootViewRef(_rootLView);
         this.componentType = componentType;
@@ -12948,8 +13194,16 @@ class ComponentRef extends ComponentRef$1 {
         const inputData = this._tNode.inputs;
         let dataValue;
         if (inputData !== null && (dataValue = inputData[name])) {
+            this.previousInputValues ??= new Map();
+            // Do not set the input if it is the same as the last value
+            // This behavior matches `bindingUpdated` when binding inputs in templates.
+            if (this.previousInputValues.has(name) &&
+                Object.is(this.previousInputValues.get(name), value)) {
+                return;
+            }
             const lView = this._rootLView;
             setInputsForProperty(lView[TVIEW], lView, dataValue, name, value);
+            this.previousInputValues.set(name, value);
             markDirtyIfOnPush(lView, this._tNode.index);
         }
         else {
@@ -14680,10 +14934,9 @@ function siblingAfter(skip, from) {
  */
 function stringifyNavigationInstructions(instructions) {
     const container = [];
-    let i = 0;
-    while (i < instructions.length) {
-        const step = instructions[i++];
-        const repeat = instructions[i++];
+    for (let i = 0; i < instructions.length; i += 2) {
+        const step = instructions[i];
+        const repeat = instructions[i + 1];
         for (let r = 0; r < repeat; r++) {
             container.push(step === NodeNavigationStep.FirstChild ? 'firstChild' : 'nextSibling');
         }
@@ -14696,10 +14949,9 @@ function stringifyNavigationInstructions(instructions) {
  */
 function navigateToNode(from, instructions) {
     let node = from;
-    let i = 0;
-    while (i < instructions.length) {
-        const step = instructions[i++];
-        const repeat = instructions[i++];
+    for (let i = 0; i < instructions.length; i += 2) {
+        const step = instructions[i];
+        const repeat = instructions[i + 1];
         for (let r = 0; r < repeat; r++) {
             if (ngDevMode && !node) {
                 throw nodeNotFoundAtPathError(from, stringifyNavigationInstructions(instructions));
@@ -14926,7 +15178,7 @@ function createContainerAnchorImpl(tView, lView, tNode, index) {
  */
 function locateOrCreateContainerAnchorImpl(tView, lView, tNode, index) {
     const hydrationInfo = lView[HYDRATION];
-    const isNodeCreationMode = !hydrationInfo || isInSkipHydrationBlock$1() || isDisconnectedNode(hydrationInfo, index);
+    const isNodeCreationMode = !hydrationInfo || isInSkipHydrationBlock$1() || isDisconnectedNode$1(hydrationInfo, index);
     lastNodeWasCreated(isNodeCreationMode);
     // Regular creation mode.
     if (isNodeCreationMode) {
@@ -15192,7 +15444,7 @@ let _locateOrCreateElementNode = (tView, lView, tNode, renderer, name, index) =>
  */
 function locateOrCreateElementNodeImpl(tView, lView, tNode, renderer, name, index) {
     const hydrationInfo = lView[HYDRATION];
-    const isNodeCreationMode = !hydrationInfo || isInSkipHydrationBlock$1() || isDisconnectedNode(hydrationInfo, index);
+    const isNodeCreationMode = !hydrationInfo || isInSkipHydrationBlock$1() || isDisconnectedNode$1(hydrationInfo, index);
     lastNodeWasCreated(isNodeCreationMode);
     // Regular creation mode.
     if (isNodeCreationMode) {
@@ -15220,7 +15472,7 @@ function locateOrCreateElementNodeImpl(tView, lView, tNode, renderer, name, inde
             enterSkipHydrationBlock(tNode);
             // Since this isn't hydratable, we need to empty the node
             // so there's no duplicate content after render
-            clearElementContents(renderer, native);
+            clearElementContents(native);
         }
         else if (ngDevMode) {
             // If this is not a component host, throw an error.
@@ -17666,8 +17918,11 @@ function isStylingValuePresent(value) {
  * @param suffix
  */
 function normalizeSuffix(value, suffix) {
-    if (value == null /** || value === undefined */) {
+    if (value == null || value === '') {
         // do nothing
+        // Do not add the suffix if the value is going to be empty.
+        // As it produce invalid CSS, which the browsers will automatically omit but Domino will not.
+        // Example: `"left": "px;"` instead of `"left": ""`.
     }
     else if (typeof suffix === 'string') {
         value = value + suffix;
@@ -17726,7 +17981,7 @@ let _locateOrCreateTextNode = (tView, lView, tNode, value, index) => {
  */
 function locateOrCreateTextNodeImpl(tView, lView, tNode, value, index) {
     const hydrationInfo = lView[HYDRATION];
-    const isNodeCreationMode = !hydrationInfo || isInSkipHydrationBlock$1() || isDisconnectedNode(hydrationInfo, index);
+    const isNodeCreationMode = !hydrationInfo || isInSkipHydrationBlock$1() || isDisconnectedNode$1(hydrationInfo, index);
     lastNodeWasCreated(isNodeCreationMode);
     // Regular creation mode.
     if (isNodeCreationMode) {
@@ -21534,13 +21789,13 @@ class StandaloneService {
             this.cachedInjectors.clear();
         }
     }
+    /** @nocollapse */
+    static { this.ɵprov = ɵɵdefineInjectable({
+        token: StandaloneService,
+        providedIn: 'environment',
+        factory: () => new StandaloneService(ɵɵinject(EnvironmentInjector)),
+    }); }
 }
-/** @nocollapse */
-StandaloneService.ɵprov = ɵɵdefineInjectable({
-    token: StandaloneService,
-    providedIn: 'environment',
-    factory: () => new StandaloneService(ɵɵinject(EnvironmentInjector)),
-});
 /**
  * A feature that acts as a setup code for the {@link StandaloneService}.
  *
@@ -22582,6 +22837,7 @@ function symbolIterator() {
  * @publicApi
  */
 class QueryList {
+    static { Symbol.iterator; }
     /**
      * Returns `Observable` of `QueryList` notifying the subscriber of changes.
      */
@@ -22709,7 +22965,6 @@ class QueryList {
         this.changes.unsubscribe();
     }
 }
-Symbol.iterator;
 
 /**
  * Represents an embedded template that can be used to instantiate embedded views.
@@ -22730,12 +22985,12 @@ Symbol.iterator;
  * @publicApi
  */
 class TemplateRef {
+    /**
+     * @internal
+     * @nocollapse
+     */
+    static { this.__NG_ELEMENT_ID__ = injectTemplateRef; }
 }
-/**
- * @internal
- * @nocollapse
- */
-TemplateRef.__NG_ELEMENT_ID__ = injectTemplateRef;
 const ViewEngineTemplateRef = TemplateRef;
 // TODO(alxhub): combine interface and implementation. Currently this is challenging since something
 // in g3 depends on them being separate.
@@ -22865,11 +23120,13 @@ function cleanupLView(lView) {
  * Walks over all views registered within the ApplicationRef and removes
  * all dehydrated views from all `LContainer`s along the way.
  */
-function cleanupDehydratedViews(appRef) {
+function cleanupDehydratedViews(appRef, pendingTasks) {
     // Wait once an app becomes stable and cleanup all views that
     // were not claimed during the application bootstrap process.
     // The timing is similar to when we kick off serialization on the server.
-    return appRef.isStable.pipe(first((isStable) => isStable)).toPromise().then(() => {
+    const isStablePromise = appRef.isStable.pipe(first((isStable) => isStable)).toPromise();
+    const pendingTasksPromise = pendingTasks.whenAllTasksComplete;
+    return Promise.allSettled([isStablePromise, pendingTasksPromise]).then(() => {
         const viewRefs = appRef._views;
         for (const viewRef of viewRefs) {
             const lView = getComponentLViewForHydration(viewRef);
@@ -22972,12 +23229,12 @@ function findMatchingDehydratedView(lContainer, template) {
  * @publicApi
  */
 class ViewContainerRef {
+    /**
+     * @internal
+     * @nocollapse
+     */
+    static { this.__NG_ELEMENT_ID__ = injectViewContainerRef; }
 }
-/**
- * @internal
- * @nocollapse
- */
-ViewContainerRef.__NG_ELEMENT_ID__ = injectViewContainerRef;
 /**
  * Creates a ViewContainerRef and stores it on the injector. Or, if the ViewContainerRef
  * already exists, retrieves the existing ViewContainerRef.
@@ -23291,7 +23548,7 @@ function locateOrCreateAnchorNode(lContainer, hostLView, hostTNode, slotValue) {
     const hydrationInfo = hostLView[HYDRATION];
     const noOffsetIndex = hostTNode.index - HEADER_OFFSET;
     const isNodeCreationMode = !hydrationInfo || isInSkipHydrationBlock(hostTNode) ||
-        isDisconnectedNode(hydrationInfo, noOffsetIndex);
+        isDisconnectedNode$1(hydrationInfo, noOffsetIndex);
     // Regular creation mode.
     if (isNodeCreationMode) {
         return createAnchorNode(lContainer, hostLView, hostTNode, slotValue);
@@ -24166,7 +24423,6 @@ function verifySemanticsOfNgModuleDef(moduleType, allowDuplicateDeclarationsInRo
     ];
     exports.forEach(verifyExportsAreDeclaredOrReExported);
     declarations.forEach(decl => verifyDeclarationIsUnique(decl, allowDuplicateDeclarationsInRoot));
-    declarations.forEach(verifyComponentEntryComponentsIsPartOfNgModule);
     const ngModule = getAnnotation(moduleType, 'NgModule');
     if (ngModule) {
         ngModule.imports &&
@@ -24176,8 +24432,6 @@ function verifySemanticsOfNgModuleDef(moduleType, allowDuplicateDeclarationsInRo
             });
         ngModule.bootstrap && deepForEach(ngModule.bootstrap, verifyCorrectBootstrapType);
         ngModule.bootstrap && deepForEach(ngModule.bootstrap, verifyComponentIsPartOfNgModule);
-        ngModule.entryComponents &&
-            deepForEach(ngModule.entryComponents, verifyComponentIsPartOfNgModule);
     }
     // Throw Error if any errors were detected.
     if (errors.length) {
@@ -24255,16 +24509,6 @@ function verifySemanticsOfNgModuleDef(moduleType, allowDuplicateDeclarationsInRo
                 `function for bootstrap instead.`);
         }
     }
-    function verifyComponentEntryComponentsIsPartOfNgModule(type) {
-        type = resolveForwardRef(type);
-        if (getComponentDef(type)) {
-            // We know we are component
-            const component = getAnnotation(type, 'Component');
-            if (component && component.entryComponents) {
-                deepForEach(component.entryComponents, verifyComponentIsPartOfNgModule);
-            }
-        }
-    }
     function verifySemanticsOfNgModuleImport(type, importingModule) {
         type = resolveForwardRef(type);
         const directiveDef = getComponentDef(type) || getDirectiveDef(type);
@@ -25105,7 +25349,7 @@ const NgModule = makeDecorator('NgModule', (ngModule) => ngModule, undefined, un
  * Decorator that marks the following class as an NgModule, and supplies
  * configuration metadata for it.
  *
- * * The `declarations` and `entryComponents` options configure the compiler
+ * * The `declarations` option configures the compiler
  * with information about what belongs to the NgModule.
  * * The `providers` options configures the NgModule's injector to provide
  * dependencies the NgModule members.
@@ -25261,9 +25505,9 @@ class ApplicationInitStatus {
         }
         this.initialized = true;
     }
+    static { this.ɵfac = function ApplicationInitStatus_Factory(t) { return new (t || ApplicationInitStatus)(); }; }
+    static { this.ɵprov = /*@__PURE__*/ ɵɵdefineInjectable({ token: ApplicationInitStatus, factory: ApplicationInitStatus.ɵfac, providedIn: 'root' }); }
 }
-ApplicationInitStatus.ɵfac = function ApplicationInitStatus_Factory(t) { return new (t || ApplicationInitStatus)(); };
-ApplicationInitStatus.ɵprov = /*@__PURE__*/ ɵɵdefineInjectable({ token: ApplicationInitStatus, factory: ApplicationInitStatus.ɵfac, providedIn: 'root' });
 (function () { (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(ApplicationInitStatus, [{
         type: Injectable,
         args: [{ providedIn: 'root' }]
@@ -25279,9 +25523,9 @@ class Console {
         // tslint:disable-next-line:no-console
         console.warn(message);
     }
+    static { this.ɵfac = function Console_Factory(t) { return new (t || Console)(); }; }
+    static { this.ɵprov = /*@__PURE__*/ ɵɵdefineInjectable({ token: Console, factory: Console.ɵfac, providedIn: 'platform' }); }
 }
-Console.ɵfac = function Console_Factory(t) { return new (t || Console)(); };
-Console.ɵprov = /*@__PURE__*/ ɵɵdefineInjectable({ token: Console, factory: Console.ɵfac, providedIn: 'platform' });
 (function () { (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(Console, [{
         type: Injectable,
         args: [{ providedIn: 'platform' }]
@@ -25493,8 +25737,8 @@ class ModuleWithComponentFactories {
  */
 class Compiler {
     /**
-     * Compiles the given NgModule and all of its components. All templates of the components listed
-     * in `entryComponents` have to be inlined.
+     * Compiles the given NgModule and all of its components. All templates of the components
+     * have to be inlined.
      */
     compileModuleSync(moduleType) {
         return new NgModuleFactory(moduleType);
@@ -25539,9 +25783,9 @@ class Compiler {
     getModuleId(moduleType) {
         return undefined;
     }
+    static { this.ɵfac = function Compiler_Factory(t) { return new (t || Compiler)(); }; }
+    static { this.ɵprov = /*@__PURE__*/ ɵɵdefineInjectable({ token: Compiler, factory: Compiler.ɵfac, providedIn: 'root' }); }
 }
-Compiler.ɵfac = function Compiler_Factory(t) { return new (t || Compiler)(); };
-Compiler.ɵprov = /*@__PURE__*/ ɵɵdefineInjectable({ token: Compiler, factory: Compiler.ɵfac, providedIn: 'root' });
 (function () { (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(Compiler, [{
         type: Injectable,
         args: [{ providedIn: 'root' }]
@@ -26356,9 +26600,9 @@ class Testability {
         // TODO(juliemr): implement.
         return [];
     }
+    static { this.ɵfac = function Testability_Factory(t) { return new (t || Testability)(ɵɵinject(NgZone), ɵɵinject(TestabilityRegistry), ɵɵinject(TESTABILITY_GETTER)); }; }
+    static { this.ɵprov = /*@__PURE__*/ ɵɵdefineInjectable({ token: Testability, factory: Testability.ɵfac }); }
 }
-Testability.ɵfac = function Testability_Factory(t) { return new (t || Testability)(ɵɵinject(NgZone), ɵɵinject(TestabilityRegistry), ɵɵinject(TESTABILITY_GETTER)); };
-Testability.ɵprov = /*@__PURE__*/ ɵɵdefineInjectable({ token: Testability, factory: Testability.ɵfac });
 (function () { (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(Testability, [{
         type: Injectable
     }], function () { return [{ type: NgZone }, { type: TestabilityRegistry }, { type: undefined, decorators: [{
@@ -26423,9 +26667,9 @@ class TestabilityRegistry {
     findTestabilityInTree(elem, findInAncestors = true) {
         return _testabilityGetter?.findTestabilityInTree(this, elem, findInAncestors) ?? null;
     }
+    static { this.ɵfac = function TestabilityRegistry_Factory(t) { return new (t || TestabilityRegistry)(); }; }
+    static { this.ɵprov = /*@__PURE__*/ ɵɵdefineInjectable({ token: TestabilityRegistry, factory: TestabilityRegistry.ɵfac, providedIn: 'platform' }); }
 }
-TestabilityRegistry.ɵfac = function TestabilityRegistry_Factory(t) { return new (t || TestabilityRegistry)(); };
-TestabilityRegistry.ɵprov = /*@__PURE__*/ ɵɵdefineInjectable({ token: TestabilityRegistry, factory: TestabilityRegistry.ɵfac, providedIn: 'platform' });
 (function () { (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(TestabilityRegistry, [{
         type: Injectable,
         args: [{ providedIn: 'platform' }]
@@ -26439,7 +26683,6 @@ function setTestabilityGetter(getter) {
 }
 let _testabilityGetter;
 
-const NG_DEV_MODE = typeof ngDevMode === 'undefined' || ngDevMode;
 let _platformInjector = null;
 /**
  * Internal token to indicate whether having multiple bootstrapped platform should be allowed (only
@@ -26570,7 +26813,7 @@ function runPlatformInitializers(injector) {
  */
 function internalCreateApplication(config) {
     const { rootComponent, appProviders, platformProviders } = config;
-    if (NG_DEV_MODE && rootComponent !== undefined) {
+    if ((typeof ngDevMode === 'undefined' || ngDevMode) && rootComponent !== undefined) {
         assertStandaloneComponentType(rootComponent);
     }
     const platformInjector = createOrReusePlatformInjector(platformProviders);
@@ -26584,7 +26827,7 @@ function internalCreateApplication(config) {
         ];
         const envInjector = createEnvironmentInjector(allAppProviders, platformInjector, 'Environment Injector');
         const exceptionHandler = envInjector.get(ErrorHandler, null);
-        if (NG_DEV_MODE && !exceptionHandler) {
+        if ((typeof ngDevMode === 'undefined' || ngDevMode) && !exceptionHandler) {
             throw new RuntimeError(402 /* RuntimeErrorCode.MISSING_REQUIRED_INJECTABLE_IN_BOOTSTRAP */, 'No `ErrorHandler` found in the Dependency Injection tree.');
         }
         let onErrorSubscription;
@@ -26734,7 +26977,7 @@ class PlatformRef {
         return ngZone.run(() => {
             const moduleRef = createNgModuleRefWithProviders(moduleFactory.moduleType, this.injector, provideNgZoneChangeDetection(ngZone));
             const exceptionHandler = moduleRef.injector.get(ErrorHandler, null);
-            if (NG_DEV_MODE && exceptionHandler === null) {
+            if ((typeof ngDevMode === 'undefined' || ngDevMode) && exceptionHandler === null) {
                 throw new RuntimeError(402 /* RuntimeErrorCode.MISSING_REQUIRED_INJECTABLE_IN_BOOTSTRAP */, 'No ErrorHandler. Is platform module (BrowserModule) included?');
             }
             ngZone.runOutsideAngular(() => {
@@ -26834,9 +27077,9 @@ class PlatformRef {
     get destroyed() {
         return this._destroyed;
     }
+    static { this.ɵfac = function PlatformRef_Factory(t) { return new (t || PlatformRef)(ɵɵinject(Injector)); }; }
+    static { this.ɵprov = /*@__PURE__*/ ɵɵdefineInjectable({ token: PlatformRef, factory: PlatformRef.ɵfac, providedIn: 'platform' }); }
 }
-PlatformRef.ɵfac = function PlatformRef_Factory(t) { return new (t || PlatformRef)(ɵɵinject(Injector)); };
-PlatformRef.ɵprov = /*@__PURE__*/ ɵɵdefineInjectable({ token: PlatformRef, factory: PlatformRef.ɵfac, providedIn: 'platform' });
 (function () { (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(PlatformRef, [{
         type: Injectable,
         args: [{ providedIn: 'platform' }]
@@ -27051,7 +27294,7 @@ class ApplicationRef {
      * {@example core/ts/platform/platform.ts region='domNode'}
      */
     bootstrap(componentOrFactory, rootSelectorOrNode) {
-        NG_DEV_MODE && this.warnIfDestroyed();
+        (typeof ngDevMode === 'undefined' || ngDevMode) && this.warnIfDestroyed();
         const isComponentFactory = componentOrFactory instanceof ComponentFactory$1;
         const initStatus = this._injector.get(ApplicationInitStatus);
         if (!initStatus.done) {
@@ -27059,7 +27302,7 @@ class ApplicationRef {
             const errorMessage = 'Cannot bootstrap as there are still asynchronous initializers running.' +
                 (standalone ? '' :
                     ' Bootstrap components in the `ngDoBootstrap` method of the root module.');
-            throw new RuntimeError(405 /* RuntimeErrorCode.ASYNC_INITIALIZERS_STILL_RUNNING */, NG_DEV_MODE && errorMessage);
+            throw new RuntimeError(405 /* RuntimeErrorCode.ASYNC_INITIALIZERS_STILL_RUNNING */, (typeof ngDevMode === 'undefined' || ngDevMode) && errorMessage);
         }
         let componentFactory;
         if (isComponentFactory) {
@@ -27100,7 +27343,7 @@ class ApplicationRef {
      * detection pass during which all change detection must complete.
      */
     tick() {
-        NG_DEV_MODE && this.warnIfDestroyed();
+        (typeof ngDevMode === 'undefined' || ngDevMode) && this.warnIfDestroyed();
         if (this._runningTick) {
             throw new RuntimeError(101 /* RuntimeErrorCode.RECURSIVE_APPLICATION_REF_TICK */, ngDevMode && 'ApplicationRef.tick is called recursively');
         }
@@ -27129,7 +27372,7 @@ class ApplicationRef {
      * This will throw if the view is already attached to a ViewContainer.
      */
     attachView(viewRef) {
-        NG_DEV_MODE && this.warnIfDestroyed();
+        (typeof ngDevMode === 'undefined' || ngDevMode) && this.warnIfDestroyed();
         const view = viewRef;
         this._views.push(view);
         view.attachToAppRef(this);
@@ -27138,7 +27381,7 @@ class ApplicationRef {
      * Detaches a view from dirty checking again.
      */
     detachView(viewRef) {
-        NG_DEV_MODE && this.warnIfDestroyed();
+        (typeof ngDevMode === 'undefined' || ngDevMode) && this.warnIfDestroyed();
         const view = viewRef;
         remove(this._views, view);
         view.detachFromAppRef();
@@ -27186,7 +27429,7 @@ class ApplicationRef {
      * @internal
      */
     onDestroy(callback) {
-        NG_DEV_MODE && this.warnIfDestroyed();
+        (typeof ngDevMode === 'undefined' || ngDevMode) && this.warnIfDestroyed();
         this._destroyListeners.push(callback);
         return () => remove(this._destroyListeners, callback);
     }
@@ -27214,13 +27457,13 @@ class ApplicationRef {
         return this._views.length;
     }
     warnIfDestroyed() {
-        if (NG_DEV_MODE && this._destroyed) {
+        if ((typeof ngDevMode === 'undefined' || ngDevMode) && this._destroyed) {
             console.warn(formatRuntimeError(406 /* RuntimeErrorCode.APPLICATION_REF_ALREADY_DESTROYED */, 'This instance of the `ApplicationRef` has already been destroyed.'));
         }
     }
+    static { this.ɵfac = function ApplicationRef_Factory(t) { return new (t || ApplicationRef)(); }; }
+    static { this.ɵprov = /*@__PURE__*/ ɵɵdefineInjectable({ token: ApplicationRef, factory: ApplicationRef.ɵfac, providedIn: 'root' }); }
 }
-ApplicationRef.ɵfac = function ApplicationRef_Factory(t) { return new (t || ApplicationRef)(); };
-ApplicationRef.ɵprov = /*@__PURE__*/ ɵɵdefineInjectable({ token: ApplicationRef, factory: ApplicationRef.ɵfac, providedIn: 'root' });
 (function () { (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(ApplicationRef, [{
         type: Injectable,
         args: [{ providedIn: 'root' }]
@@ -27245,7 +27488,7 @@ function _lastDefined(args) {
  * `NgZone` is provided by default today so the default (and only) implementation for this
  * is calling `ErrorHandler.handleError` outside of the Angular zone.
  */
-const INTERNAL_APPLICATION_ERROR_HANDLER = new InjectionToken(NG_DEV_MODE ? 'internal error handler' : '', {
+const INTERNAL_APPLICATION_ERROR_HANDLER = new InjectionToken((typeof ngDevMode === 'undefined' || ngDevMode) ? 'internal error handler' : '', {
     providedIn: 'root',
     factory: () => {
         const userErrorHandler = inject(ErrorHandler);
@@ -27277,9 +27520,9 @@ class NgZoneChangeDetectionScheduler {
     ngOnDestroy() {
         this._onMicrotaskEmptySubscription?.unsubscribe();
     }
+    static { this.ɵfac = function NgZoneChangeDetectionScheduler_Factory(t) { return new (t || NgZoneChangeDetectionScheduler)(); }; }
+    static { this.ɵprov = /*@__PURE__*/ ɵɵdefineInjectable({ token: NgZoneChangeDetectionScheduler, factory: NgZoneChangeDetectionScheduler.ɵfac, providedIn: 'root' }); }
 }
-NgZoneChangeDetectionScheduler.ɵfac = function NgZoneChangeDetectionScheduler_Factory(t) { return new (t || NgZoneChangeDetectionScheduler)(); };
-NgZoneChangeDetectionScheduler.ɵprov = /*@__PURE__*/ ɵɵdefineInjectable({ token: NgZoneChangeDetectionScheduler, factory: NgZoneChangeDetectionScheduler.ɵfac, providedIn: 'root' });
 (function () { (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgZoneChangeDetectionScheduler, [{
         type: Injectable,
         args: [{ providedIn: 'root' }]
@@ -27292,8 +27535,10 @@ function provideNgZoneChangeDetection(ngZone) {
             multi: true,
             useFactory: () => {
                 const ngZoneChangeDetectionScheduler = inject(NgZoneChangeDetectionScheduler, { optional: true });
-                if (NG_DEV_MODE && ngZoneChangeDetectionScheduler === null) {
-                    throw new RuntimeError(402 /* RuntimeErrorCode.MISSING_REQUIRED_INJECTABLE_IN_BOOTSTRAP */, 'No NgZoneChangeDetectionScheduler found in the Dependency Injection tree.');
+                if ((typeof ngDevMode === 'undefined' || ngDevMode) &&
+                    ngZoneChangeDetectionScheduler === null) {
+                    throw new RuntimeError(402 /* RuntimeErrorCode.MISSING_REQUIRED_INJECTABLE_IN_BOOTSTRAP */, `A required Injectable was not found in the dependency injection tree. ` +
+                        'If you are bootstrapping an NgModule, make sure that the `BrowserModule` is imported.');
                 }
                 return () => ngZoneChangeDetectionScheduler.initialize();
             },
@@ -27350,17 +27595,17 @@ function enableProdMode() {
  * @publicApi
  */
 class DestroyRef {
+    /**
+     * @internal
+     * @nocollapse
+     */
+    static { this.__NG_ELEMENT_ID__ = injectDestroyRef; }
+    /**
+     * @internal
+     * @nocollapse
+     */
+    static { this.__NG_ENV_ID__ = (injector) => injector; }
 }
-/**
- * @internal
- * @nocollapse
- */
-DestroyRef.__NG_ELEMENT_ID__ = injectDestroyRef;
-/**
- * @internal
- * @nocollapse
- */
-DestroyRef.__NG_ENV_ID__ = (injector) => injector;
 class NodeInjectorDestroyRef extends DestroyRef {
     constructor(_lView) {
         super();
@@ -27450,12 +27695,12 @@ function noModuleError(id) {
  * @publicApi
  */
 class ChangeDetectorRef {
+    /**
+     * @internal
+     * @nocollapse
+     */
+    static { this.__NG_ELEMENT_ID__ = injectChangeDetectorRef; }
 }
-/**
- * @internal
- * @nocollapse
- */
-ChangeDetectorRef.__NG_ELEMENT_ID__ = injectChangeDetectorRef;
 /** Returns a ChangeDetectorRef (a.k.a. a ViewRef) */
 function injectChangeDetectorRef(flags) {
     return createViewRef(getCurrentTNode(), getLView(), (flags & 16 /* InternalInjectFlags.ForPipe */) === 16 /* InternalInjectFlags.ForPipe */);
@@ -29033,6 +29278,8 @@ function defaultIterableDiffersFactory() {
  * @publicApi
  */
 class IterableDiffers {
+    /** @nocollapse */
+    static { this.ɵprov = ɵɵdefineInjectable({ token: IterableDiffers, providedIn: 'root', factory: defaultIterableDiffersFactory }); }
     constructor(factories) {
         this.factories = factories;
     }
@@ -29087,8 +29334,6 @@ class IterableDiffers {
         }
     }
 }
-/** @nocollapse */
-IterableDiffers.ɵprov = ɵɵdefineInjectable({ token: IterableDiffers, providedIn: 'root', factory: defaultIterableDiffersFactory });
 function getTypeNameForDebugging(type) {
     return type['name'] || typeof type;
 }
@@ -29102,6 +29347,8 @@ function defaultKeyValueDiffersFactory() {
  * @publicApi
  */
 class KeyValueDiffers {
+    /** @nocollapse */
+    static { this.ɵprov = ɵɵdefineInjectable({ token: KeyValueDiffers, providedIn: 'root', factory: defaultKeyValueDiffersFactory }); }
     constructor(factories) {
         this.factories = factories;
     }
@@ -29153,8 +29400,6 @@ class KeyValueDiffers {
         throw new RuntimeError(901 /* RuntimeErrorCode.NO_SUPPORTING_DIFFER_FACTORY */, ngDevMode && `Cannot find a differ supporting object '${kv}'`);
     }
 }
-/** @nocollapse */
-KeyValueDiffers.ɵprov = ɵɵdefineInjectable({ token: KeyValueDiffers, providedIn: 'root', factory: defaultKeyValueDiffersFactory });
 
 /**
  * Structural diffing for `Object`s and `Map`s.
@@ -29190,10 +29435,10 @@ const platformCore = createPlatformFactory(null, 'core', []);
 class ApplicationModule {
     // Inject ApplicationRef to make it eager...
     constructor(appRef) { }
+    static { this.ɵfac = function ApplicationModule_Factory(t) { return new (t || ApplicationModule)(ɵɵinject(ApplicationRef)); }; }
+    static { this.ɵmod = /*@__PURE__*/ ɵɵdefineNgModule({ type: ApplicationModule }); }
+    static { this.ɵinj = /*@__PURE__*/ ɵɵdefineInjector({}); }
 }
-ApplicationModule.ɵfac = function ApplicationModule_Factory(t) { return new (t || ApplicationModule)(ɵɵinject(ApplicationRef)); };
-ApplicationModule.ɵmod = /*@__PURE__*/ ɵɵdefineNgModule({ type: ApplicationModule });
-ApplicationModule.ɵinj = /*@__PURE__*/ ɵɵdefineInjector({});
 (function () { (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(ApplicationModule, [{
         type: NgModule
     }], function () { return [{ type: ApplicationRef }]; }, null); })();
@@ -29326,7 +29571,7 @@ function serializeLContainer(lContainer, context) {
         const currentViewAsString = JSON.stringify(view);
         if (views.length > 0 && currentViewAsString === lastViewAsString) {
             const previousView = views[views.length - 1];
-            previousView[MULTIPLIER] ?? (previousView[MULTIPLIER] = 1);
+            previousView[MULTIPLIER] ??= 1;
             previousView[MULTIPLIER]++;
         }
         else {
@@ -29344,9 +29589,21 @@ function serializeLContainer(lContainer, context) {
  */
 function appendSerializedNodePath(ngh, tNode, lView) {
     const noOffsetIndex = tNode.index - HEADER_OFFSET;
-    ngh[NODES] ?? (ngh[NODES] = {});
+    ngh[NODES] ??= {};
     ngh[NODES][noOffsetIndex] = calcPathForNode(tNode, lView);
 }
+/**
+ * Helper function to append information about a disconnected node.
+ * This info is needed at runtime to avoid DOM lookups for this element
+ * and instead, the element would be created from scratch.
+ */
+function appendDisconnectedNodeIndex(ngh, tNode) {
+    const noOffsetIndex = tNode.index - HEADER_OFFSET;
+    ngh[DISCONNECTED_NODES] ??= [];
+    if (!ngh[DISCONNECTED_NODES].includes(noOffsetIndex)) {
+        ngh[DISCONNECTED_NODES].push(noOffsetIndex);
+    }
+}
 /**
  * There is no special TNode type for an i18n block, so we verify
  * whether the structure that we store at the `TView.data[idx]` position
@@ -29386,14 +29643,8 @@ function serializeLView(lView, context) {
         // This situation may happen during the content projection, when some nodes don't make it
         // into one of the content projection slots (for example, when there is no default
         // <ng-content /> slot in projector component's template).
-        //
-        // Note: we leverage the fact that we have this information available in the DOM emulation
-        // layer (in Domino) for now. Longer-term solution should not rely on the DOM emulation and
-        // only use internal data structures and state to compute this information.
-        if (!(tNode.type & 16 /* TNodeType.Projection */) && !!lView[i] &&
-            !unwrapRNode(lView[i]).isConnected) {
-            ngh[DISCONNECTED_NODES] ?? (ngh[DISCONNECTED_NODES] = []);
-            ngh[DISCONNECTED_NODES].push(noOffsetIndex);
+        if (isDisconnectedNode(tNode, lView) && isContentProjectedNode(tNode)) {
+            appendDisconnectedNodeIndex(ngh, tNode);
             continue;
         }
         if (Array.isArray(tNode.projection)) {
@@ -29408,7 +29659,16 @@ function serializeLView(lView, context) {
                     // a parent lView, which contains those nodes.
                     if (!isProjectionTNode(projectionHeadTNode) &&
                         !isInSkipHydrationBlock(projectionHeadTNode)) {
-                        appendSerializedNodePath(ngh, projectionHeadTNode, lView);
+                        if (isDisconnectedNode(projectionHeadTNode, lView)) {
+                            // Check whether this node is connected, since we may have a TNode
+                            // in the data structure as a projection segment head, but the
+                            // content projection slot might be disabled (e.g.
+                            // <ng-content *ngIf="false" />).
+                            appendDisconnectedNodeIndex(ngh, projectionHeadTNode);
+                        }
+                        else {
+                            appendSerializedNodePath(ngh, projectionHeadTNode, lView);
+                        }
                     }
                 }
                 else {
@@ -29428,7 +29688,7 @@ function serializeLView(lView, context) {
             // Serialize information about a template.
             const embeddedTView = tNode.tView;
             if (embeddedTView !== null) {
-                ngh[TEMPLATES] ?? (ngh[TEMPLATES] = {});
+                ngh[TEMPLATES] ??= {};
                 ngh[TEMPLATES][noOffsetIndex] = getSsrId(embeddedTView);
             }
             // Serialize views within this LContainer.
@@ -29443,7 +29703,7 @@ function serializeLView(lView, context) {
                     annotateHostElementForHydration(targetNode, hostNode, context);
                 }
             }
-            ngh[CONTAINERS] ?? (ngh[CONTAINERS] = {});
+            ngh[CONTAINERS] ??= {};
             ngh[CONTAINERS][noOffsetIndex] = serializeLContainer(lView[i], context);
         }
         else if (Array.isArray(lView[i])) {
@@ -29471,7 +29731,7 @@ function serializeLView(lView, context) {
                 // An <ng-container> is represented by the number of
                 // top-level nodes. This information is needed to skip over
                 // those nodes to reach a corresponding anchor node (comment node).
-                ngh[ELEMENT_CONTAINERS] ?? (ngh[ELEMENT_CONTAINERS] = {});
+                ngh[ELEMENT_CONTAINERS] ??= {};
                 ngh[ELEMENT_CONTAINERS][noOffsetIndex] = calcNumRootNodes(tView, lView, tNode.child);
             }
             else if (tNode.type & 16 /* TNodeType.Projection */) {
@@ -29563,32 +29823,122 @@ function insertCorruptedTextNodeMarkers(corruptedTextNodes, doc) {
         textNode.after(doc.createComment(marker));
     }
 }
-
 /**
- * Indicates whether the hydration-related code was added,
- * prevents adding it multiple times.
+ * Detects whether a given TNode represents a node that
+ * is being content projected.
  */
-let isHydrationSupportEnabled = false;
+function isContentProjectedNode(tNode) {
+    let currentTNode = tNode;
+    while (currentTNode != null) {
+        // If we come across a component host node in parent nodes -
+        // this TNode is in the content projection section.
+        if (isComponentHost(currentTNode)) {
+            return true;
+        }
+        currentTNode = currentTNode.parent;
+    }
+    return false;
+}
 /**
- * Brings the necessary hydration code in tree-shakable manner.
- * The code is only present when the `provideHydrationSupport` is
- * invoked. Otherwise, this code is tree-shaken away during the
- * build optimization step.
+ * Check whether a given node exists, but is disconnected from the DOM.
  *
- * 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.
+ * Note: we leverage the fact that we have this information available in the DOM emulation
+ * layer (in Domino) for now. Longer-term solution should not rely on the DOM emulation and
+ * only use internal data structures and state to compute this information.
  */
-function enableHydrationRuntimeSupport() {
-    if (!isHydrationSupportEnabled) {
-        isHydrationSupportEnabled = true;
-        enableRetrieveHydrationInfoImpl();
-        enableLocateOrCreateElementNodeImpl();
-        enableLocateOrCreateTextNodeImpl();
-        enableLocateOrCreateElementContainerNodeImpl();
-        enableLocateOrCreateContainerAnchorImpl();
-        enableLocateOrCreateContainerRefImpl();
+function isDisconnectedNode(tNode, lView) {
+    return !(tNode.type & 16 /* TNodeType.Projection */) && !!lView[tNode.index] &&
+        !unwrapRNode(lView[tNode.index]).isConnected;
+}
+
+/**
+ * *Internal* service that keeps track of pending tasks happening in the system
+ * during the initial rendering. No tasks are tracked after an initial
+ * rendering.
+ *
+ * This information is needed to make sure that the serialization on the server
+ * is delayed until all tasks in the queue (such as an initial navigation or a
+ * pending HTTP request) are completed.
+ */
+class InitialRenderPendingTasks {
+    get whenAllTasksComplete() {
+        if (this.collection.size > 0) {
+            return this.promise;
+        }
+        return Promise.resolve().then(() => {
+            this.completed = true;
+        });
+    }
+    constructor() {
+        this.taskId = 0;
+        this.collection = new Set();
+        this.ngZone = inject(NgZone);
+        this.completed = false;
+        // Run outside of the Angular zone to avoid triggering
+        // extra change detection cycles.
+        this.ngZone.runOutsideAngular(() => {
+            this.promise = new Promise((resolve) => {
+                this.resolve = resolve;
+            });
+        });
+    }
+    add() {
+        if (this.completed) {
+            // Indicates that the task was added after
+            // the task queue completion, so it's a noop.
+            return -1;
+        }
+        const taskId = this.taskId++;
+        this.collection.add(taskId);
+        return taskId;
+    }
+    remove(taskId) {
+        if (this.completed)
+            return;
+        this.collection.delete(taskId);
+        if (this.collection.size === 0) {
+            // We've removed the last task, resolve the promise.
+            this.completed = true;
+            this.resolve();
+        }
+    }
+    ngOnDestroy() {
+        this.completed = true;
+        this.collection.clear();
+    }
+    static { this.ɵfac = function InitialRenderPendingTasks_Factory(t) { return new (t || InitialRenderPendingTasks)(); }; }
+    static { this.ɵprov = /*@__PURE__*/ ɵɵdefineInjectable({ token: InitialRenderPendingTasks, factory: InitialRenderPendingTasks.ɵfac, providedIn: 'root' }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(InitialRenderPendingTasks, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], function () { return []; }, null); })();
+
+/**
+ * Indicates whether the hydration-related code was added,
+ * prevents adding it multiple times.
+ */
+let isHydrationSupportEnabled = false;
+/**
+ * Brings the necessary hydration code in tree-shakable manner.
+ * The code is only present when the `provideHydrationSupport` 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();
     }
@@ -29675,7 +30025,8 @@ function provideHydrationSupport() {
             useFactory: () => {
                 if (isBrowser()) {
                     const appRef = inject(ApplicationRef);
-                    return () => cleanupDehydratedViews(appRef);
+                    const pendingTasks = inject(InitialRenderPendingTasks);
+                    return () => cleanupDehydratedViews(appRef, pendingTasks);
                 }
                 return () => { }; // noop
             },
@@ -29694,14 +30045,14 @@ const SIGNAL = Symbol('SIGNAL');
  * Checks if the given `value` function is a reactive `Signal`.
  */
 function isSignal(value) {
-    return value[SIGNAL] ?? false;
+    return value[SIGNAL] !== undefined;
 }
 /**
  * Converts `fn` into a marked signal function (where `isSignal(fn)` will be `true`), and
  * potentially add some set of extra properties (passed as an object record `extraApi`).
  */
-function createSignalFromFunction(fn, extraApi = {}) {
-    fn[SIGNAL] = true;
+function createSignalFromFunction(node, fn, extraApi = {}) {
+    fn[SIGNAL] = node;
     // Copy properties from `extraApi` to `fn` to complete the desired API of the `Signal`.
     return Object.assign(fn, extraApi);
 }
@@ -29722,141 +30073,18 @@ function defaultEquals(a, b) {
     // as objects (`typeof null === 'object'`).
     return (a === null || typeof a !== 'object') && Object.is(a, b);
 }
-
-/**
- * Tracks the currently active reactive context (or `null` if there is no active
- * context).
- */
-let activeConsumer = null;
-/**
- * Counter tracking the next `ProducerId` or `ConsumerId`.
- */
-let _nextReactiveId = 0;
-/**
- * Get a new `ProducerId` or `ConsumerId`, allocated from the global sequence.
- *
- * The value returned is a type intersection of both branded types, and thus can be assigned to
- * either.
- */
-function nextReactiveId() {
-    return _nextReactiveId++;
-}
-/**
- * Set `consumer` as the active reactive context, and return the previous `Consumer`
- * (if any) for later restoration.
- */
-function setActiveConsumer(consumer) {
-    const prevConsumer = activeConsumer;
-    activeConsumer = consumer;
-    return prevConsumer;
-}
-/**
- * Notify all `Consumer`s of the given `Producer` that its value may have changed.
- */
-function producerNotifyConsumers(producer) {
-    for (const [consumerId, edge] of producer.consumers) {
-        const consumer = edge.consumerRef.deref();
-        if (consumer === undefined || consumer.trackingVersion !== edge.atTrackingVersion) {
-            producer.consumers.delete(consumerId);
-            consumer?.producers.delete(producer.id);
-            continue;
-        }
-        consumer.notify();
-    }
-}
-/**
- * Record a dependency on the given `Producer` by the current reactive `Consumer` if
- * one is present.
- */
-function producerAccessed(producer) {
-    if (activeConsumer === null) {
-        return;
-    }
-    // Either create or update the dependency `Edge` in both directions.
-    let edge = activeConsumer.producers.get(producer.id);
-    if (edge === undefined) {
-        edge = {
-            consumerRef: activeConsumer.ref,
-            producerRef: producer.ref,
-            seenValueVersion: producer.valueVersion,
-            atTrackingVersion: activeConsumer.trackingVersion,
-        };
-        activeConsumer.producers.set(producer.id, edge);
-        producer.consumers.set(activeConsumer.id, edge);
-    }
-    else {
-        edge.seenValueVersion = producer.valueVersion;
-        edge.atTrackingVersion = activeConsumer.trackingVersion;
-    }
-}
-/**
- * Checks if a `Producer` has a current value which is different than the value
- * last seen at a specific version by a `Consumer` which recorded a dependency on
- * this `Producer`.
- */
-function producerPollStatus(producer, lastSeenValueVersion) {
-    // `producer.valueVersion` may be stale, but a mismatch still means that the value
-    // last seen by the `Consumer` is also stale.
-    if (producer.valueVersion !== lastSeenValueVersion) {
-        return true;
-    }
-    // Trigger the `Producer` to update its `valueVersion` if necessary.
-    producer.checkForChangedValue();
-    // At this point, we can trust `producer.valueVersion`.
-    return producer.valueVersion !== lastSeenValueVersion;
-}
-/**
- * Function called to check the stale status of dependencies (producers) for a given consumer. This
- * is a verification step before refreshing a given consumer: if none of the the dependencies
- * reports a semantically new value, then the `Consumer` has not observed a real dependency change
- * (even though it may have been notified of one).
- */
-function consumerPollValueStatus(consumer) {
-    for (const [producerId, edge] of consumer.producers) {
-        const producer = edge.producerRef.deref();
-        if (producer === undefined || edge.atTrackingVersion !== consumer.trackingVersion) {
-            // This dependency edge is stale, so remove it.
-            consumer.producers.delete(producerId);
-            producer?.consumers.delete(consumer.id);
-            continue;
-        }
-        if (producerPollStatus(producer, edge.seenValueVersion)) {
-            // One of the dependencies reports a real value change.
-            return true;
-        }
-    }
-    // No dependency reported a real value change, so the `Consumer` has also not been
-    // impacted.
-    return false;
-}
-
-// `WeakRef` is not always defined in every TS environment where Angular is compiled. Instead,
-// read it off of the global context if available.
-// tslint:disable-next-line: no-toplevel-property-access
-let WeakRefImpl = _global['WeakRef'];
-function newWeakRef(value) {
-    if (typeof ngDevMode !== 'undefined' && ngDevMode && WeakRefImpl === undefined) {
-        throw new Error(`Angular requires a browser which supports the 'WeakRef' API`);
-    }
-    return new WeakRefImpl(value);
-}
-/**
- * Use an alternate implementation of `WeakRef` if a platform implementation isn't available.
- */
-function setAlternateWeakRefImpl(impl) {
-    if (!WeakRefImpl) {
-        WeakRefImpl = impl;
-    }
-}
+// clang-format on
 
 /**
  * Create a computed `Signal` which derives a reactive value from an expression.
  *
  * @developerPreview
  */
-function computed(computation, equal = defaultEquals) {
-    const node = new ComputedImpl(computation, equal);
-    return createSignalFromFunction(node.signal.bind(node));
+function computed(computation, options) {
+    const node = new ComputedImpl(computation, options?.equal ?? defaultEquals);
+    // Casting here is required for g3, as TS inference behavior is slightly different between our
+    // version/options and g3's.
+    return createSignalFromFunction(node, node.signal.bind(node));
 }
 /**
  * A dedicated symbol used before a computed value has been calculated for the first time.
@@ -29878,10 +30106,11 @@ const ERRORED = Symbol('ERRORED');
 /**
  * A computation, which derives a value from a declarative reactive expression.
  *
- * `Computed`s are both `Producer`s and `Consumer`s of reactivity.
+ * `Computed`s are both producers and consumers of reactivity.
  */
-class ComputedImpl {
+class ComputedImpl extends ReactiveNode {
     constructor(computation, equal) {
+        super();
         this.computation = computation;
         this.equal = equal;
         /**
@@ -29903,20 +30132,25 @@ class ComputedImpl {
          * state can be resolved without recomputing the value.
          */
         this.stale = true;
-        this.id = nextReactiveId();
-        this.ref = newWeakRef(this);
-        this.producers = new Map();
-        this.consumers = new Map();
-        this.trackingVersion = 0;
-        this.valueVersion = 0;
     }
-    checkForChangedValue() {
+    onConsumerDependencyMayHaveChanged() {
+        if (this.stale) {
+            // We've already notified consumers that this value has potentially changed.
+            return;
+        }
+        // Record that the currently cached value may be stale.
+        this.stale = true;
+        // Notify any consumers about the potential change.
+        this.producerMayHaveChanged();
+    }
+    onProducerUpdateValueVersion() {
         if (!this.stale) {
             // The current value and its version are already up to date.
             return;
         }
         // The current value is stale. Check whether we need to produce a new one.
-        if (this.value !== UNSET && this.value !== COMPUTING && !consumerPollValueStatus(this)) {
+        if (this.value !== UNSET && this.value !== COMPUTING &&
+            !this.consumerPollProducersForChange()) {
             // Even though we were previously notified of a potential dependency update, all of
             // our dependencies report that they have not actually changed in value, so we can
             // resolve the stale state without needing to recompute the current value.
@@ -29959,21 +30193,11 @@ class ComputedImpl {
         this.value = newValue;
         this.valueVersion++;
     }
-    notify() {
-        if (this.stale) {
-            // We've already notified consumers that this value has potentially changed.
-            return;
-        }
-        // Record that the currently cached value may be stale.
-        this.stale = true;
-        // Notify any consumers about the potential change.
-        producerNotifyConsumers(this);
-    }
     signal() {
         // Check if the value needs updating before returning it.
-        this.checkForChangedValue();
+        this.onProducerUpdateValueVersion();
         // Record that someone looked at this signal.
-        producerAccessed(this);
+        this.producerAccessed();
         if (this.value === ERRORED) {
             throw this.error;
         }
@@ -29981,124 +30205,17 @@ class ComputedImpl {
     }
 }
 
-/**
- * Watches a reactive expression and allows it to be scheduled to re-run
- * when any dependencies notify of a change.
- *
- * `Watch` doesn't run reactive expressions itself, but relies on a consumer-
- * provided scheduling operation to coordinate calling `Watch.run()`.
- */
-class Watch {
-    constructor(watch, schedule) {
-        this.watch = watch;
-        this.schedule = schedule;
-        this.id = nextReactiveId();
-        this.ref = newWeakRef(this);
-        this.producers = new Map();
-        this.trackingVersion = 0;
-        this.dirty = false;
-    }
-    notify() {
-        if (!this.dirty) {
-            this.schedule(this);
-        }
-        this.dirty = true;
-    }
-    /**
-     * Execute the reactive expression in the context of this `Watch` consumer.
-     *
-     * Should be called by the user scheduling algorithm when the provided
-     * `schedule` hook is called by `Watch`.
-     */
-    run() {
-        this.dirty = false;
-        if (this.trackingVersion !== 0 && !consumerPollValueStatus(this)) {
-            return;
-        }
-        const prevConsumer = setActiveConsumer(this);
-        this.trackingVersion++;
-        try {
-            this.watch();
-        }
-        finally {
-            setActiveConsumer(prevConsumer);
-        }
-    }
-}
-
-/**
- * Create a global `Effect` for the given reactive function.
- *
- * @developerPreview
- */
-function effect(effectFn) {
-    const watch = new Watch(effectFn, queueWatch);
-    globalWatches.add(watch);
-    // Effects start dirty.
-    watch.notify();
-    return {
-        destroy: () => {
-            queuedWatches.delete(watch);
-            globalWatches.delete(watch);
-        },
-    };
-}
-/**
- * Get a `Promise` that resolves when any scheduled effects have resolved.
- */
-function effectsDone() {
-    return watchQueuePromise?.promise ?? Promise.resolve();
-}
-/**
- * Shut down all active effects.
- */
-function resetEffects() {
-    queuedWatches.clear();
-    globalWatches.clear();
-}
-const globalWatches = new Set();
-const queuedWatches = new Set();
-let watchQueuePromise = null;
-function queueWatch(watch) {
-    if (queuedWatches.has(watch) || !globalWatches.has(watch)) {
-        return;
-    }
-    queuedWatches.add(watch);
-    if (watchQueuePromise === null) {
-        Promise.resolve().then(runWatchQueue);
-        let resolveFn;
-        const promise = new Promise((resolve) => {
-            resolveFn = resolve;
-        });
-        watchQueuePromise = {
-            promise,
-            resolveFn,
-        };
-    }
-}
-function runWatchQueue() {
-    for (const watch of queuedWatches) {
-        queuedWatches.delete(watch);
-        watch.run();
-    }
-    watchQueuePromise.resolveFn();
-    watchQueuePromise = null;
-}
-
-/**
- * Backing type for a `SettableSignal`, a mutable reactive value.
- */
-class SettableSignalImpl {
+class WritableSignalImpl extends ReactiveNode {
     constructor(value, equal) {
+        super();
         this.value = value;
         this.equal = equal;
-        this.id = nextReactiveId();
-        this.ref = newWeakRef(this);
-        this.consumers = new Map();
-        this.valueVersion = 0;
     }
-    checkForChangedValue() {
-        // Settable signals can only change when set, so there's nothing to check here.
+    onConsumerDependencyMayHaveChanged() {
+        // This never happens for writable signals as they're not consumers.
+    }
+    onProducerUpdateValueVersion() {
+        // Writable signal value versions are always up to date.
     }
     /**
      * Directly update the value of the signal to a new value, which may or may not be
@@ -30111,7 +30228,7 @@ class SettableSignalImpl {
         if (!this.equal(this.value, newValue)) {
             this.value = newValue;
             this.valueVersion++;
-            producerNotifyConsumers(this);
+            this.producerMayHaveChanged();
         }
     }
     /**
@@ -30130,10 +30247,10 @@ class SettableSignalImpl {
         // Mutate bypasses equality checks as it's by definition changing the value.
         mutator(this.value);
         this.valueVersion++;
-        producerNotifyConsumers(this);
+        this.producerMayHaveChanged();
     }
     signal() {
-        producerAccessed(this);
+        this.producerAccessed();
         return this.value;
     }
 }
@@ -30142,10 +30259,11 @@ class SettableSignalImpl {
  *
  * @developerPreview
  */
-function signal(initialValue, equal = defaultEquals) {
-    const signalNode = new SettableSignalImpl(initialValue, equal);
-    // Casting here is required for g3.
-    const signalFn = createSignalFromFunction(signalNode.signal.bind(signalNode), {
+function signal(initialValue, options) {
+    const signalNode = new WritableSignalImpl(initialValue, options?.equal ?? defaultEquals);
+    // Casting here is required for g3, as TS inference behavior is slightly different between our
+    // version/options and g3's.
+    const signalFn = createSignalFromFunction(signalNode, signalNode.signal.bind(signalNode), {
         set: signalNode.set.bind(signalNode),
         update: signalNode.update.bind(signalNode),
         mutate: signalNode.mutate.bind(signalNode),
@@ -30171,6 +30289,60 @@ function untracked(nonReactiveReadsFn) {
     }
 }
 
+const NOOP_CLEANUP_FN = () => { };
+/**
+ * Watches a reactive expression and allows it to be scheduled to re-run
+ * when any dependencies notify of a change.
+ *
+ * `Watch` doesn't run reactive expressions itself, but relies on a consumer-
+ * provided scheduling operation to coordinate calling `Watch.run()`.
+ */
+class Watch extends ReactiveNode {
+    constructor(watch, schedule) {
+        super();
+        this.watch = watch;
+        this.schedule = schedule;
+        this.dirty = false;
+        this.cleanupFn = NOOP_CLEANUP_FN;
+    }
+    notify() {
+        if (!this.dirty) {
+            this.schedule(this);
+        }
+        this.dirty = true;
+    }
+    onConsumerDependencyMayHaveChanged() {
+        this.notify();
+    }
+    onProducerUpdateValueVersion() {
+        // Watches are not producers.
+    }
+    /**
+     * Execute the reactive expression in the context of this `Watch` consumer.
+     *
+     * Should be called by the user scheduling algorithm when the provided
+     * `schedule` hook is called by `Watch`.
+     */
+    run() {
+        this.dirty = false;
+        if (this.trackingVersion !== 0 && !this.consumerPollProducersForChange()) {
+            return;
+        }
+        const prevConsumer = setActiveConsumer(this);
+        this.trackingVersion++;
+        try {
+            this.cleanupFn();
+            this.cleanupFn = this.watch() ?? NOOP_CLEANUP_FN;
+        }
+        finally {
+            setActiveConsumer(prevConsumer);
+        }
+    }
+    cleanup() {
+        this.cleanupFn();
+    }
+}
+
 /** Coerces a value (typically a string) to a boolean. */
 function coerceToBoolean(value) {
     return typeof value === 'boolean' ? value : (value != null && value !== 'false');
@@ -30269,6 +30441,64 @@ function ɵɵngDeclarePipe(decl) {
 // clang-format off
 // clang-format on
 
+const globalWatches = new Set();
+const queuedWatches = new Map();
+let watchQueuePromise = null;
+/**
+ * Create a global `Effect` for the given reactive function.
+ *
+ * @developerPreview
+ */
+function effect(effectFn, options) {
+    !options?.injector && assertInInjectionContext(effect);
+    const zone = Zone.current;
+    const watch = new Watch(effectFn, (watch) => queueWatch(watch, zone));
+    const injector = options?.injector ?? inject(Injector);
+    const destroyRef = options?.manualCleanup !== true ? injector.get(DestroyRef) : null;
+    globalWatches.add(watch);
+    // Effects start dirty.
+    watch.notify();
+    let unregisterOnDestroy;
+    const destroy = () => {
+        watch.cleanup();
+        unregisterOnDestroy?.();
+        queuedWatches.delete(watch);
+        globalWatches.delete(watch);
+    };
+    unregisterOnDestroy = destroyRef?.onDestroy(destroy);
+    return {
+        destroy,
+    };
+}
+function queueWatch(watch, zone) {
+    if (queuedWatches.has(watch) || !globalWatches.has(watch)) {
+        return;
+    }
+    queuedWatches.set(watch, zone);
+    if (watchQueuePromise === null) {
+        Promise.resolve().then(runWatchQueue);
+        let resolveFn;
+        const promise = new Promise((resolve) => {
+            resolveFn = resolve;
+        });
+        watchQueuePromise = {
+            promise,
+            resolveFn,
+        };
+    }
+}
+function runWatchQueue() {
+    for (const [watch, zone] of queuedWatches) {
+        queuedWatches.delete(watch);
+        zone.run(() => watch.run());
+    }
+    watchQueuePromise.resolveFn();
+    watchQueuePromise = null;
+}
+
+// clang-format off
+// clang-format on
+
 // This file exists to allow the set of reactivity exports to be modified in g3, as these APIs are
 
 /**
@@ -30452,5 +30682,5 @@ if (typeof ngDevMode !== 'undefined' && ngDevMode) {
  * Generated bundle index. Do not edit.
  */
 
-export { ANALYZE_FOR_ENTRY_COMPONENTS, ANIMATION_MODULE_TYPE, APP_BOOTSTRAP_LISTENER, APP_ID, APP_INITIALIZER, ApplicationInitStatus, ApplicationModule, ApplicationRef, Attribute, COMPILER_OPTIONS, CSP_NONCE, CUSTOM_ELEMENTS_SCHEMA, ChangeDetectionStrategy, ChangeDetectorRef, Compiler, CompilerFactory, Component, ComponentFactory$1 as ComponentFactory, ComponentFactoryResolver$1 as ComponentFactoryResolver, ComponentRef$1 as ComponentRef, ContentChild, ContentChildren, DEFAULT_CURRENCY_CODE, DebugElement, DebugEventListener, DebugNode, DefaultIterableDiffer, DestroyRef, Directive, ENVIRONMENT_INITIALIZER, ElementRef, EmbeddedViewRef, EnvironmentInjector, ErrorHandler, EventEmitter, Host, HostBinding, HostListener, INJECTOR, Inject, InjectFlags, Injectable, InjectionToken, Injector, Input, IterableDiffers, KeyValueDiffers, LOCALE_ID, MissingTranslationStrategy, ModuleWithComponentFactories, NO_ERRORS_SCHEMA, NgModule, NgModuleFactory$1 as NgModuleFactory, NgModuleRef$1 as NgModuleRef, NgProbeToken, NgZone, Optional, Output, PACKAGE_ROOT_URL, PLATFORM_ID, PLATFORM_INITIALIZER, Pipe, PlatformRef, Query, QueryList, ReflectiveInjector, ReflectiveKey, Renderer2, RendererFactory2, RendererStyleFlags2, ResolvedReflectiveFactory, Sanitizer, SecurityContext, Self, SimpleChange, SkipSelf, TRANSLATIONS, TRANSLATIONS_FORMAT, TemplateRef, Testability, TestabilityRegistry, Type, VERSION, Version, ViewChild, ViewChildren, ViewContainerRef, ViewEncapsulation$1 as ViewEncapsulation, ViewRef, asNativeElements, assertPlatform, computed, createComponent, createEnvironmentInjector, createNgModule, createNgModuleRef, createPlatform, createPlatformFactory, defineInjectable, destroyPlatform, effect, enableProdMode, forwardRef, getDebugNode, getModuleFactory, getNgModuleById, getPlatform, importProvidersFrom, inject, isDevMode, isSignal, isStandalone, makeEnvironmentProviders, mergeApplicationConfig, platformCore, reflectComponentType, resolveForwardRef, runInInjectionContext, setTestabilityGetter, signal, untracked, ALLOW_MULTIPLE_PLATFORMS as ɵALLOW_MULTIPLE_PLATFORMS, ComponentFactory$1 as ɵComponentFactory, Console as ɵConsole, DEFAULT_LOCALE_ID as ɵDEFAULT_LOCALE_ID, INJECTOR_SCOPE as ɵINJECTOR_SCOPE, IS_HYDRATION_FEATURE_ENABLED as ɵIS_HYDRATION_FEATURE_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, ReflectionCapabilities as ɵReflectionCapabilities, ComponentFactory as ɵRender3ComponentFactory, ComponentRef as ɵRender3ComponentRef, NgModuleRef as ɵRender3NgModuleRef, RuntimeError as ɵRuntimeError, TESTABILITY as ɵTESTABILITY, TESTABILITY_GETTER as ɵTESTABILITY_GETTER, TransferState as ɵTransferState, 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, coerceToBoolean as ɵcoerceToBoolean, 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, detectChanges as ɵdetectChanges, devModeEqual as ɵdevModeEqual, escapeTransferStateContent as ɵescapeTransferStateContent, findLocaleData as ɵfindLocaleData, flushModuleScopingQueueAsMuchAsPossible as ɵflushModuleScopingQueueAsMuchAsPossible, formatRuntimeError as ɵformatRuntimeError, getDebugNode as ɵgetDebugNode, getDirectives as ɵgetDirectives, getHostElement as ɵgetHostElement, getInjectableDef as ɵgetInjectableDef, getLContext as ɵgetLContext, getLocaleCurrencyCode as ɵgetLocaleCurrencyCode, getLocalePluralCase as ɵgetLocalePluralCase, getSanitizationBypassType as ɵgetSanitizationBypassType, ɵgetUnknownElementStrictMode, ɵgetUnknownPropertyStrictMode, _global as ɵglobal, injectChangeDetectorRef as ɵinjectChangeDetectorRef, internalCreateApplication as ɵinternalCreateApplication, isBoundToModule as ɵisBoundToModule, isEnvironmentProviders as ɵisEnvironmentProviders, isInjectable as ɵisInjectable, isNgModule as ɵisNgModule, isPromise as ɵisPromise, isSubscribable as ɵisSubscribable, makeDecorator as ɵmakeDecorator, makeStateKey as ɵmakeStateKey, noSideEffects as ɵnoSideEffects, patchComponentDefWithScope as ɵpatchComponentDefWithScope, provideHydrationSupport as ɵprovideHydrationSupport, provideNgZoneChangeDetection as ɵprovideNgZoneChangeDetection, publishDefaultGlobalUtils$1 as ɵpublishDefaultGlobalUtils, publishGlobalUtil as ɵpublishGlobalUtil, registerLocaleData as ɵregisterLocaleData, resetCompiledComponents as ɵresetCompiledComponents, resetJitOptions as ɵresetJitOptions, resolveComponentResources as ɵresolveComponentResources, setAllowDuplicateNgModuleIdsForTest as ɵsetAllowDuplicateNgModuleIdsForTest, setAlternateWeakRefImpl as ɵsetAlternateWeakRefImpl, setClassMetadata as ɵsetClassMetadata, setCurrentInjector as ɵsetCurrentInjector, setDocument as ɵsetDocument, setLocaleId as ɵsetLocaleId, ɵsetUnknownElementStrictMode, ɵsetUnknownPropertyStrictMode, store as ɵstore, stringify as ɵstringify, transitiveScopesFor as ɵtransitiveScopesFor, unescapeTransferStateContent as ɵunescapeTransferStateContent, unregisterAllLocaleData as ɵunregisterLocaleData, unwrapSafeValue as ɵunwrapSafeValue, ɵɵCopyDefinitionFeature, FactoryTarget as ɵɵFactoryTarget, ɵɵHostDirectivesFeature, ɵɵInheritDefinitionFeature, ɵɵ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, ɵɵcontentQuery, ɵɵdefineComponent, ɵɵdefineDirective, ɵɵdefineInjectable, ɵɵdefineInjector, ɵɵdefineNgModule, ɵɵdefinePipe, ɵɵdirectiveInject, ɵɵdisableBindings, ɵɵelement, ɵɵelementContainer, ɵɵelementContainerEnd, ɵɵelementContainerStart, ɵɵelementEnd, ɵɵelementStart, ɵɵenableBindings, ɵɵgetCurrentView, ɵɵgetInheritedFactory, ɵɵhostProperty, ɵɵi18n, ɵɵi18nApply, ɵɵi18nAttributes, ɵɵi18nEnd, ɵɵi18nExp, ɵɵi18nPostprocess, ɵɵi18nStart, ɵɵinject, ɵɵinjectAttribute, ɵɵinvalidFactory, ɵɵinvalidFactoryDep, ɵɵlistener, ɵɵloadQuery, ɵɵnamespaceHTML, ɵɵnamespaceMathML, ɵɵnamespaceSVG, ɵɵnextContext, ɵɵngDeclareClassMetadata, ɵɵngDeclareComponent, ɵɵngDeclareDirective, ɵɵngDeclareFactory, ɵɵngDeclareInjectable, ɵɵngDeclareInjector, ɵɵngDeclareNgModule, ɵɵngDeclarePipe, ɵɵpipe, ɵɵpipeBind1, ɵɵpipeBind2, ɵɵpipeBind3, ɵɵpipeBind4, ɵɵpipeBindV, ɵɵprojection, ɵɵprojectionDef, ɵɵproperty, ɵɵpropertyInterpolate, ɵɵpropertyInterpolate1, ɵɵpropertyInterpolate2, ɵɵpropertyInterpolate3, ɵɵpropertyInterpolate4, ɵɵpropertyInterpolate5, ɵɵpropertyInterpolate6, ɵɵpropertyInterpolate7, ɵɵpropertyInterpolate8, ɵɵpropertyInterpolateV, ɵɵpureFunction0, ɵɵpureFunction1, ɵɵpureFunction2, ɵɵpureFunction3, ɵɵpureFunction4, ɵɵpureFunction5, ɵɵpureFunction6, ɵɵpureFunction7, ɵɵpureFunction8, ɵɵpureFunctionV, ɵɵqueryRefresh, ɵɵreference, registerNgModuleType as ɵɵregisterNgModuleType, ɵɵresetView, ɵɵresolveBody, ɵɵresolveDocument, ɵɵresolveWindow, ɵɵrestoreView, ɵɵsanitizeHtml, ɵɵsanitizeResourceUrl, ɵɵsanitizeScript, ɵɵsanitizeStyle, ɵɵsanitizeUrl, ɵɵsanitizeUrlOrResourceUrl, ɵɵsetComponentScope, ɵɵsetNgModuleScope, ɵɵstyleMap, ɵɵstyleMapInterpolate1, ɵɵstyleMapInterpolate2, ɵɵstyleMapInterpolate3, ɵɵstyleMapInterpolate4, ɵɵstyleMapInterpolate5, ɵɵstyleMapInterpolate6, ɵɵstyleMapInterpolate7, ɵɵstyleMapInterpolate8, ɵɵstyleMapInterpolateV, ɵɵstyleProp, ɵɵstylePropInterpolate1, ɵɵstylePropInterpolate2, ɵɵstylePropInterpolate3, ɵɵstylePropInterpolate4, ɵɵstylePropInterpolate5, ɵɵstylePropInterpolate6, ɵɵstylePropInterpolate7, ɵɵstylePropInterpolate8, ɵɵstylePropInterpolateV, ɵɵsyntheticHostListener, ɵɵsyntheticHostProperty, ɵɵtemplate, ɵɵtemplateRefExtractor, ɵɵtext, ɵɵtextInterpolate, ɵɵtextInterpolate1, ɵɵtextInterpolate2, ɵɵtextInterpolate3, ɵɵtextInterpolate4, ɵɵtextInterpolate5, ɵɵtextInterpolate6, ɵɵtextInterpolate7, ɵɵtextInterpolate8, ɵɵtextInterpolateV, ɵɵtrustConstantHtml, ɵɵtrustConstantResourceUrl, ɵɵvalidateIframeAttribute, ɵɵviewQuery };
+export { ANIMATION_MODULE_TYPE, APP_BOOTSTRAP_LISTENER, APP_ID, APP_INITIALIZER, ApplicationInitStatus, ApplicationModule, ApplicationRef, Attribute, COMPILER_OPTIONS, CSP_NONCE, CUSTOM_ELEMENTS_SCHEMA, ChangeDetectionStrategy, ChangeDetectorRef, Compiler, CompilerFactory, Component, ComponentFactory$1 as ComponentFactory, ComponentFactoryResolver$1 as ComponentFactoryResolver, ComponentRef$1 as ComponentRef, ContentChild, ContentChildren, DEFAULT_CURRENCY_CODE, DebugElement, DebugEventListener, DebugNode, DefaultIterableDiffer, DestroyRef, Directive, ENVIRONMENT_INITIALIZER, ElementRef, EmbeddedViewRef, EnvironmentInjector, ErrorHandler, EventEmitter, Host, HostBinding, HostListener, INJECTOR, Inject, InjectFlags, Injectable, InjectionToken, Injector, Input, IterableDiffers, KeyValueDiffers, LOCALE_ID, MissingTranslationStrategy, ModuleWithComponentFactories, NO_ERRORS_SCHEMA, NgModule, NgModuleFactory$1 as NgModuleFactory, NgModuleRef$1 as NgModuleRef, NgProbeToken, NgZone, Optional, Output, PACKAGE_ROOT_URL, PLATFORM_ID, PLATFORM_INITIALIZER, Pipe, PlatformRef, Query, QueryList, ReflectiveInjector, ReflectiveKey, Renderer2, RendererFactory2, RendererStyleFlags2, ResolvedReflectiveFactory, Sanitizer, SecurityContext, Self, SimpleChange, SkipSelf, TRANSLATIONS, TRANSLATIONS_FORMAT, TemplateRef, Testability, TestabilityRegistry, TransferState, Type, VERSION, Version, ViewChild, ViewChildren, ViewContainerRef, ViewEncapsulation$1 as ViewEncapsulation, ViewRef, asNativeElements, assertInInjectionContext, assertPlatform, computed, createComponent, createEnvironmentInjector, createNgModule, createNgModuleRef, createPlatform, createPlatformFactory, defineInjectable, destroyPlatform, effect, enableProdMode, forwardRef, getDebugNode, getModuleFactory, getNgModuleById, getPlatform, importProvidersFrom, inject, isDevMode, isSignal, isStandalone, makeEnvironmentProviders, makeStateKey, mergeApplicationConfig, platformCore, reflectComponentType, resolveForwardRef, runInInjectionContext, setTestabilityGetter, signal, untracked, ALLOW_MULTIPLE_PLATFORMS as ɵALLOW_MULTIPLE_PLATFORMS, ComponentFactory$1 as ɵComponentFactory, Console as ɵConsole, DEFAULT_LOCALE_ID as ɵDEFAULT_LOCALE_ID, INJECTOR_SCOPE as ɵINJECTOR_SCOPE, IS_HYDRATION_FEATURE_ENABLED as ɵIS_HYDRATION_FEATURE_ENABLED, InitialRenderPendingTasks as ɵInitialRenderPendingTasks, LContext as ɵLContext, LifecycleHooksFeature as ɵLifecycleHooksFeature, LocaleDataIndex as ɵLocaleDataIndex, NG_COMP_DEF as ɵNG_COMP_DEF, NG_DIR_DEF as ɵNG_DIR_DEF, NG_ELEMENT_ID as ɵNG_ELEMENT_ID, NG_INJ_DEF as ɵNG_INJ_DEF, NG_MOD_DEF as ɵNG_MOD_DEF, NG_PIPE_DEF as ɵNG_PIPE_DEF, NG_PROV_DEF as ɵNG_PROV_DEF, NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR as ɵNOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR, NO_CHANGE as ɵNO_CHANGE, NgModuleFactory as ɵNgModuleFactory, NoopNgZone as ɵNoopNgZone, ReflectionCapabilities as ɵReflectionCapabilities, ComponentFactory as ɵRender3ComponentFactory, ComponentRef as ɵRender3ComponentRef, NgModuleRef as ɵRender3NgModuleRef, RuntimeError as ɵRuntimeError, TESTABILITY as ɵTESTABILITY, TESTABILITY_GETTER as ɵTESTABILITY_GETTER, 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, coerceToBoolean as ɵcoerceToBoolean, 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, detectChanges as ɵdetectChanges, devModeEqual as ɵdevModeEqual, escapeTransferStateContent as ɵescapeTransferStateContent, findLocaleData as ɵfindLocaleData, flushModuleScopingQueueAsMuchAsPossible as ɵflushModuleScopingQueueAsMuchAsPossible, formatRuntimeError as ɵformatRuntimeError, getDebugNode as ɵgetDebugNode, getDirectives as ɵgetDirectives, getHostElement as ɵgetHostElement, getInjectableDef as ɵgetInjectableDef, getLContext as ɵgetLContext, getLocaleCurrencyCode as ɵgetLocaleCurrencyCode, getLocalePluralCase as ɵgetLocalePluralCase, getSanitizationBypassType as ɵgetSanitizationBypassType, ɵgetUnknownElementStrictMode, ɵgetUnknownPropertyStrictMode, _global as ɵglobal, injectChangeDetectorRef as ɵinjectChangeDetectorRef, internalCreateApplication as ɵinternalCreateApplication, isBoundToModule as ɵisBoundToModule, isEnvironmentProviders as ɵisEnvironmentProviders, isInjectable as ɵisInjectable, isNgModule as ɵisNgModule, isPromise as ɵisPromise, isSubscribable as ɵisSubscribable, makeDecorator as ɵmakeDecorator, noSideEffects as ɵnoSideEffects, patchComponentDefWithScope as ɵpatchComponentDefWithScope, provideHydrationSupport as ɵprovideHydrationSupport, provideNgZoneChangeDetection as ɵprovideNgZoneChangeDetection, publishDefaultGlobalUtils$1 as ɵpublishDefaultGlobalUtils, publishGlobalUtil as ɵpublishGlobalUtil, registerLocaleData as ɵregisterLocaleData, resetCompiledComponents as ɵresetCompiledComponents, resetJitOptions as ɵresetJitOptions, resolveComponentResources as ɵresolveComponentResources, setAllowDuplicateNgModuleIdsForTest as ɵsetAllowDuplicateNgModuleIdsForTest, setAlternateWeakRefImpl as ɵsetAlternateWeakRefImpl, setClassMetadata as ɵsetClassMetadata, setCurrentInjector as ɵsetCurrentInjector, setDocument as ɵsetDocument, setLocaleId as ɵsetLocaleId, ɵsetUnknownElementStrictMode, ɵsetUnknownPropertyStrictMode, store as ɵstore, stringify as ɵstringify, transitiveScopesFor as ɵtransitiveScopesFor, unescapeTransferStateContent as ɵunescapeTransferStateContent, unregisterAllLocaleData as ɵunregisterLocaleData, unwrapSafeValue as ɵunwrapSafeValue, ɵɵCopyDefinitionFeature, FactoryTarget as ɵɵFactoryTarget, ɵɵHostDirectivesFeature, ɵɵInheritDefinitionFeature, ɵɵ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, ɵɵcontentQuery, ɵɵdefineComponent, ɵɵdefineDirective, ɵɵdefineInjectable, ɵɵdefineInjector, ɵɵdefineNgModule, ɵɵdefinePipe, ɵɵdirectiveInject, ɵɵdisableBindings, ɵɵelement, ɵɵelementContainer, ɵɵelementContainerEnd, ɵɵelementContainerStart, ɵɵelementEnd, ɵɵelementStart, ɵɵenableBindings, ɵɵgetCurrentView, ɵɵgetInheritedFactory, ɵɵhostProperty, ɵɵi18n, ɵɵi18nApply, ɵɵi18nAttributes, ɵɵi18nEnd, ɵɵi18nExp, ɵɵi18nPostprocess, ɵɵi18nStart, ɵɵinject, ɵɵinjectAttribute, ɵɵinvalidFactory, ɵɵinvalidFactoryDep, ɵɵlistener, ɵɵloadQuery, ɵɵnamespaceHTML, ɵɵnamespaceMathML, ɵɵnamespaceSVG, ɵɵnextContext, ɵɵngDeclareClassMetadata, ɵɵngDeclareComponent, ɵɵngDeclareDirective, ɵɵngDeclareFactory, ɵɵngDeclareInjectable, ɵɵngDeclareInjector, ɵɵngDeclareNgModule, ɵɵngDeclarePipe, ɵɵpipe, ɵɵpipeBind1, ɵɵpipeBind2, ɵɵpipeBind3, ɵɵpipeBind4, ɵɵpipeBindV, ɵɵprojection, ɵɵprojectionDef, ɵɵproperty, ɵɵpropertyInterpolate, ɵɵpropertyInterpolate1, ɵɵpropertyInterpolate2, ɵɵpropertyInterpolate3, ɵɵpropertyInterpolate4, ɵɵpropertyInterpolate5, ɵɵpropertyInterpolate6, ɵɵpropertyInterpolate7, ɵɵpropertyInterpolate8, ɵɵpropertyInterpolateV, ɵɵpureFunction0, ɵɵpureFunction1, ɵɵpureFunction2, ɵɵpureFunction3, ɵɵpureFunction4, ɵɵpureFunction5, ɵɵpureFunction6, ɵɵpureFunction7, ɵɵpureFunction8, ɵɵpureFunctionV, ɵɵqueryRefresh, ɵɵreference, registerNgModuleType as ɵɵregisterNgModuleType, ɵɵresetView, ɵɵresolveBody, ɵɵresolveDocument, ɵɵresolveWindow, ɵɵrestoreView, ɵɵsanitizeHtml, ɵɵsanitizeResourceUrl, ɵɵsanitizeScript, ɵɵsanitizeStyle, ɵɵsanitizeUrl, ɵɵsanitizeUrlOrResourceUrl, ɵɵsetComponentScope, ɵɵsetNgModuleScope, ɵɵstyleMap, ɵɵstyleMapInterpolate1, ɵɵstyleMapInterpolate2, ɵɵstyleMapInterpolate3, ɵɵstyleMapInterpolate4, ɵɵstyleMapInterpolate5, ɵɵstyleMapInterpolate6, ɵɵstyleMapInterpolate7, ɵɵstyleMapInterpolate8, ɵɵstyleMapInterpolateV, ɵɵstyleProp, ɵɵstylePropInterpolate1, ɵɵstylePropInterpolate2, ɵɵstylePropInterpolate3, ɵɵstylePropInterpolate4, ɵɵstylePropInterpolate5, ɵɵstylePropInterpolate6, ɵɵstylePropInterpolate7, ɵɵstylePropInterpolate8, ɵɵstylePropInterpolateV, ɵɵsyntheticHostListener, ɵɵsyntheticHostProperty, ɵɵtemplate, ɵɵtemplateRefExtractor, ɵɵtext, ɵɵtextInterpolate, ɵɵtextInterpolate1, ɵɵtextInterpolate2, ɵɵtextInterpolate3, ɵɵtextInterpolate4, ɵɵtextInterpolate5, ɵɵtextInterpolate6, ɵɵtextInterpolate7, ɵɵtextInterpolate8, ɵɵtextInterpolateV, ɵɵtrustConstantHtml, ɵɵtrustConstantResourceUrl, ɵɵvalidateIframeAttribute, ɵɵviewQuery };
 //# sourceMappingURL=core.mjs.map