@angular/core 17.0.0-next.7 → 17.0.0-next.8

package/fesm2022/core.mjs

@@ -1,9 +1,10 @@
 /**
- * @license Angular v17.0.0-next.7
+ * @license Angular v17.0.0-next.8
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
 
+import { setActiveConsumer as setActiveConsumer$1, consumerDestroy as consumerDestroy$1, SIGNAL as SIGNAL$1, createComputed as createComputed$1, createSignal as createSignal$1, signalSetFn as signalSetFn$1, signalUpdateFn as signalUpdateFn$1, getActiveConsumer as getActiveConsumer$1, createWatch as createWatch$1, REACTIVE_NODE as REACTIVE_NODE$1, consumerBeforeComputation as consumerBeforeComputation$1, consumerAfterComputation as consumerAfterComputation$1, setThrowInvalidWriteToSignalError as setThrowInvalidWriteToSignalError$1 } from '@angular/core/primitives/signals';
 import { Subject, Subscription, Observable, merge as merge$1, BehaviorSubject, of } from 'rxjs';
 import { share, switchMap, distinctUntilChanged, first } from 'rxjs/operators';
 
@@ -65,6 +66,21 @@ function concatStringsWithSpace(before, after) {
         (after === null ? '' : after) :
         ((after == null || after === '') ? before : before + ' ' + after);
 }
+/**
+ * Ellipses the string in the middle when longer than the max length
+ *
+ * @param string
+ * @param maxLength of the output string
+ * @returns elispsed string with ... in the middle
+ */
+function truncateMiddle(str, maxLength = 100) {
+    if (!str || maxLength < 1 || str.length <= maxLength)
+        return str;
+    if (maxLength == 1)
+        return str.substring(0, 1) + '...';
+    const halfLimit = Math.round(maxLength / 2);
+    return str.substring(0, halfLimit) + '...' + str.substring(str.length - halfLimit);
+}
 
 const __forward_ref__ = getClosureSafeProperty({ __forward_ref__: getClosureSafeProperty });
 /**
@@ -193,6 +209,28 @@ function formatRuntimeError(code, message) {
     return errorMessage;
 }
 
+const NG_COMP_DEF = getClosureSafeProperty({ ɵcmp: getClosureSafeProperty });
+const NG_DIR_DEF = getClosureSafeProperty({ ɵdir: getClosureSafeProperty });
+const NG_PIPE_DEF = getClosureSafeProperty({ ɵpipe: getClosureSafeProperty });
+const NG_MOD_DEF = getClosureSafeProperty({ ɵmod: getClosureSafeProperty });
+const NG_FACTORY_DEF = getClosureSafeProperty({ ɵfac: getClosureSafeProperty });
+/**
+ * If a directive is diPublic, bloomAdd sets a property on the type with this constant as
+ * the key and the directive's unique ID as the value. This allows us to map directives to their
+ * bloom filter bit for DI.
+ */
+// TODO(misko): This is wrong. The NG_ELEMENT_ID should never be minified.
+const NG_ELEMENT_ID = getClosureSafeProperty({ __NG_ELEMENT_ID__: getClosureSafeProperty });
+/**
+ * The `NG_ENV_ID` field on a DI token indicates special processing in the `EnvironmentInjector`:
+ * getting such tokens from the `EnvironmentInjector` will bypass the standard DI resolution
+ * strategy and instead will return implementation produced by the `NG_ENV_ID` factory function.
+ *
+ * This particular retrieval of DI tokens is mostly done to eliminate circular dependencies and
+ * improve tree-shaking.
+ */
+const NG_ENV_ID = getClosureSafeProperty({ __NG_ENV_ID__: getClosureSafeProperty });
+
 /**
  * Used for stringify render output in Ivy.
  * Important! This function is very performance-sensitive and we should
@@ -210,6 +248,7 @@ function renderStringify(value) {
 }
 /**
  * Used to stringify a value so that it can be displayed in an error message.
+ *
  * Important! This function contains a megamorphic read and should only be
  * used for error messages.
  */
@@ -221,6 +260,31 @@ function stringifyForError(value) {
     }
     return renderStringify(value);
 }
+/**
+ * Used to stringify a `Type` and including the file path and line number in which it is defined, if
+ * possible, for better debugging experience.
+ *
+ * Important! This function contains a megamorphic read and should only be used for error messages.
+ */
+function debugStringifyTypeForError(type) {
+    // TODO(pmvald): Do some refactoring so that we can use getComponentDef here without creating
+    // circular deps.
+    let componentDef = type[NG_COMP_DEF] || null;
+    if (componentDef !== null && componentDef.debugInfo) {
+        return stringifyTypeFromDebugInfo(componentDef.debugInfo);
+    }
+    return stringifyForError(type);
+}
+// TODO(pmvald): Do some refactoring so that we can use the type ClassDebugInfo for the param
+// debugInfo here without creating circular deps.
+function stringifyTypeFromDebugInfo(debugInfo) {
+    if (!debugInfo.filePath || !debugInfo.lineNumber) {
+        return debugInfo.className;
+    }
+    else {
+        return `${debugInfo.className} (at ${debugInfo.filePath}:${debugInfo.lineNumber})`;
+    }
+}
 
 /** Called when directives inject each other (creating a circular dependency) */
 function throwCyclicDependencyError(token, path) {
@@ -1027,28 +1091,6 @@ if ((typeof ngDevMode === 'undefined' || ngDevMode) && initNgDevMode()) {
     Object.freeze(EMPTY_ARRAY);
 }
 
-const NG_COMP_DEF = getClosureSafeProperty({ ɵcmp: getClosureSafeProperty });
-const NG_DIR_DEF = getClosureSafeProperty({ ɵdir: getClosureSafeProperty });
-const NG_PIPE_DEF = getClosureSafeProperty({ ɵpipe: getClosureSafeProperty });
-const NG_MOD_DEF = getClosureSafeProperty({ ɵmod: getClosureSafeProperty });
-const NG_FACTORY_DEF = getClosureSafeProperty({ ɵfac: getClosureSafeProperty });
-/**
- * If a directive is diPublic, bloomAdd sets a property on the type with this constant as
- * the key and the directive's unique ID as the value. This allows us to map directives to their
- * bloom filter bit for DI.
- */
-// TODO(misko): This is wrong. The NG_ELEMENT_ID should never be minified.
-const NG_ELEMENT_ID = getClosureSafeProperty({ __NG_ELEMENT_ID__: getClosureSafeProperty });
-/**
- * The `NG_ENV_ID` field on a DI token indicates special processing in the `EnvironmentInjector`:
- * getting such tokens from the `EnvironmentInjector` will bypass the standard DI resolution
- * strategy and instead will return implementation produced by the `NG_ENV_ID` factory function.
- *
- * This particular retrieval of DI tokens is mostly done to eliminate circular dependencies and
- * improve tree-shaking.
- */
-const NG_ENV_ID = getClosureSafeProperty({ __NG_ENV_ID__: getClosureSafeProperty });
-
 /**
  * Returns an index of `classToSearch` in `className` taking token boundaries into account.
  *
@@ -1951,6 +1993,7 @@ function getNgDirectiveDef(directiveDefinition) {
         hostDirectives: null,
         inputs: invertObject(directiveDefinition.inputs, declaredInputs),
         outputs: invertObject(directiveDefinition.outputs),
+        debugInfo: null,
     };
 }
 function initFeatures(definition) {
@@ -2032,10 +2075,12 @@ function getComponentId(componentDef) {
 const HOST = 0;
 const TVIEW = 1;
 const FLAGS = 2;
+// Shared with LContainer
 const PARENT = 3;
 const NEXT = 4;
-const DESCENDANT_VIEWS_TO_REFRESH = 5;
-const T_HOST = 6;
+const T_HOST = 5;
+// End shared with LContainer
+const HYDRATION = 6;
 const CLEANUP = 7;
 const CONTEXT = 8;
 const INJECTOR$1 = 9;
@@ -2052,7 +2097,6 @@ const QUERIES = 18;
 const ID = 19;
 const EMBEDDED_VIEW_INJECTOR = 20;
 const ON_DESTROY_HOOKS = 21;
-const HYDRATION = 22;
 const REACTIVE_TEMPLATE_CONSUMER = 23;
 const REACTIVE_HOST_BINDING_CONSUMER = 24;
 /**
@@ -2087,10 +2131,11 @@ const TYPE = 1;
  * that the `MOVED_VIEWS` are transplanted and on-push.
  */
 const HAS_TRANSPLANTED_VIEWS = 2;
-// PARENT, NEXT, DESCENDANT_VIEWS_TO_REFRESH are indices 3, 4, and 5
+// PARENT and NEXT are indices 3 and 4
 // As we already have these constants in LView, we don't need to re-create them.
-// T_HOST is index 6
+// T_HOST is index 5
 // We already have this constants in LView, we don't need to re-create it.
+const HAS_CHILD_VIEWS_TO_REFRESH = 6;
 const NATIVE = 7;
 const VIEW_REFS = 8;
 const MOVED_VIEWS = 9;
@@ -2235,6 +2280,20 @@ function assertProjectionSlots(lView, errMessage) {
 function assertParentView(lView, errMessage) {
     assertDefined(lView, errMessage || 'Component views should always have a parent view (component\'s host view)');
 }
+function assertNoDuplicateDirectives(directives) {
+    // The array needs at least two elements in order to have duplicates.
+    if (directives.length < 2) {
+        return;
+    }
+    const seenDirectives = new Set();
+    for (const current of directives) {
+        if (seenDirectives.has(current)) {
+            throw new RuntimeError(309 /* RuntimeErrorCode.DUPLICATE_DIRECTITVE */, `Directive ${current.type.name} matches multiple times on the same element. ` +
+                `Directives can only match an element once.`);
+        }
+        seenDirectives.add(current);
+    }
+}
 /**
  * This is a basic sanity check that the `injectorIndex` seems to point to what looks like a
  * NodeInjector data structure.
@@ -2265,906 +2324,345 @@ function getFactoryDef(type, throwNotFound) {
 }
 
 /**
- * Symbol used to tell `Signal`s apart from other functions.
+ * Represents a basic change from a previous to a new value for a single
+ * property on a directive instance. Passed as a value in a
+ * {@link SimpleChanges} object to the `ngOnChanges` hook.
  *
- * This can be used to auto-unwrap signals in various cases, or to auto-wrap non-signal values.
+ * @see {@link OnChanges}
+ *
+ * @publicApi
  */
-const SIGNAL = /* @__PURE__ */ Symbol('SIGNAL');
+class SimpleChange {
+    constructor(previousValue, currentValue, firstChange) {
+        this.previousValue = previousValue;
+        this.currentValue = currentValue;
+        this.firstChange = firstChange;
+    }
+    /**
+     * Check whether the new value is the first value assigned.
+     */
+    isFirstChange() {
+        return this.firstChange;
+    }
+}
+
 /**
- * Checks if the given `value` is a reactive `Signal`.
+ * The NgOnChangesFeature decorates a component with support for the ngOnChanges
+ * lifecycle hook, so it should be included in any component that implements
+ * that hook.
  *
- * @developerPreview
+ * If the component or directive uses inheritance, the NgOnChangesFeature MUST
+ * be included as a feature AFTER {@link InheritDefinitionFeature}, otherwise
+ * inherited properties will not be propagated to the ngOnChanges lifecycle
+ * hook.
+ *
+ * Example usage:
+ *
+ * ```
+ * static ɵcmp = defineComponent({
+ *   ...
+ *   inputs: {name: 'publicName'},
+ *   features: [NgOnChangesFeature]
+ * });
+ * ```
+ *
+ * @codeGenApi
  */
-function isSignal(value) {
-    return typeof value === 'function' && value[SIGNAL] !== undefined;
+function ɵɵNgOnChangesFeature() {
+    return NgOnChangesFeatureImpl;
+}
+function NgOnChangesFeatureImpl(definition) {
+    if (definition.type.prototype.ngOnChanges) {
+        definition.setInput = ngOnChangesSetInput;
+    }
+    return rememberChangeHistoryAndInvokeOnChangesHook;
 }
+// This option ensures that the ngOnChanges lifecycle hook will be inherited
+// from superclasses (in InheritDefinitionFeature).
+/** @nocollapse */
+// tslint:disable-next-line:no-toplevel-property-access
+ɵɵNgOnChangesFeature.ngInherit = true;
 /**
- * The default equality function used for `signal` and `computed`, which treats objects and arrays
- * as never equal, and all other primitive values using identity semantics.
+ * This is a synthetic lifecycle hook which gets inserted into `TView.preOrderHooks` to simulate
+ * `ngOnChanges`.
  *
- * This allows signals to hold non-primitive values (arrays, objects, other collections) and still
- * propagate change notification upon explicit mutation without identity change.
+ * The hook reads the `NgSimpleChangesStore` data from the component instance and if changes are
+ * found it invokes `ngOnChanges` on the component instance.
  *
- * @developerPreview
+ * @param this Component instance. Because this function gets inserted into `TView.preOrderHooks`,
+ *     it is guaranteed to be called with component instance.
  */
-function defaultEquals(a, b) {
-    // `Object.is` compares two values using identity semantics which is desired behavior for
-    // primitive values. If `Object.is` determines two values to be equal we need to make sure that
-    // those don't represent objects (we want to make sure that 2 objects are always considered
-    // "unequal"). The null check is needed for the special case of JavaScript reporting null values
-    // as objects (`typeof null === 'object'`).
-    return (a === null || typeof a !== 'object') && Object.is(a, b);
+function rememberChangeHistoryAndInvokeOnChangesHook() {
+    const simpleChangesStore = getSimpleChangesStore(this);
+    const current = simpleChangesStore?.current;
+    if (current) {
+        const previous = simpleChangesStore.previous;
+        if (previous === EMPTY_OBJ) {
+            simpleChangesStore.previous = current;
+        }
+        else {
+            // New changes are copied to the previous store, so that we don't lose history for inputs
+            // which were not changed this time
+            for (let key in current) {
+                previous[key] = current[key];
+            }
+        }
+        simpleChangesStore.current = null;
+        this.ngOnChanges(current);
+    }
+}
+function ngOnChangesSetInput(instance, value, publicName, privateName) {
+    const declaredName = this.declaredInputs[publicName];
+    ngDevMode && assertString(declaredName, 'Name of input in ngOnChanges has to be a string');
+    const simpleChangesStore = getSimpleChangesStore(instance) ||
+        setSimpleChangesStore(instance, { previous: EMPTY_OBJ, current: null });
+    const current = simpleChangesStore.current || (simpleChangesStore.current = {});
+    const previous = simpleChangesStore.previous;
+    const previousChange = previous[declaredName];
+    current[declaredName] = new SimpleChange(previousChange && previousChange.currentValue, value, previous === EMPTY_OBJ);
+    instance[privateName] = value;
+}
+const SIMPLE_CHANGES_STORE = '__ngSimpleChanges__';
+function getSimpleChangesStore(instance) {
+    return instance[SIMPLE_CHANGES_STORE] || null;
+}
+function setSimpleChangesStore(instance, store) {
+    return instance[SIMPLE_CHANGES_STORE] = store;
 }
 
-// Required as the signals library is in a separate package, so we need to explicitly ensure the
+let profilerCallback = null;
 /**
- * The currently active consumer `ReactiveNode`, if running code in a reactive context.
+ * Sets the callback function which will be invoked before and after performing certain actions at
+ * runtime (for example, before and after running change detection).
  *
- * Change this via `setActiveConsumer`.
+ * Warning: this function is *INTERNAL* and should not be relied upon in application's code.
+ * The contract of the function might be changed in any release and/or the function can be removed
+ * completely.
+ *
+ * @param profiler function provided by the caller or null value to disable profiling.
  */
-let activeConsumer = null;
-let inNotificationPhase = false;
-function setActiveConsumer(consumer) {
-    const prev = activeConsumer;
-    activeConsumer = consumer;
-    return prev;
-}
-function isInNotificationPhase() {
-    return inNotificationPhase;
-}
-const REACTIVE_NODE = {
-    version: 0,
-    dirty: false,
-    producerNode: undefined,
-    producerLastReadVersion: undefined,
-    producerIndexOfThis: undefined,
-    nextProducerIndex: 0,
-    liveConsumerNode: undefined,
-    liveConsumerIndexOfThis: undefined,
-    consumerAllowSignalWrites: false,
-    consumerIsAlwaysLive: false,
-    producerMustRecompute: () => false,
-    producerRecomputeValue: () => { },
-    consumerMarkedDirty: () => { },
+const setProfiler = (profiler) => {
+    profilerCallback = profiler;
 };
 /**
- * Called by implementations when a producer's signal is read.
+ * Profiler function which wraps user code executed by the runtime.
+ *
+ * @param event ProfilerEvent corresponding to the execution context
+ * @param instance component instance
+ * @param hookOrListener lifecycle hook function or output listener. The value depends on the
+ *  execution context
+ * @returns
  */
-function producerAccessed(node) {
-    if (inNotificationPhase) {
-        throw new Error(typeof ngDevMode !== 'undefined' && ngDevMode ?
-            `Assertion error: signal read during notification phase` :
-            '');
-    }
-    if (activeConsumer === null) {
-        // Accessed outside of a reactive context, so nothing to record.
-        return;
-    }
-    // This producer is the `idx`th dependency of `activeConsumer`.
-    const idx = activeConsumer.nextProducerIndex++;
-    assertConsumerNode(activeConsumer);
-    if (idx < activeConsumer.producerNode.length && activeConsumer.producerNode[idx] !== node) {
-        // There's been a change in producers since the last execution of `activeConsumer`.
-        // `activeConsumer.producerNode[idx]` holds a stale dependency which will be be removed and
-        // replaced with `this`.
-        //
-        // If `activeConsumer` isn't live, then this is a no-op, since we can replace the producer in
-        // `activeConsumer.producerNode` directly. However, if `activeConsumer` is live, then we need
-        // to remove it from the stale producer's `liveConsumer`s.
-        if (consumerIsLive(activeConsumer)) {
-            const staleProducer = activeConsumer.producerNode[idx];
-            producerRemoveLiveConsumerAtIndex(staleProducer, activeConsumer.producerIndexOfThis[idx]);
-            // At this point, the only record of `staleProducer` is the reference at
-            // `activeConsumer.producerNode[idx]` which will be overwritten below.
-        }
-    }
-    if (activeConsumer.producerNode[idx] !== node) {
-        // We're a new dependency of the consumer (at `idx`).
-        activeConsumer.producerNode[idx] = node;
-        // If the active consumer is live, then add it as a live consumer. If not, then use 0 as a
-        // placeholder value.
-        activeConsumer.producerIndexOfThis[idx] =
-            consumerIsLive(activeConsumer) ? producerAddLiveConsumer(node, activeConsumer, idx) : 0;
+const profiler = function (event, instance, hookOrListener) {
+    if (profilerCallback != null /* both `null` and `undefined` */) {
+        profilerCallback(event, instance, hookOrListener);
     }
-    activeConsumer.producerLastReadVersion[idx] = node.version;
-}
+};
+
+const SVG_NAMESPACE = 'svg';
+const MATH_ML_NAMESPACE = 'math';
+
 /**
- * Ensure this producer's `version` is up-to-date.
+ * For efficiency reasons we often put several different data types (`RNode`, `LView`, `LContainer`)
+ * in same location in `LView`. This is because we don't want to pre-allocate space for it
+ * because the storage is sparse. This file contains utilities for dealing with such data types.
+ *
+ * How do we know what is stored at a given location in `LView`.
+ * - `Array.isArray(value) === false` => `RNode` (The normal storage value)
+ * - `Array.isArray(value) === true` => then the `value[0]` represents the wrapped value.
+ *   - `typeof value[TYPE] === 'object'` => `LView`
+ *      - This happens when we have a component at a given location
+ *   - `typeof value[TYPE] === true` => `LContainer`
+ *      - This happens when we have `LContainer` binding at a given location.
+ *
+ *
+ * NOTE: it is assumed that `Array.isArray` and `typeof` operations are very efficient.
  */
-function producerUpdateValueVersion(node) {
-    if (consumerIsLive(node) && !node.dirty) {
-        // A live consumer will be marked dirty by producers, so a clean state means that its version
-        // is guaranteed to be up-to-date.
-        return;
-    }
-    if (!node.producerMustRecompute(node) && !consumerPollProducersForChange(node)) {
-        // None of our producers report a change since the last time they were read, so no
-        // recomputation of our value is necessary, and we can consider ourselves clean.
-        node.dirty = false;
-        return;
+/**
+ * Returns `RNode`.
+ * @param value wrapped value of `RNode`, `LView`, `LContainer`
+ */
+function unwrapRNode(value) {
+    while (Array.isArray(value)) {
+        value = value[HOST];
     }
-    node.producerRecomputeValue(node);
-    // After recomputing the value, we're no longer dirty.
-    node.dirty = false;
+    return value;
 }
 /**
- * Propagate a dirty notification to live consumers of this producer.
+ * Returns `LView` or `null` if not found.
+ * @param value wrapped value of `RNode`, `LView`, `LContainer`
  */
-function producerNotifyConsumers(node) {
-    if (node.liveConsumerNode === undefined) {
-        return;
-    }
-    // Prevent signal reads when we're updating the graph
-    const prev = inNotificationPhase;
-    inNotificationPhase = true;
-    try {
-        for (const consumer of node.liveConsumerNode) {
-            if (!consumer.dirty) {
-                consumerMarkDirty(consumer);
-            }
-        }
-    }
-    finally {
-        inNotificationPhase = prev;
+function unwrapLView(value) {
+    while (Array.isArray(value)) {
+        // This check is same as `isLView()` but we don't call at as we don't want to call
+        // `Array.isArray()` twice and give JITer more work for inlining.
+        if (typeof value[TYPE] === 'object')
+            return value;
+        value = value[HOST];
     }
+    return null;
 }
 /**
- * Whether this `ReactiveNode` in its producer capacity is currently allowed to initiate updates,
- * based on the current consumer context.
+ * Retrieves an element value from the provided `viewData`, by unwrapping
+ * from any containers, component views, or style contexts.
  */
-function producerUpdatesAllowed() {
-    return activeConsumer?.consumerAllowSignalWrites !== false;
+function getNativeByIndex(index, lView) {
+    ngDevMode && assertIndexInRange(lView, index);
+    ngDevMode && assertGreaterThanOrEqual(index, HEADER_OFFSET, 'Expected to be past HEADER_OFFSET');
+    return unwrapRNode(lView[index]);
 }
-function consumerMarkDirty(node) {
-    node.dirty = true;
-    producerNotifyConsumers(node);
-    node.consumerMarkedDirty?.(node);
+/**
+ * Retrieve an `RNode` for a given `TNode` and `LView`.
+ *
+ * This function guarantees in dev mode to retrieve a non-null `RNode`.
+ *
+ * @param tNode
+ * @param lView
+ */
+function getNativeByTNode(tNode, lView) {
+    ngDevMode && assertTNodeForLView(tNode, lView);
+    ngDevMode && assertIndexInRange(lView, tNode.index);
+    const node = unwrapRNode(lView[tNode.index]);
+    return node;
 }
 /**
- * Prepare this consumer to run a computation in its reactive context.
+ * Retrieve an `RNode` or `null` for a given `TNode` and `LView`.
  *
- * Must be called by subclasses which represent reactive computations, before those computations
- * begin.
+ * Some `TNode`s don't have associated `RNode`s. For example `Projection`
+ *
+ * @param tNode
+ * @param lView
  */
-function consumerBeforeComputation(node) {
-    node && (node.nextProducerIndex = 0);
-    return setActiveConsumer(node);
+function getNativeByTNodeOrNull(tNode, lView) {
+    const index = tNode === null ? -1 : tNode.index;
+    if (index !== -1) {
+        ngDevMode && assertTNodeForLView(tNode, lView);
+        const node = unwrapRNode(lView[index]);
+        return node;
+    }
+    return null;
+}
+// fixme(misko): The return Type should be `TNode|null`
+function getTNode(tView, index) {
+    ngDevMode && assertGreaterThan(index, -1, 'wrong index for TNode');
+    ngDevMode && assertLessThan(index, tView.data.length, 'wrong index for TNode');
+    const tNode = tView.data[index];
+    ngDevMode && tNode !== null && assertTNode(tNode);
+    return tNode;
+}
+/** Retrieves a value from any `LView` or `TData`. */
+function load(view, index) {
+    ngDevMode && assertIndexInRange(view, index);
+    return view[index];
+}
+function getComponentLViewByIndex(nodeIndex, hostView) {
+    // Could be an LView or an LContainer. If LContainer, unwrap to find LView.
+    ngDevMode && assertIndexInRange(hostView, nodeIndex);
+    const slotValue = hostView[nodeIndex];
+    const lView = isLView(slotValue) ? slotValue : slotValue[HOST];
+    return lView;
+}
+/** Checks whether a given view is in creation mode */
+function isCreationMode(view) {
+    return (view[FLAGS] & 4 /* LViewFlags.CreationMode */) === 4 /* LViewFlags.CreationMode */;
 }
 /**
- * Finalize this consumer's state after a reactive computation has run.
+ * Returns a boolean for whether the view is attached to the change detection tree.
  *
- * Must be called by subclasses which represent reactive computations, after those computations
- * have finished.
+ * Note: This determines whether a view should be checked, not whether it's inserted
+ * into a container. For that, you'll want `viewAttachedToContainer` below.
  */
-function consumerAfterComputation(node, prevConsumer) {
-    setActiveConsumer(prevConsumer);
-    if (!node || node.producerNode === undefined || node.producerIndexOfThis === undefined ||
-        node.producerLastReadVersion === undefined) {
+function viewAttachedToChangeDetector(view) {
+    return (view[FLAGS] & 128 /* LViewFlags.Attached */) === 128 /* LViewFlags.Attached */;
+}
+/** Returns a boolean for whether the view is attached to a container. */
+function viewAttachedToContainer(view) {
+    return isLContainer(view[PARENT]);
+}
+function getConstant(consts, index) {
+    if (index === null || index === undefined)
+        return null;
+    ngDevMode && assertIndexInRange(consts, index);
+    return consts[index];
+}
+/**
+ * Resets the pre-order hook flags of the view.
+ * @param lView the LView on which the flags are reset
+ */
+function resetPreOrderHookFlags(lView) {
+    lView[PREORDER_HOOK_FLAGS] = 0;
+}
+/**
+ * Adds the `RefreshView` flag from the lView and updates HAS_CHILD_VIEWS_TO_REFRESH flag of
+ * parents.
+ */
+function markViewForRefresh(lView) {
+    if (lView[FLAGS] & 1024 /* LViewFlags.RefreshView */) {
         return;
     }
-    if (consumerIsLive(node)) {
-        // For live consumers, we need to remove the producer -> consumer edge for any stale producers
-        // which weren't dependencies after the recomputation.
-        for (let i = node.nextProducerIndex; i < node.producerNode.length; i++) {
-            producerRemoveLiveConsumerAtIndex(node.producerNode[i], node.producerIndexOfThis[i]);
-        }
-    }
-    // Truncate the producer tracking arrays.
-    // Perf note: this is essentially truncating the length to `node.nextProducerIndex`, but
-    // benchmarking has shown that individual pop operations are faster.
-    while (node.producerNode.length > node.nextProducerIndex) {
-        node.producerNode.pop();
-        node.producerLastReadVersion.pop();
-        node.producerIndexOfThis.pop();
+    lView[FLAGS] |= 1024 /* LViewFlags.RefreshView */;
+    if (viewAttachedToChangeDetector(lView)) {
+        markAncestorsForTraversal(lView);
     }
 }
 /**
- * Determine whether this consumer has any dependencies which have changed since the last time
- * they were read.
+ * Walks up the LView hierarchy.
+ * @param nestingLevel Number of times to walk up in hierarchy.
+ * @param currentView View from which to start the lookup.
  */
-function consumerPollProducersForChange(node) {
-    assertConsumerNode(node);
-    // Poll producers for change.
-    for (let i = 0; i < node.producerNode.length; i++) {
-        const producer = node.producerNode[i];
-        const seenVersion = node.producerLastReadVersion[i];
-        // First check the versions. A mismatch means that the producer's value is known to have
-        // changed since the last time we read it.
-        if (seenVersion !== producer.version) {
-            return true;
-        }
-        // The producer's version is the same as the last time we read it, but it might itself be
-        // stale. Force the producer to recompute its version (calculating a new value if necessary).
-        producerUpdateValueVersion(producer);
-        // Now when we do this check, `producer.version` is guaranteed to be up to date, so if the
-        // versions still match then it has not changed since the last time we read it.
-        if (seenVersion !== producer.version) {
-            return true;
-        }
+function walkUpViews(nestingLevel, currentView) {
+    while (nestingLevel > 0) {
+        ngDevMode &&
+            assertDefined(currentView[DECLARATION_VIEW], 'Declaration view should be defined if nesting level is greater than 0.');
+        currentView = currentView[DECLARATION_VIEW];
+        nestingLevel--;
     }
-    return false;
+    return currentView;
 }
 /**
- * Disconnect this consumer from the graph.
+ * Updates the `DESCENDANT_VIEWS_TO_REFRESH` counter on the parents of the `LView` as well as the
+ * parents above that whose
+ *  1. counter goes from 0 to 1, indicating that there is a new child that has a view to refresh
+ *  or
+ *  2. counter goes from 1 to 0, indicating there are no more descendant views to refresh
+ * When attaching/re-attaching an `LView` to the change detection tree, we need to ensure that the
+ * views above it are traversed during change detection if this one is marked for refresh or has
+ * some child or descendant that needs to be refreshed.
  */
-function consumerDestroy(node) {
-    assertConsumerNode(node);
-    if (consumerIsLive(node)) {
-        // Drop all connections from the graph to this node.
-        for (let i = 0; i < node.producerNode.length; i++) {
-            producerRemoveLiveConsumerAtIndex(node.producerNode[i], node.producerIndexOfThis[i]);
-        }
-    }
-    // Truncate all the arrays to drop all connection from this node to the graph.
-    node.producerNode.length = node.producerLastReadVersion.length = node.producerIndexOfThis.length =
-        0;
-    if (node.liveConsumerNode) {
-        node.liveConsumerNode.length = node.liveConsumerIndexOfThis.length = 0;
+function updateAncestorTraversalFlagsOnAttach(lView) {
+    if (lView[FLAGS] & (1024 /* LViewFlags.RefreshView */ | 8192 /* LViewFlags.HasChildViewsToRefresh */)) {
+        markAncestorsForTraversal(lView);
     }
 }
 /**
- * Add `consumer` as a live consumer of this node.
+ * Ensures views above the given `lView` are traversed during change detection even when they are
+ * not dirty.
  *
- * Note that this operation is potentially transitive. If this node becomes live, then it becomes
- * a live consumer of all of its current producers.
+ * This is done by setting the `HAS_CHILD_VIEWS_TO_REFRESH` flag up to the root, stopping when the
+ * flag is already `true` or the `lView` is detached.
  */
-function producerAddLiveConsumer(node, consumer, indexOfThis) {
-    assertProducerNode(node);
-    assertConsumerNode(node);
-    if (node.liveConsumerNode.length === 0) {
-        // When going from 0 to 1 live consumers, we become a live consumer to our producers.
-        for (let i = 0; i < node.producerNode.length; i++) {
-            node.producerIndexOfThis[i] = producerAddLiveConsumer(node.producerNode[i], node, i);
+function markAncestorsForTraversal(lView) {
+    let parent = lView[PARENT];
+    if (parent === null) {
+        return;
+    }
+    while (parent !== null) {
+        // We stop adding markers to the ancestors once we reach one that already has the marker. This
+        // is to avoid needlessly traversing all the way to the root when the marker already exists.
+        if ((isLContainer(parent) && parent[HAS_CHILD_VIEWS_TO_REFRESH] ||
+            (isLView(parent) && parent[FLAGS] & 8192 /* LViewFlags.HasChildViewsToRefresh */))) {
+            break;
+        }
+        if (isLContainer(parent)) {
+            parent[HAS_CHILD_VIEWS_TO_REFRESH] = true;
         }
-    }
-    node.liveConsumerIndexOfThis.push(indexOfThis);
-    return node.liveConsumerNode.push(consumer) - 1;
-}
-/**
- * Remove the live consumer at `idx`.
- */
-function producerRemoveLiveConsumerAtIndex(node, idx) {
-    assertProducerNode(node);
-    assertConsumerNode(node);
-    if (typeof ngDevMode !== 'undefined' && ngDevMode && idx >= node.liveConsumerNode.length) {
-        throw new Error(`Assertion error: active consumer index ${idx} is out of bounds of ${node.liveConsumerNode.length} consumers)`);
-    }
-    if (node.liveConsumerNode.length === 1) {
-        // When removing the last live consumer, we will no longer be live. We need to remove
-        // ourselves from our producers' tracking (which may cause consumer-producers to lose
-        // liveness as well).
-        for (let i = 0; i < node.producerNode.length; i++) {
-            producerRemoveLiveConsumerAtIndex(node.producerNode[i], node.producerIndexOfThis[i]);
-        }
-    }
-    // Move the last value of `liveConsumers` into `idx`. Note that if there's only a single
-    // live consumer, this is a no-op.
-    const lastIdx = node.liveConsumerNode.length - 1;
-    node.liveConsumerNode[idx] = node.liveConsumerNode[lastIdx];
-    node.liveConsumerIndexOfThis[idx] = node.liveConsumerIndexOfThis[lastIdx];
-    // Truncate the array.
-    node.liveConsumerNode.length--;
-    node.liveConsumerIndexOfThis.length--;
-    // If the index is still valid, then we need to fix the index pointer from the producer to this
-    // consumer, and update it from `lastIdx` to `idx` (accounting for the move above).
-    if (idx < node.liveConsumerNode.length) {
-        const idxProducer = node.liveConsumerIndexOfThis[idx];
-        const consumer = node.liveConsumerNode[idx];
-        assertConsumerNode(consumer);
-        consumer.producerIndexOfThis[idxProducer] = idx;
-    }
-}
-function consumerIsLive(node) {
-    return node.consumerIsAlwaysLive || (node?.liveConsumerNode?.length ?? 0) > 0;
-}
-function assertConsumerNode(node) {
-    node.producerNode ??= [];
-    node.producerIndexOfThis ??= [];
-    node.producerLastReadVersion ??= [];
-}
-function assertProducerNode(node) {
-    node.liveConsumerNode ??= [];
-    node.liveConsumerIndexOfThis ??= [];
-}
-
-/**
- * Create a computed `Signal` which derives a reactive value from an expression.
- *
- * @developerPreview
- */
-function computed(computation, options) {
-    const node = Object.create(COMPUTED_NODE);
-    node.computation = computation;
-    options?.equal && (node.equal = options.equal);
-    const computed = () => {
-        // Check if the value needs updating before returning it.
-        producerUpdateValueVersion(node);
-        // Record that someone looked at this signal.
-        producerAccessed(node);
-        if (node.value === ERRORED) {
-            throw node.error;
-        }
-        return node.value;
-    };
-    computed[SIGNAL] = node;
-    return computed;
-}
-/**
- * A dedicated symbol used before a computed value has been calculated for the first time.
- * Explicitly typed as `any` so we can use it as signal's value.
- */
-const UNSET = /* @__PURE__ */ Symbol('UNSET');
-/**
- * A dedicated symbol used in place of a computed signal value to indicate that a given computation
- * is in progress. Used to detect cycles in computation chains.
- * Explicitly typed as `any` so we can use it as signal's value.
- */
-const COMPUTING = /* @__PURE__ */ Symbol('COMPUTING');
-/**
- * A dedicated symbol used in place of a computed signal value to indicate that a given computation
- * failed. The thrown error is cached until the computation gets dirty again.
- * Explicitly typed as `any` so we can use it as signal's value.
- */
-const ERRORED = /* @__PURE__ */ Symbol('ERRORED');
-// Note: Using an IIFE here to ensure that the spread assignment is not considered
-// a side-effect, ending up preserving `COMPUTED_NODE` and `REACTIVE_NODE`.
-// TODO: remove when https://github.com/evanw/esbuild/issues/3392 is resolved.
-const COMPUTED_NODE = /* @__PURE__ */ (() => {
-    return {
-        ...REACTIVE_NODE,
-        value: UNSET,
-        dirty: true,
-        error: null,
-        equal: defaultEquals,
-        producerMustRecompute(node) {
-            // Force a recomputation if there's no current value, or if the current value is in the
-            // process of being calculated (which should throw an error).
-            return node.value === UNSET || node.value === COMPUTING;
-        },
-        producerRecomputeValue(node) {
-            if (node.value === COMPUTING) {
-                // Our computation somehow led to a cyclic read of itself.
-                throw new Error('Detected cycle in computations.');
-            }
-            const oldValue = node.value;
-            node.value = COMPUTING;
-            const prevConsumer = consumerBeforeComputation(node);
-            let newValue;
-            try {
-                newValue = node.computation();
-            }
-            catch (err) {
-                newValue = ERRORED;
-                node.error = err;
-            }
-            finally {
-                consumerAfterComputation(node, prevConsumer);
-            }
-            if (oldValue !== UNSET && oldValue !== ERRORED && newValue !== ERRORED &&
-                node.equal(oldValue, newValue)) {
-                // No change to `valueVersion` - old and new values are
-                // semantically equivalent.
-                node.value = oldValue;
-                return;
-            }
-            node.value = newValue;
-            node.version++;
-        },
-    };
-})();
-
-function defaultThrowError() {
-    throw new Error();
-}
-let throwInvalidWriteToSignalErrorFn = defaultThrowError;
-function throwInvalidWriteToSignalError() {
-    throwInvalidWriteToSignalErrorFn();
-}
-function setThrowInvalidWriteToSignalError(fn) {
-    throwInvalidWriteToSignalErrorFn = fn;
-}
-
-/**
- * If set, called after `WritableSignal`s are updated.
- *
- * This hook can be used to achieve various effects, such as running effects synchronously as part
- * of setting a signal.
- */
-let postSignalSetFn = null;
-/**
- * Create a `Signal` that can be set or updated directly.
- *
- * @developerPreview
- */
-function signal(initialValue, options) {
-    const node = Object.create(SIGNAL_NODE);
-    node.value = initialValue;
-    options?.equal && (node.equal = options.equal);
-    function signalFn() {
-        producerAccessed(node);
-        return node.value;
-    }
-    signalFn.set = signalSetFn;
-    signalFn.update = signalUpdateFn;
-    signalFn.mutate = signalMutateFn;
-    signalFn.asReadonly = signalAsReadonlyFn;
-    signalFn[SIGNAL] = node;
-    return signalFn;
-}
-function setPostSignalSetFn(fn) {
-    const prev = postSignalSetFn;
-    postSignalSetFn = fn;
-    return prev;
-}
-// Note: Using an IIFE here to ensure that the spread assignment is not considered
-// a side-effect, ending up preserving `COMPUTED_NODE` and `REACTIVE_NODE`.
-// TODO: remove when https://github.com/evanw/esbuild/issues/3392 is resolved.
-const SIGNAL_NODE = /* @__PURE__ */ (() => {
-    return {
-        ...REACTIVE_NODE,
-        equal: defaultEquals,
-        readonlyFn: undefined,
-    };
-})();
-function signalValueChanged(node) {
-    node.version++;
-    producerNotifyConsumers(node);
-    postSignalSetFn?.();
-}
-function signalSetFn(newValue) {
-    const node = this[SIGNAL];
-    if (!producerUpdatesAllowed()) {
-        throwInvalidWriteToSignalError();
-    }
-    if (!node.equal(node.value, newValue)) {
-        node.value = newValue;
-        signalValueChanged(node);
-    }
-}
-function signalUpdateFn(updater) {
-    if (!producerUpdatesAllowed()) {
-        throwInvalidWriteToSignalError();
-    }
-    signalSetFn.call(this, updater(this[SIGNAL].value));
-}
-function signalMutateFn(mutator) {
-    const node = this[SIGNAL];
-    if (!producerUpdatesAllowed()) {
-        throwInvalidWriteToSignalError();
-    }
-    // Mutate bypasses equality checks as it's by definition changing the value.
-    mutator(node.value);
-    signalValueChanged(node);
-}
-function signalAsReadonlyFn() {
-    const node = this[SIGNAL];
-    if (node.readonlyFn === undefined) {
-        const readonlyFn = () => this();
-        readonlyFn[SIGNAL] = node;
-        node.readonlyFn = readonlyFn;
-    }
-    return node.readonlyFn;
-}
-
-/**
- * Execute an arbitrary function in a non-reactive (non-tracking) context. The executed function
- * can, optionally, return a value.
- *
- * @developerPreview
- */
-function untracked(nonReactiveReadsFn) {
-    const prevConsumer = setActiveConsumer(null);
-    // We are not trying to catch any particular errors here, just making sure that the consumers
-    // stack is restored in case of errors.
-    try {
-        return nonReactiveReadsFn();
-    }
-    finally {
-        setActiveConsumer(prevConsumer);
-    }
-}
-
-function watch(fn, schedule, allowSignalWrites) {
-    const node = Object.create(WATCH_NODE);
-    if (allowSignalWrites) {
-        node.consumerAllowSignalWrites = true;
-    }
-    node.fn = fn;
-    node.schedule = schedule;
-    const registerOnCleanup = (cleanupFn) => {
-        node.cleanupFn = cleanupFn;
-    };
-    function isWatchNodeDestroyed(node) {
-        return node.fn === null && node.schedule === null;
-    }
-    function destroyWatchNode(node) {
-        if (!isWatchNodeDestroyed(node)) {
-            consumerDestroy(node); // disconnect watcher from the reactive graph
-            node.cleanupFn();
-            // nullify references to the integration functions to mark node as destroyed
-            node.fn = null;
-            node.schedule = null;
-            node.cleanupFn = NOOP_CLEANUP_FN;
-        }
-    }
-    const run = () => {
-        if (node.fn === null) {
-            // trying to run a destroyed watch is noop
-            return;
-        }
-        if (isInNotificationPhase()) {
-            throw new Error(`Schedulers cannot synchronously execute watches while scheduling.`);
-        }
-        node.dirty = false;
-        if (node.hasRun && !consumerPollProducersForChange(node)) {
-            return;
-        }
-        node.hasRun = true;
-        const prevConsumer = consumerBeforeComputation(node);
-        try {
-            node.cleanupFn();
-            node.cleanupFn = NOOP_CLEANUP_FN;
-            node.fn(registerOnCleanup);
-        }
-        finally {
-            consumerAfterComputation(node, prevConsumer);
-        }
-    };
-    node.ref = {
-        notify: () => consumerMarkDirty(node),
-        run,
-        cleanup: () => node.cleanupFn(),
-        destroy: () => destroyWatchNode(node),
-    };
-    return node.ref;
-}
-const NOOP_CLEANUP_FN = () => { };
-// Note: Using an IIFE here to ensure that the spread assignment is not considered
-// a side-effect, ending up preserving `COMPUTED_NODE` and `REACTIVE_NODE`.
-// TODO: remove when https://github.com/evanw/esbuild/issues/3392 is resolved.
-const WATCH_NODE = /* @__PURE__ */ (() => {
-    return {
-        ...REACTIVE_NODE,
-        consumerIsAlwaysLive: true,
-        consumerAllowSignalWrites: false,
-        consumerMarkedDirty: (node) => {
-            if (node.schedule !== null) {
-                node.schedule(node.ref);
-            }
-        },
-        hasRun: false,
-        cleanupFn: NOOP_CLEANUP_FN,
-    };
-})();
-
-function setAlternateWeakRefImpl(impl) {
-    // TODO: remove this function
-}
-
-/**
- * Represents a basic change from a previous to a new value for a single
- * property on a directive instance. Passed as a value in a
- * {@link SimpleChanges} object to the `ngOnChanges` hook.
- *
- * @see {@link OnChanges}
- *
- * @publicApi
- */
-class SimpleChange {
-    constructor(previousValue, currentValue, firstChange) {
-        this.previousValue = previousValue;
-        this.currentValue = currentValue;
-        this.firstChange = firstChange;
-    }
-    /**
-     * Check whether the new value is the first value assigned.
-     */
-    isFirstChange() {
-        return this.firstChange;
-    }
-}
-
-/**
- * The NgOnChangesFeature decorates a component with support for the ngOnChanges
- * lifecycle hook, so it should be included in any component that implements
- * that hook.
- *
- * If the component or directive uses inheritance, the NgOnChangesFeature MUST
- * be included as a feature AFTER {@link InheritDefinitionFeature}, otherwise
- * inherited properties will not be propagated to the ngOnChanges lifecycle
- * hook.
- *
- * Example usage:
- *
- * ```
- * static ɵcmp = defineComponent({
- *   ...
- *   inputs: {name: 'publicName'},
- *   features: [NgOnChangesFeature]
- * });
- * ```
- *
- * @codeGenApi
- */
-function ɵɵNgOnChangesFeature() {
-    return NgOnChangesFeatureImpl;
-}
-function NgOnChangesFeatureImpl(definition) {
-    if (definition.type.prototype.ngOnChanges) {
-        definition.setInput = ngOnChangesSetInput;
-    }
-    return rememberChangeHistoryAndInvokeOnChangesHook;
-}
-// This option ensures that the ngOnChanges lifecycle hook will be inherited
-// from superclasses (in InheritDefinitionFeature).
-/** @nocollapse */
-// tslint:disable-next-line:no-toplevel-property-access
-ɵɵNgOnChangesFeature.ngInherit = true;
-/**
- * This is a synthetic lifecycle hook which gets inserted into `TView.preOrderHooks` to simulate
- * `ngOnChanges`.
- *
- * The hook reads the `NgSimpleChangesStore` data from the component instance and if changes are
- * found it invokes `ngOnChanges` on the component instance.
- *
- * @param this Component instance. Because this function gets inserted into `TView.preOrderHooks`,
- *     it is guaranteed to be called with component instance.
- */
-function rememberChangeHistoryAndInvokeOnChangesHook() {
-    const simpleChangesStore = getSimpleChangesStore(this);
-    const current = simpleChangesStore?.current;
-    if (current) {
-        const previous = simpleChangesStore.previous;
-        if (previous === EMPTY_OBJ) {
-            simpleChangesStore.previous = current;
-        }
-        else {
-            // New changes are copied to the previous store, so that we don't lose history for inputs
-            // which were not changed this time
-            for (let key in current) {
-                previous[key] = current[key];
-            }
-        }
-        simpleChangesStore.current = null;
-        this.ngOnChanges(current);
-    }
-}
-function ngOnChangesSetInput(instance, value, publicName, privateName) {
-    const declaredName = this.declaredInputs[publicName];
-    ngDevMode && assertString(declaredName, 'Name of input in ngOnChanges has to be a string');
-    const simpleChangesStore = getSimpleChangesStore(instance) ||
-        setSimpleChangesStore(instance, { previous: EMPTY_OBJ, current: null });
-    const current = simpleChangesStore.current || (simpleChangesStore.current = {});
-    const previous = simpleChangesStore.previous;
-    const previousChange = previous[declaredName];
-    current[declaredName] = new SimpleChange(previousChange && previousChange.currentValue, value, previous === EMPTY_OBJ);
-    instance[privateName] = value;
-}
-const SIMPLE_CHANGES_STORE = '__ngSimpleChanges__';
-function getSimpleChangesStore(instance) {
-    return instance[SIMPLE_CHANGES_STORE] || null;
-}
-function setSimpleChangesStore(instance, store) {
-    return instance[SIMPLE_CHANGES_STORE] = store;
-}
-
-let profilerCallback = null;
-/**
- * Sets the callback function which will be invoked before and after performing certain actions at
- * runtime (for example, before and after running change detection).
- *
- * Warning: this function is *INTERNAL* and should not be relied upon in application's code.
- * The contract of the function might be changed in any release and/or the function can be removed
- * completely.
- *
- * @param profiler function provided by the caller or null value to disable profiling.
- */
-const setProfiler = (profiler) => {
-    profilerCallback = profiler;
-};
-/**
- * Profiler function which wraps user code executed by the runtime.
- *
- * @param event ProfilerEvent corresponding to the execution context
- * @param instance component instance
- * @param hookOrListener lifecycle hook function or output listener. The value depends on the
- *  execution context
- * @returns
- */
-const profiler = function (event, instance, hookOrListener) {
-    if (profilerCallback != null /* both `null` and `undefined` */) {
-        profilerCallback(event, instance, hookOrListener);
-    }
-};
-
-const SVG_NAMESPACE = 'svg';
-const MATH_ML_NAMESPACE = 'math';
-
-/**
- * For efficiency reasons we often put several different data types (`RNode`, `LView`, `LContainer`)
- * in same location in `LView`. This is because we don't want to pre-allocate space for it
- * because the storage is sparse. This file contains utilities for dealing with such data types.
- *
- * How do we know what is stored at a given location in `LView`.
- * - `Array.isArray(value) === false` => `RNode` (The normal storage value)
- * - `Array.isArray(value) === true` => then the `value[0]` represents the wrapped value.
- *   - `typeof value[TYPE] === 'object'` => `LView`
- *      - This happens when we have a component at a given location
- *   - `typeof value[TYPE] === true` => `LContainer`
- *      - This happens when we have `LContainer` binding at a given location.
- *
- *
- * NOTE: it is assumed that `Array.isArray` and `typeof` operations are very efficient.
- */
-/**
- * Returns `RNode`.
- * @param value wrapped value of `RNode`, `LView`, `LContainer`
- */
-function unwrapRNode(value) {
-    while (Array.isArray(value)) {
-        value = value[HOST];
-    }
-    return value;
-}
-/**
- * Returns `LView` or `null` if not found.
- * @param value wrapped value of `RNode`, `LView`, `LContainer`
- */
-function unwrapLView(value) {
-    while (Array.isArray(value)) {
-        // This check is same as `isLView()` but we don't call at as we don't want to call
-        // `Array.isArray()` twice and give JITer more work for inlining.
-        if (typeof value[TYPE] === 'object')
-            return value;
-        value = value[HOST];
-    }
-    return null;
-}
-/**
- * Retrieves an element value from the provided `viewData`, by unwrapping
- * from any containers, component views, or style contexts.
- */
-function getNativeByIndex(index, lView) {
-    ngDevMode && assertIndexInRange(lView, index);
-    ngDevMode && assertGreaterThanOrEqual(index, HEADER_OFFSET, 'Expected to be past HEADER_OFFSET');
-    return unwrapRNode(lView[index]);
-}
-/**
- * Retrieve an `RNode` for a given `TNode` and `LView`.
- *
- * This function guarantees in dev mode to retrieve a non-null `RNode`.
- *
- * @param tNode
- * @param lView
- */
-function getNativeByTNode(tNode, lView) {
-    ngDevMode && assertTNodeForLView(tNode, lView);
-    ngDevMode && assertIndexInRange(lView, tNode.index);
-    const node = unwrapRNode(lView[tNode.index]);
-    return node;
-}
-/**
- * Retrieve an `RNode` or `null` for a given `TNode` and `LView`.
- *
- * Some `TNode`s don't have associated `RNode`s. For example `Projection`
- *
- * @param tNode
- * @param lView
- */
-function getNativeByTNodeOrNull(tNode, lView) {
-    const index = tNode === null ? -1 : tNode.index;
-    if (index !== -1) {
-        ngDevMode && assertTNodeForLView(tNode, lView);
-        const node = unwrapRNode(lView[index]);
-        return node;
-    }
-    return null;
-}
-// fixme(misko): The return Type should be `TNode|null`
-function getTNode(tView, index) {
-    ngDevMode && assertGreaterThan(index, -1, 'wrong index for TNode');
-    ngDevMode && assertLessThan(index, tView.data.length, 'wrong index for TNode');
-    const tNode = tView.data[index];
-    ngDevMode && tNode !== null && assertTNode(tNode);
-    return tNode;
-}
-/** Retrieves a value from any `LView` or `TData`. */
-function load(view, index) {
-    ngDevMode && assertIndexInRange(view, index);
-    return view[index];
-}
-function getComponentLViewByIndex(nodeIndex, hostView) {
-    // Could be an LView or an LContainer. If LContainer, unwrap to find LView.
-    ngDevMode && assertIndexInRange(hostView, nodeIndex);
-    const slotValue = hostView[nodeIndex];
-    const lView = isLView(slotValue) ? slotValue : slotValue[HOST];
-    return lView;
-}
-/** Checks whether a given view is in creation mode */
-function isCreationMode(view) {
-    return (view[FLAGS] & 4 /* LViewFlags.CreationMode */) === 4 /* LViewFlags.CreationMode */;
-}
-/**
- * Returns a boolean for whether the view is attached to the change detection tree.
- *
- * Note: This determines whether a view should be checked, not whether it's inserted
- * into a container. For that, you'll want `viewAttachedToContainer` below.
- */
-function viewAttachedToChangeDetector(view) {
-    return (view[FLAGS] & 128 /* LViewFlags.Attached */) === 128 /* LViewFlags.Attached */;
-}
-/** Returns a boolean for whether the view is attached to a container. */
-function viewAttachedToContainer(view) {
-    return isLContainer(view[PARENT]);
-}
-function getConstant(consts, index) {
-    if (index === null || index === undefined)
-        return null;
-    ngDevMode && assertIndexInRange(consts, index);
-    return consts[index];
-}
-/**
- * Resets the pre-order hook flags of the view.
- * @param lView the LView on which the flags are reset
- */
-function resetPreOrderHookFlags(lView) {
-    lView[PREORDER_HOOK_FLAGS] = 0;
-}
-/**
- * Adds the `RefreshView` flag from the lView and updates DESCENDANT_VIEWS_TO_REFRESH counters of
- * parents.
- */
-function markViewForRefresh(lView) {
-    if ((lView[FLAGS] & 1024 /* LViewFlags.RefreshView */) === 0) {
-        lView[FLAGS] |= 1024 /* LViewFlags.RefreshView */;
-        updateViewsToRefresh(lView, 1);
-    }
-}
-/**
- * Removes the `RefreshView` flag from the lView and updates DESCENDANT_VIEWS_TO_REFRESH counters of
- * parents.
- */
-function clearViewRefreshFlag(lView) {
-    if (lView[FLAGS] & 1024 /* LViewFlags.RefreshView */) {
-        lView[FLAGS] &= ~1024 /* LViewFlags.RefreshView */;
-        updateViewsToRefresh(lView, -1);
-    }
-}
-/**
- * Walks up the LView hierarchy.
- * @param nestingLevel Number of times to walk up in hierarchy.
- * @param currentView View from which to start the lookup.
- */
-function walkUpViews(nestingLevel, currentView) {
-    while (nestingLevel > 0) {
-        ngDevMode &&
-            assertDefined(currentView[DECLARATION_VIEW], 'Declaration view should be defined if nesting level is greater than 0.');
-        currentView = currentView[DECLARATION_VIEW];
-        nestingLevel--;
-    }
-    return currentView;
-}
-/**
- * Updates the `DESCENDANT_VIEWS_TO_REFRESH` counter on the parents of the `LView` as well as the
- * parents above that whose
- *  1. counter goes from 0 to 1, indicating that there is a new child that has a view to refresh
- *  or
- *  2. counter goes from 1 to 0, indicating there are no more descendant views to refresh
- */
-function updateViewsToRefresh(lView, amount) {
-    let parent = lView[PARENT];
-    if (parent === null) {
-        return;
-    }
-    parent[DESCENDANT_VIEWS_TO_REFRESH] += amount;
-    let viewOrContainer = parent;
-    parent = parent[PARENT];
-    while (parent !== null &&
-        ((amount === 1 && viewOrContainer[DESCENDANT_VIEWS_TO_REFRESH] === 1) ||
-            (amount === -1 && viewOrContainer[DESCENDANT_VIEWS_TO_REFRESH] === 0))) {
-        parent[DESCENDANT_VIEWS_TO_REFRESH] += amount;
-        viewOrContainer = parent;
-        parent = parent[PARENT];
+        else {
+            parent[FLAGS] |= 8192 /* LViewFlags.HasChildViewsToRefresh */;
+            if (!viewAttachedToChangeDetector(parent)) {
+                break;
+            }
+        }
+        parent = parent[PARENT];
     }
 }
 /**
@@ -3863,7 +3361,7 @@ function incrementInitPhaseFlags(lView, initPhase) {
         assertNotEqual(initPhase, 3 /* InitPhaseState.InitPhaseCompleted */, 'Init hooks phase should not be incremented after all init hooks have been run.');
     let flags = lView[FLAGS];
     if ((flags & 3 /* LViewFlags.InitPhaseStateMask */) === initPhase) {
-        flags &= 8191 /* LViewFlags.IndexWithinInitPhaseReset */;
+        flags &= 16383 /* LViewFlags.IndexWithinInitPhaseReset */;
         flags += 1 /* LViewFlags.InitPhaseStateIncrementer */;
         lView[FLAGS] = flags;
     }
@@ -3921,12 +3419,12 @@ function callHooks(currentView, arr, initPhase, currentNodeIndex) {
  */
 function callHookInternal(directive, hook) {
     profiler(4 /* ProfilerEvent.LifecycleHookStart */, directive, hook);
-    const prevConsumer = setActiveConsumer(null);
+    const prevConsumer = setActiveConsumer$1(null);
     try {
         hook.call(directive);
     }
     finally {
-        setActiveConsumer(prevConsumer);
+        setActiveConsumer$1(prevConsumer);
         profiler(5 /* ProfilerEvent.LifecycleHookEnd */, directive, hook);
     }
 }
@@ -3944,12 +3442,12 @@ function callHook(currentView, initPhase, arr, i) {
     const directiveIndex = isInitHook ? -arr[i] : arr[i];
     const directive = currentView[directiveIndex];
     if (isInitHook) {
-        const indexWithintInitPhase = currentView[FLAGS] >> 13 /* LViewFlags.IndexWithinInitPhaseShift */;
+        const indexWithintInitPhase = currentView[FLAGS] >> 14 /* LViewFlags.IndexWithinInitPhaseShift */;
         // The init phase state must be always checked here as it may have been recursively updated.
         if (indexWithintInitPhase <
             (currentView[PREORDER_HOOK_FLAGS] >> 16 /* PreOrderHookFlags.NumberOfInitHooksCalledShift */) &&
             (currentView[FLAGS] & 3 /* LViewFlags.InitPhaseStateMask */) === initPhase) {
-            currentView[FLAGS] += 8192 /* LViewFlags.IndexWithinInitPhaseIncrementer */;
+            currentView[FLAGS] += 16384 /* LViewFlags.IndexWithinInitPhaseIncrementer */;
             callHookInternal(directive, hook);
         }
     }
@@ -7261,6 +6759,21 @@ const ENABLED_SSR_FEATURES = new InjectionToken((typeof ngDevMode === 'undefined
     providedIn: 'root',
     factory: () => new Set(),
 });
+const IMAGE_CONFIG_DEFAULTS = {
+    breakpoints: [16, 32, 48, 64, 96, 128, 256, 384, 640, 750, 828, 1080, 1200, 1920, 2048, 3840],
+    disableImageSizeWarning: false,
+    disableImageLazyLoadWarning: false,
+};
+/**
+ * Injection token that configures the image optimized image functionality.
+ * See {@link ImageConfig} for additional information about parameters that
+ * can be used.
+ *
+ * @see {@link NgOptimizedImage}
+ * @see {@link ImageConfig}
+ * @publicApi
+ */
+const IMAGE_CONFIG = new InjectionToken('ImageConfig', { providedIn: 'root', factory: () => IMAGE_CONFIG_DEFAULTS });
 
 /**
  *
@@ -7379,7 +6892,9 @@ class DepsTracker {
         }
         else {
             if (!this.ownerNgModule.has(type)) {
-                throw new RuntimeError(1001 /* RuntimeErrorCode.RUNTIME_DEPS_ORPHAN_COMPONENT */, `Orphan component found! Trying to render the component ${type.name} without first loading the NgModule that declares it. Make sure that you import the component's NgModule in the NgModule or the standalone component in which you are trying to render this component. Also make sure the way the app is bundled and served always includes the component's NgModule before the component.`);
+                // This component is orphan! No need to handle the error since the component rendering
+                // pipeline (e.g., view_container_ref) will check for this error based on configs.
+                return { dependencies: [] };
             }
             const scope = this.getNgModuleScope(this.ownerNgModule.get(type));
             if (scope.compilation.isPoisoned) {
@@ -7552,6 +7067,15 @@ class DepsTracker {
         }
         return ans;
     }
+    /** @override */
+    isOrphanComponent(cmp) {
+        const def = getComponentDef(cmp);
+        if (!def || def.standalone) {
+            return false;
+        }
+        this.resolveNgModulesDecls();
+        return !this.ownerNgModule.has(cmp);
+    }
 }
 function addSet(sourceSet, targetSet) {
     for (const m of sourceSet) {
@@ -8654,6 +8178,7 @@ function insertView(tView, lView, lContainer, index) {
     if (lQueries !== null) {
         lQueries.insertView(tView);
     }
+    updateAncestorTraversalFlagsOnAttach(lView);
     // Sets the attached flag
     lView[FLAGS] |= 128 /* LViewFlags.Attached */;
 }
@@ -8692,9 +8217,6 @@ function detachMovedView(declarationContainer, lView) {
     const declarationViewIndex = movedViews.indexOf(lView);
     const insertionLContainer = lView[PARENT];
     ngDevMode && assertLContainer(insertionLContainer);
-    // If the view was marked for refresh but then detached before it was checked (where the flag
-    // would be cleared and the counter decremented), we need to update the status here.
-    clearViewRefreshFlag(lView);
     movedViews.splice(declarationViewIndex, 1);
 }
 /**
@@ -8744,8 +8266,8 @@ function detachView(lContainer, removeIndex) {
 function destroyLView(tView, lView) {
     if (!(lView[FLAGS] & 256 /* LViewFlags.Destroyed */)) {
         const renderer = lView[RENDERER];
-        lView[REACTIVE_TEMPLATE_CONSUMER] && consumerDestroy(lView[REACTIVE_TEMPLATE_CONSUMER]);
-        lView[REACTIVE_HOST_BINDING_CONSUMER] && consumerDestroy(lView[REACTIVE_HOST_BINDING_CONSUMER]);
+        lView[REACTIVE_TEMPLATE_CONSUMER] && consumerDestroy$1(lView[REACTIVE_TEMPLATE_CONSUMER]);
+        lView[REACTIVE_HOST_BINDING_CONSUMER] && consumerDestroy$1(lView[REACTIVE_HOST_BINDING_CONSUMER]);
         if (renderer.destroyNode) {
             applyView(tView, lView, renderer, 3 /* WalkTNodeTreeAction.Destroy */, null, null);
         }
@@ -10907,7 +10429,7 @@ class Version {
 /**
  * @publicApi
  */
-const VERSION = new Version('17.0.0-next.7');
+const VERSION = new Version('17.0.0-next.8');
 
 // This default value is when checking the hierarchy for a token.
 //
@@ -10928,6 +10450,64 @@ const VERSION = new Version('17.0.0-next.7');
 // - mod2.injector.get(token, default)
 const NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR = {};
 
+/**
+ * Checks if the given `value` is a reactive `Signal`.
+ */
+function isSignal(value) {
+    return typeof value === 'function' && value[SIGNAL$1] !== undefined;
+}
+
+/**
+ * Create a computed `Signal` which derives a reactive value from an expression.
+ */
+function computed(computation, options) {
+    const getter = createComputed$1(computation);
+    if (options?.equal) {
+        getter[SIGNAL$1].equal = options.equal;
+    }
+    return getter;
+}
+
+/**
+ * Create a `Signal` that can be set or updated directly.
+ */
+function signal(initialValue, options) {
+    const signalFn = createSignal$1(initialValue);
+    const node = signalFn[SIGNAL$1];
+    if (options?.equal) {
+        node.equal = options.equal;
+    }
+    signalFn.set = (newValue) => signalSetFn$1(node, newValue);
+    signalFn.update = (updateFn) => signalUpdateFn$1(node, updateFn);
+    signalFn.asReadonly = signalAsReadonlyFn.bind(signalFn);
+    return signalFn;
+}
+function signalAsReadonlyFn() {
+    const node = this[SIGNAL$1];
+    if (node.readonlyFn === undefined) {
+        const readonlyFn = () => this();
+        readonlyFn[SIGNAL$1] = node;
+        node.readonlyFn = readonlyFn;
+    }
+    return node.readonlyFn;
+}
+
+/**
+ * Execute an arbitrary function in a non-reactive (non-tracking) context. The executed function
+ * can, optionally, return a value.
+ */
+function untracked(nonReactiveReadsFn) {
+    const prevConsumer = setActiveConsumer$1(null);
+    // We are not trying to catch any particular errors here, just making sure that the consumers
+    // stack is restored in case of errors.
+    try {
+        return nonReactiveReadsFn();
+    }
+    finally {
+        setActiveConsumer$1(prevConsumer);
+    }
+}
+
 const ERROR_ORIGINAL_ERROR = 'ngOriginalError';
 function wrappedError(message, originalError) {
     const msg = `${message} caused by: ${originalError instanceof Error ? originalError.message : originalError}`;
@@ -11022,6 +10602,183 @@ function injectDestroyRef() {
     return new NodeInjectorDestroyRef(getLView());
 }
 
+/**
+ * Asserts that the current stack frame is not within a reactive context. Useful
+ * to disallow certain code from running inside a reactive context (see {@link toSignal}).
+ *
+ * @param debugFn a reference to the function making the assertion (used for the error message).
+ *
+ * @publicApi
+ */
+function assertNotInReactiveContext(debugFn, extraContext) {
+    // Taking a `Function` instead of a string name here prevents the un-minified name of the function
+    // from being retained in the bundle regardless of minification.
+    if (getActiveConsumer$1() !== null) {
+        throw new RuntimeError(-602 /* RuntimeErrorCode.ASSERTION_NOT_INSIDE_REACTIVE_CONTEXT */, ngDevMode &&
+            `${debugFn.name}() cannot be called from within a reactive context.${extraContext ? ` ${extraContext}` : ''}`);
+    }
+}
+
+/**
+ * Not public API, which guarantees `EffectScheduler` only ever comes from the application root
+ * injector.
+ */
+const APP_EFFECT_SCHEDULER = new InjectionToken('', {
+    providedIn: 'root',
+    factory: () => inject(EffectScheduler),
+});
+/**
+ * A scheduler which manages the execution of effects.
+ */
+class EffectScheduler {
+    /** @nocollapse */
+    static { this.ɵprov = ɵɵdefineInjectable({
+        token: EffectScheduler,
+        providedIn: 'root',
+        factory: () => new ZoneAwareMicrotaskScheduler(),
+    }); }
+}
+/**
+ * An `EffectScheduler` which is capable of queueing scheduled effects per-zone, and flushing them
+ * as an explicit operation.
+ */
+class ZoneAwareQueueingScheduler {
+    constructor() {
+        this.queuedEffectCount = 0;
+        this.queues = new Map();
+    }
+    scheduleEffect(handle) {
+        const zone = handle.creationZone;
+        if (!this.queues.has(zone)) {
+            this.queues.set(zone, new Set());
+        }
+        const queue = this.queues.get(zone);
+        if (queue.has(handle)) {
+            return;
+        }
+        this.queuedEffectCount++;
+        queue.add(handle);
+    }
+    /**
+     * Run all scheduled effects.
+     *
+     * Execution order of effects within the same zone is guaranteed to be FIFO, but there is no
+     * ordering guarantee between effects scheduled in different zones.
+     */
+    flush() {
+        while (this.queuedEffectCount > 0) {
+            for (const [zone, queue] of this.queues) {
+                // `zone` here must be defined.
+                if (zone === null) {
+                    this.flushQueue(queue);
+                }
+                else {
+                    zone.run(() => this.flushQueue(queue));
+                }
+            }
+        }
+    }
+    flushQueue(queue) {
+        for (const handle of queue) {
+            queue.delete(handle);
+            this.queuedEffectCount--;
+            // TODO: what happens if this throws an error?
+            handle.run();
+        }
+    }
+    /** @nocollapse */
+    static { this.ɵprov = ɵɵdefineInjectable({
+        token: ZoneAwareQueueingScheduler,
+        providedIn: 'root',
+        factory: () => new ZoneAwareQueueingScheduler(),
+    }); }
+}
+/**
+ * A wrapper around `ZoneAwareQueueingScheduler` that schedules flushing via the microtask queue
+ * when.
+ */
+class ZoneAwareMicrotaskScheduler {
+    constructor() {
+        this.hasQueuedFlush = false;
+        this.delegate = new ZoneAwareQueueingScheduler();
+        this.flushTask = () => {
+            // Leave `hasQueuedFlush` as `true` so we don't queue another microtask if more effects are
+            // scheduled during flushing. The flush of the `ZoneAwareQueueingScheduler` delegate is
+            // guaranteed to empty the queue.
+            this.delegate.flush();
+            this.hasQueuedFlush = false;
+            // This is a variable initialization, not a method.
+            // tslint:disable-next-line:semicolon
+        };
+    }
+    scheduleEffect(handle) {
+        this.delegate.scheduleEffect(handle);
+        if (!this.hasQueuedFlush) {
+            queueMicrotask(this.flushTask);
+            this.hasQueuedFlush = true;
+        }
+    }
+}
+/**
+ * Core reactive node for an Angular effect.
+ *
+ * `EffectHandle` combines the reactive graph's `Watch` base node for effects with the framework's
+ * scheduling abstraction (`EffectScheduler`) as well as automatic cleanup via `DestroyRef` if
+ * available/requested.
+ */
+class EffectHandle {
+    constructor(scheduler, effectFn, creationZone, destroyRef, errorHandler, allowSignalWrites) {
+        this.scheduler = scheduler;
+        this.effectFn = effectFn;
+        this.creationZone = creationZone;
+        this.errorHandler = errorHandler;
+        this.watcher = createWatch$1((onCleanup) => this.runEffect(onCleanup), () => this.schedule(), allowSignalWrites);
+        this.unregisterOnDestroy = destroyRef?.onDestroy(() => this.destroy());
+    }
+    runEffect(onCleanup) {
+        try {
+            this.effectFn(onCleanup);
+        }
+        catch (err) {
+            this.errorHandler?.handleError(err);
+        }
+    }
+    run() {
+        this.watcher.run();
+    }
+    schedule() {
+        this.scheduler.scheduleEffect(this);
+    }
+    notify() {
+        this.watcher.notify();
+    }
+    destroy() {
+        this.watcher.destroy();
+        this.unregisterOnDestroy?.();
+        // Note: if the effect is currently scheduled, it's not un-scheduled, and so the scheduler will
+        // retain a reference to it. Attempting to execute it will be a no-op.
+    }
+}
+/**
+ * Create a global `Effect` for the given reactive function.
+ */
+function effect(effectFn, options) {
+    ngDevMode &&
+        assertNotInReactiveContext(effect, 'Call `effect` outside of a reactive context. For example, schedule the ' +
+            'effect inside the component constructor.');
+    !options?.injector && assertInInjectionContext(effect);
+    const injector = options?.injector ?? inject(Injector);
+    const errorHandler = injector.get(ErrorHandler, null, { optional: true });
+    const destroyRef = options?.manualCleanup !== true ? injector.get(DestroyRef) : null;
+    const handle = new EffectHandle(injector.get(APP_EFFECT_SCHEDULER), effectFn, (typeof Zone === 'undefined') ? null : Zone.current, destroyRef, errorHandler, options?.allowSignalWrites ?? false);
+    // Effects start dirty.
+    handle.notify();
+    return handle;
+}
+
+// clang-format off
+// clang-format on
+
 /// <reference types="rxjs" />
 class EventEmitter_ extends Subject {
     constructor(isAsync = false) {
@@ -11702,6 +11459,9 @@ var AfterRenderPhase;
  * @developerPreview
  */
 function afterRender(callback, options) {
+    ngDevMode &&
+        assertNotInReactiveContext(afterRender, 'Call `afterRender` outside of a reactive context. For example, schedule the render ' +
+            'callback inside the component constructor`.');
     !options && assertInInjectionContext(afterRender);
     const injector = options?.injector ?? inject(Injector);
     if (!isPlatformBrowser(injector)) {
@@ -12113,7 +11873,7 @@ function commitLViewConsumerIfHasProducers(lView, slot) {
     currentConsumer = createLViewConsumer();
 }
 const REACTIVE_LVIEW_CONSUMER_NODE = {
-    ...REACTIVE_NODE,
+    ...REACTIVE_NODE$1,
     consumerIsAlwaysLive: true,
     consumerMarkedDirty: (node) => {
         (typeof ngDevMode === 'undefined' || ngDevMode) &&
@@ -12245,13 +12005,13 @@ function processHostBindingOpCodes(tView, lView) {
                 const hostBindingFn = hostBindingOpCodes[++i];
                 setBindingRootForHostBindings(bindingRootIndx, directiveIdx);
                 consumer.dirty = false;
-                const prevConsumer = consumerBeforeComputation(consumer);
+                const prevConsumer = consumerBeforeComputation$1(consumer);
                 try {
                     const context = lView[directiveIdx];
                     hostBindingFn(2 /* RenderFlags.Update */, context);
                 }
                 finally {
-                    consumerAfterComputation(consumer, prevConsumer);
+                    consumerAfterComputation$1(consumer, prevConsumer);
                 }
             }
         }
@@ -12393,7 +12153,7 @@ function executeTemplate(tView, lView, templateFn, rf, context) {
         const preHookType = isUpdatePhase ? 2 /* ProfilerEvent.TemplateUpdateStart */ : 0 /* ProfilerEvent.TemplateCreateStart */;
         profiler(preHookType, context);
         const effectiveConsumer = isUpdatePhase ? consumer : null;
-        const prevConsumer = consumerBeforeComputation(effectiveConsumer);
+        const prevConsumer = consumerBeforeComputation$1(effectiveConsumer);
         try {
             if (effectiveConsumer !== null) {
                 effectiveConsumer.dirty = false;
@@ -12401,7 +12161,7 @@ function executeTemplate(tView, lView, templateFn, rf, context) {
             templateFn(rf, context);
         }
         finally {
-            consumerAfterComputation(effectiveConsumer, prevConsumer);
+            consumerAfterComputation$1(effectiveConsumer, prevConsumer);
         }
     }
     finally {
@@ -12418,7 +12178,7 @@ function executeTemplate(tView, lView, templateFn, rf, context) {
 //////////////////////////
 function executeContentQueries(tView, tNode, lView) {
     if (isContentQueryHost(tNode)) {
-        const prevConsumer = setActiveConsumer(null);
+        const prevConsumer = setActiveConsumer$1(null);
         try {
             const start = tNode.directiveStart;
             const end = tNode.directiveEnd;
@@ -12430,7 +12190,7 @@ function executeContentQueries(tView, tNode, lView) {
             }
         }
         finally {
-            setActiveConsumer(prevConsumer);
+            setActiveConsumer$1(prevConsumer);
         }
     }
 }
@@ -13128,6 +12888,7 @@ function findDirectiveDefMatches(tView, tNode) {
             }
         }
     }
+    ngDevMode && matches !== null && assertNoDuplicateDirectives(matches);
     return matches === null ? null : [matches, hostDirectiveDefs];
 }
 /**
@@ -13274,7 +13035,7 @@ function setInputsFromAttrs(lView, directiveIndex, instance, def, tNode, initial
     }
 }
 function writeToDirectiveInput(def, instance, publicName, privateName, value) {
-    const prevConsumer = setActiveConsumer(null);
+    const prevConsumer = setActiveConsumer$1(null);
     try {
         const inputTransforms = def.inputTransforms;
         if (inputTransforms !== null && inputTransforms.hasOwnProperty(privateName)) {
@@ -13288,7 +13049,7 @@ function writeToDirectiveInput(def, instance, publicName, privateName, value) {
         }
     }
     finally {
-        setActiveConsumer(prevConsumer);
+        setActiveConsumer$1(prevConsumer);
     }
 }
 /**
@@ -13364,8 +13125,8 @@ function createLContainer(hostNative, currentView, native, tNode) {
         false,
         currentView,
         null,
-        0,
         tNode,
+        false,
         native,
         null,
         null,
@@ -13424,12 +13185,12 @@ function addToViewTree(lView, lViewOrLContainer) {
 function executeViewQueryFn(flags, viewQueryFn, component) {
     ngDevMode && assertDefined(viewQueryFn, 'View queries function to execute must be defined.');
     setCurrentQueryIndex(0);
-    const prevConsumer = setActiveConsumer(null);
+    const prevConsumer = setActiveConsumer$1(null);
     try {
         viewQueryFn(flags, component);
     }
     finally {
-        setActiveConsumer(prevConsumer);
+        setActiveConsumer$1(prevConsumer);
     }
 }
 ///////////////////////////////
@@ -13919,7 +13680,15 @@ function refreshView(tView, lView, templateFn, context) {
         if (!isInCheckNoChangesPass) {
             lView[FLAGS] &= ~(64 /* LViewFlags.Dirty */ | 8 /* LViewFlags.FirstLViewPass */);
         }
-        clearViewRefreshFlag(lView);
+        lView[FLAGS] &= ~1024 /* LViewFlags.RefreshView */;
+    }
+    catch (e) {
+        // If refreshing a view causes an error, we need to remark the ancestors as needing traversal
+        // because the error might have caused a situation where views below the current location are
+        // dirty but will be unreachable because the "has dirty children" flag in the ancestors has been
+        // cleared during change detection and we failed to run to completion.
+        markAncestorsForTraversal(lView);
+        throw e;
     }
     finally {
         leaveView();
@@ -13931,9 +13700,10 @@ function refreshView(tView, lView, templateFn, context) {
  */
 function detectChangesInEmbeddedViews(lView, mode) {
     for (let lContainer = getFirstLContainer(lView); lContainer !== null; lContainer = getNextLContainer(lContainer)) {
+        lContainer[HAS_CHILD_VIEWS_TO_REFRESH] = false;
         for (let i = CONTAINER_HEADER_OFFSET; i < lContainer.length; i++) {
             const embeddedLView = lContainer[i];
-            detectChangesInView(embeddedLView, mode);
+            detectChangesInViewIfAttached(embeddedLView, mode);
         }
     }
 }
@@ -13965,33 +13735,41 @@ function markTransplantedViewsForRefresh(lView) {
 function detectChangesInComponent(hostLView, componentHostIdx, mode) {
     ngDevMode && assertEqual(isCreationMode(hostLView), false, 'Should be run in update mode');
     const componentView = getComponentLViewByIndex(componentHostIdx, hostLView);
-    detectChangesInView(componentView, mode);
+    detectChangesInViewIfAttached(componentView, mode);
 }
 /**
  * Visits a view as part of change detection traversal.
  *
- * - If the view is detached, no additional traversal happens.
+ * If the view is detached, no additional traversal happens.
+ */
+function detectChangesInViewIfAttached(lView, mode) {
+    if (!viewAttachedToChangeDetector(lView)) {
+        return;
+    }
+    detectChangesInView(lView, mode);
+}
+/**
+ * Visits a view as part of change detection traversal.
  *
  * The view is refreshed if:
  * - If the view is CheckAlways or Dirty and ChangeDetectionMode is `Global`
  * - If the view has the `RefreshTransplantedView` flag
  *
  * The view is not refreshed, but descendants are traversed in `ChangeDetectionMode.Targeted` if the
- * view has a non-zero TRANSPLANTED_VIEWS_TO_REFRESH counter.
- *
+ * view HasChildViewsToRefresh flag is set.
  */
 function detectChangesInView(lView, mode) {
-    if (!viewAttachedToChangeDetector(lView)) {
-        return;
-    }
     const tView = lView[TVIEW];
     const flags = lView[FLAGS];
+    // Flag cleared before change detection runs so that the view can be re-marked for traversal if
+    // necessary.
+    lView[FLAGS] &= ~8192 /* LViewFlags.HasChildViewsToRefresh */;
     if ((flags & (16 /* LViewFlags.CheckAlways */ | 64 /* LViewFlags.Dirty */) &&
         mode === 0 /* ChangeDetectionMode.Global */) ||
         flags & 1024 /* LViewFlags.RefreshView */) {
         refreshView(tView, lView, tView.template, lView[CONTEXT]);
     }
-    else if (lView[DESCENDANT_VIEWS_TO_REFRESH] > 0) {
+    else if (flags & 8192 /* LViewFlags.HasChildViewsToRefresh */) {
         detectChangesInEmbeddedViews(lView, 1 /* ChangeDetectionMode.Targeted */);
         const components = tView.components;
         if (components !== null) {
@@ -14226,6 +14004,7 @@ class ViewRef$1 {
      * ```
      */
     reattach() {
+        updateAncestorTraversalFlagsOnAttach(this._lView);
         this._lView[FLAGS] |= 128 /* LViewFlags.Attached */;
     }
     /**
@@ -14392,6 +14171,13 @@ class ComponentFactory extends ComponentFactory$1 {
         this.isBoundToModule = !!ngModule;
     }
     create(injector, projectableNodes, rootSelectorOrNode, environmentInjector) {
+        // Check if the component is orphan
+        if (ngDevMode && (typeof ngJitMode === 'undefined' || ngJitMode) &&
+            this.componentDef.debugInfo?.forbidOrphanRendering) {
+            if (depsTracker.isOrphanComponent(this.componentType)) {
+                throw new RuntimeError(1001 /* RuntimeErrorCode.RUNTIME_DEPS_ORPHAN_COMPONENT */, `Orphan component found! Trying to render the component ${debugStringifyTypeForError(this.componentType)} without first loading the NgModule that declares it. It is recommended to make this component standalone in order to avoid this error. If this is not possible now, import the component's NgModule in the appropriate NgModule, or the standalone component in which you are trying to render this component. If this is a lazy import, load the NgModule lazily as well and use its module injector.`);
+            }
+        }
         environmentInjector = environmentInjector || this.ngModule;
         let realEnvironmentInjector = environmentInjector instanceof EnvironmentInjector ?
             environmentInjector :
@@ -14454,6 +14240,7 @@ class ComponentFactory extends ComponentFactory$1 {
                 hostDirectiveDefs = new Map();
                 rootComponentDef.findHostDirectiveDefs(rootComponentDef, rootDirectives, hostDirectiveDefs);
                 rootDirectives.push(rootComponentDef);
+                ngDevMode && assertNoDuplicateDirectives(rootDirectives);
             }
             else {
                 rootDirectives = [rootComponentDef];
@@ -14952,7 +14739,7 @@ function findHostDirectiveDefs(currentDef, matchedDefs, hostDirectiveDefs) {
         for (const hostDirectiveConfig of currentDef.hostDirectives) {
             const hostDirectiveDef = getDirectiveDef(hostDirectiveConfig.directive);
             if (typeof ngDevMode === 'undefined' || ngDevMode) {
-                validateHostDirective(hostDirectiveConfig, hostDirectiveDef, matchedDefs);
+                validateHostDirective(hostDirectiveConfig, hostDirectiveDef);
             }
             // We need to patch the `declaredInputs` so that
             // `ngOnChanges` can map the properties correctly.
@@ -15018,9 +14805,8 @@ function patchDeclaredInputs(declaredInputs, exposedInputs) {
  * Verifies that the host directive has been configured correctly.
  * @param hostDirectiveConfig Host directive configuration object.
  * @param directiveDef Directive definition of the host directive.
- * @param matchedDefs Directives that have been matched so far.
  */
-function validateHostDirective(hostDirectiveConfig, directiveDef, matchedDefs) {
+function validateHostDirective(hostDirectiveConfig, directiveDef) {
     const type = hostDirectiveConfig.directive;
     if (directiveDef === null) {
         if (getComponentDef(type) !== null) {
@@ -15032,10 +14818,6 @@ function validateHostDirective(hostDirectiveConfig, directiveDef, matchedDefs) {
     if (!directiveDef.standalone) {
         throw new RuntimeError(308 /* RuntimeErrorCode.HOST_DIRECTIVE_NOT_STANDALONE */, `Host directive ${directiveDef.type.name} must be standalone.`);
     }
-    if (matchedDefs.indexOf(directiveDef) > -1) {
-        throw new RuntimeError(309 /* RuntimeErrorCode.DUPLICATE_DIRECTITVE */, `Directive ${directiveDef.type.name} matches multiple times on the same element. ` +
-            `Directives can only match an element once.`);
-    }
     validateMappings('input', directiveDef, hostDirectiveConfig.inputs);
     validateMappings('output', directiveDef, hostDirectiveConfig.outputs);
 }
@@ -19421,6 +19203,12 @@ class LiveCollectionLContainerImpl extends LiveCollection {
         this.hostLView = hostLView;
         this.templateTNode = templateTNode;
         this.trackByFn = trackByFn;
+        /**
+         Property indicating if indexes in the repeater context need to be updated following the live
+         collection changes. Index updates are necessary if and only if views are inserted / removed in
+         the middle of LContainer. Adds and removals at the end don't require index updates.
+       */
+        this.needsIndexUpdate = false;
     }
     get length() {
         return this.lContainer.length - CONTAINER_HEADER_OFFSET;
@@ -19433,9 +19221,11 @@ class LiveCollectionLContainerImpl extends LiveCollection {
     }
     attach(index, lView) {
         const dehydratedView = lView[HYDRATION];
+        this.needsIndexUpdate ||= index !== this.length;
         addLViewToLContainer(this.lContainer, lView, index, shouldAddViewToDom(this.templateTNode, dehydratedView));
     }
     detach(index) {
+        this.needsIndexUpdate ||= index !== this.length - 1;
         return detachExistingView(this.lContainer, index);
     }
     create(index, value) {
@@ -19449,6 +19239,13 @@ class LiveCollectionLContainerImpl extends LiveCollection {
     updateValue(index, value) {
         this.at(index)[CONTEXT].$implicit = value;
     }
+    updateIndexes() {
+        if (this.needsIndexUpdate) {
+            for (let i = 0; i < this.length; i++) {
+                this.at(i)[CONTEXT].$index = i;
+            }
+        }
+    }
 }
 /**
  * The repeater instruction does update-time diffing of a provided collection (against the
@@ -19467,19 +19264,13 @@ function ɵɵrepeater(metadataSlotIdx, collection) {
     const containerIndex = metadataSlotIdx + 1;
     const lContainer = getLContainer(hostLView, HEADER_OFFSET + containerIndex);
     const itemTemplateTNode = getExistingTNode(hostTView, containerIndex);
-    reconcile(new LiveCollectionLContainerImpl(lContainer, hostLView, itemTemplateTNode, metadata.trackByFn), collection, metadata.trackByFn);
-    // moves in the container might caused context's index to get out of order, re-adjust
-    // PERF: we could try to book-keep moves and do this index re-adjust as need, at the cost of the
-    // additional code complexity
-    for (let i = 0; i < lContainer.length - CONTAINER_HEADER_OFFSET; i++) {
-        const lView = getExistingLViewFromLContainer(lContainer, i);
-        lView[CONTEXT].$index = i;
-    }
+    const liveCollection = new LiveCollectionLContainerImpl(lContainer, hostLView, itemTemplateTNode, metadata.trackByFn);
+    reconcile(liveCollection, collection, metadata.trackByFn);
+    // moves in the container might caused context's index to get out of order, re-adjust if needed
+    liveCollection.updateIndexes();
     // handle empty blocks
-    // PERF: maybe I could skip allocation of memory for the empty block? Isn't it the "fix" on the
-    // compiler side that we've been discussing? Talk to K & D!
-    const bindingIndex = nextBindingIndex();
     if (metadata.hasEmptyBlock) {
+        const bindingIndex = nextBindingIndex();
         const isCollectionEmpty = lContainer.length - CONTAINER_HEADER_OFFSET === 0;
         if (bindingUpdated(hostLView, bindingIndex, isCollectionEmpty)) {
             const emptyTemplateIndex = metadataSlotIdx + 2;
@@ -19531,6 +19322,10 @@ var DeferDependenciesLoadingState;
     /** Dependency loading has failed */
     DeferDependenciesLoadingState[DeferDependenciesLoadingState["FAILED"] = 3] = "FAILED";
 })(DeferDependenciesLoadingState || (DeferDependenciesLoadingState = {}));
+/** Slot index where `minimum` parameter value is stored. */
+const MINIMUM_SLOT = 0;
+/** Slot index where `after` parameter value is stored. */
+const LOADING_AFTER_SLOT = 1;
 /**
  * Describes the current state of this defer block instance.
  *
@@ -19559,11 +19354,14 @@ var DeferBlockInternalState;
     /** Initial state. Nothing is rendered yet. */
     DeferBlockInternalState[DeferBlockInternalState["Initial"] = -1] = "Initial";
 })(DeferBlockInternalState || (DeferBlockInternalState = {}));
-/**
- * A slot in the `LDeferBlockDetails` array that contains a number
- * that represent a current block state that is being rendered.
- */
-const DEFER_BLOCK_STATE = 0;
+const NEXT_DEFER_BLOCK_STATE = 0;
+// Note: it's *important* to keep the state in this slot, because this slot
+// is used by runtime logic to differentiate between LViews, LContainers and
+// other types (see `isLView` and `isLContainer` functions). In case of defer
+// blocks, this slot would always be a number.
+const DEFER_BLOCK_STATE = 1;
+const STATE_IS_FROZEN_UNTIL = 2;
+const LOADING_AFTER_CLEANUP_FN = 3;
 /**
  * Options for configuring defer blocks behavior.
  * @publicApi
@@ -19600,6 +19398,8 @@ const hoverTriggers = new WeakMap();
 const interactionTriggers = new WeakMap();
 /** Names of the events considered as interaction events. */
 const interactionEventNames = ['click', 'keydown'];
+/** Names of the events considered as hover events. */
+const hoverEventNames = ['mouseenter', 'focusin'];
 /** Object keeping track of registered callbacks for a deferred block trigger. */
 class DeferEventEntry {
     constructor() {
@@ -19669,7 +19469,9 @@ function onHover(trigger, callback, injector) {
         // Ensure that the handler runs in the NgZone since it gets
         // registered in `afterRender` which runs outside.
         injector.get(NgZone).run(() => {
-            trigger.addEventListener('mouseenter', entry.listener, eventListenerOptions);
+            for (const name of hoverEventNames) {
+                trigger.addEventListener(name, entry.listener, eventListenerOptions);
+            }
         });
     }
     entry.callbacks.add(callback);
@@ -19677,7 +19479,9 @@ function onHover(trigger, callback, injector) {
         const { callbacks, listener } = entry;
         callbacks.delete(callback);
         if (callbacks.size === 0) {
-            trigger.removeEventListener('mouseenter', listener, eventListenerOptions);
+            for (const name of hoverEventNames) {
+                trigger.removeEventListener(name, listener, eventListenerOptions);
+            }
             hoverTriggers.delete(trigger);
         }
     };
@@ -19730,6 +19534,10 @@ class DeferIntersectionManager {
         }
         entry.callbacks.add(callback);
         return () => {
+            // It's possible that a different cleanup callback fully removed this element already.
+            if (!this.viewportTriggers.has(trigger)) {
+                return;
+            }
             entry.callbacks.delete(callback);
             if (entry.callbacks.size === 0) {
                 this.intersectionObserver?.unobserve(trigger);
@@ -19757,6 +19565,33 @@ function shouldTriggerDeferBlock(injector) {
     }
     return isPlatformBrowser(injector);
 }
+/**
+ * Reference to the timer-based scheduler implementation of defer block state
+ * rendering method. It's used to make timer-based scheduling tree-shakable.
+ * If `minimum` or `after` parameters are used, compiler generates an extra
+ * argument for the `ɵɵdefer` instruction, which references a timer-based
+ * implementation.
+ */
+let applyDeferBlockStateWithSchedulingImpl = null;
+/**
+ * Enables timer-related scheduling if `after` or `minimum` parameters are setup
+ * on the `@loading` or `@placeholder` blocks.
+ */
+function ɵɵdeferEnableTimerScheduling(tView, tDetails, placeholderConfigIndex, loadingConfigIndex) {
+    const tViewConsts = tView.consts;
+    if (placeholderConfigIndex != null) {
+        tDetails.placeholderBlockConfig =
+            getConstant(tViewConsts, placeholderConfigIndex);
+    }
+    if (loadingConfigIndex != null) {
+        tDetails.loadingBlockConfig =
+            getConstant(tViewConsts, loadingConfigIndex);
+    }
+    // Enable implementation that supports timer-based scheduling.
+    if (applyDeferBlockStateWithSchedulingImpl === null) {
+        applyDeferBlockStateWithSchedulingImpl = applyDeferBlockStateWithScheduling;
+    }
+}
 /**
  * Creates runtime data structures for defer blocks.
  *
@@ -19770,32 +19605,30 @@ function shouldTriggerDeferBlock(injector) {
  *     block.
  * @param placeholderConfigIndex Index in the constants array of the configuration of the
  *     placeholder block.
+ * @param enableTimerScheduling Function that enables timer-related scheduling if `after`
+ *     or `minimum` parameters are setup on the `@loading` or `@placeholder` blocks.
  *
  * @codeGenApi
  */
-function ɵɵdefer(index, primaryTmplIndex, dependencyResolverFn, loadingTmplIndex, placeholderTmplIndex, errorTmplIndex, loadingConfigIndex, placeholderConfigIndex) {
+function ɵɵdefer(index, primaryTmplIndex, dependencyResolverFn, loadingTmplIndex, placeholderTmplIndex, errorTmplIndex, loadingConfigIndex, placeholderConfigIndex, enableTimerScheduling) {
     const lView = getLView();
     const tView = getTView();
-    const tViewConsts = tView.consts;
     const adjustedIndex = index + HEADER_OFFSET;
     ɵɵtemplate(index, null, 0, 0);
     if (tView.firstCreatePass) {
-        const deferBlockConfig = {
+        const tDetails = {
             primaryTmplIndex,
             loadingTmplIndex: loadingTmplIndex ?? null,
             placeholderTmplIndex: placeholderTmplIndex ?? null,
             errorTmplIndex: errorTmplIndex ?? null,
-            placeholderBlockConfig: placeholderConfigIndex != null ?
-                getConstant(tViewConsts, placeholderConfigIndex) :
-                null,
-            loadingBlockConfig: loadingConfigIndex != null ?
-                getConstant(tViewConsts, loadingConfigIndex) :
-                null,
+            placeholderBlockConfig: null,
+            loadingBlockConfig: null,
             dependencyResolverFn: dependencyResolverFn ?? null,
             loadingState: DeferDependenciesLoadingState.NOT_STARTED,
             loadingPromise: null,
         };
-        setTDeferBlockDetails(tView, adjustedIndex, deferBlockConfig);
+        enableTimerScheduling?.(tView, tDetails, placeholderConfigIndex, loadingConfigIndex);
+        setTDeferBlockDetails(tView, adjustedIndex, tDetails);
     }
     const tNode = getCurrentTNode();
     const lContainer = lView[adjustedIndex];
@@ -19804,8 +19637,12 @@ function ɵɵdefer(index, primaryTmplIndex, dependencyResolverFn, loadingTmplInd
     // In client-only mode, this function is a noop.
     populateDehydratedViewsInLContainer(lContainer, tNode, lView);
     // Init instance-specific defer details and store it.
-    const lDetails = [];
-    lDetails[DEFER_BLOCK_STATE] = DeferBlockInternalState.Initial;
+    const lDetails = [
+        null,
+        DeferBlockInternalState.Initial,
+        null,
+        null // LOADING_AFTER_CLEANUP_FN
+    ];
     setLDeferBlockDetails(lView, adjustedIndex, lDetails);
 }
 /**
@@ -20231,6 +20068,24 @@ function getTemplateIndexForState(newState, hostLView, tNode) {
             return null;
     }
 }
+/**
+ * Returns a minimum amount of time that a given state should be rendered for,
+ * taking into account `minimum` parameter value. If the `minimum` value is
+ * not specified - returns `null`.
+ */
+function getMinimumDurationForState(tDetails, currentState) {
+    if (currentState === DeferBlockState.Placeholder) {
+        return tDetails.placeholderBlockConfig?.[MINIMUM_SLOT] ?? null;
+    }
+    else if (currentState === DeferBlockState.Loading) {
+        return tDetails.loadingBlockConfig?.[MINIMUM_SLOT] ?? null;
+    }
+    return null;
+}
+/** Retrieves the value of the `after` parameter on the @loading block. */
+function getLoadingBlockAfter(tDetails) {
+    return tDetails.loadingBlockConfig?.[LOADING_AFTER_SLOT] ?? null;
+}
 /**
  * Transitions a defer block to the new state. Updates the  necessary
  * data structures and renders corresponding block.
@@ -20241,6 +20096,7 @@ function getTemplateIndexForState(newState, hostLView, tNode) {
  */
 function renderDeferBlockState(newState, tNode, lContainer) {
     const hostLView = lContainer[PARENT];
+    const hostTView = hostLView[TVIEW];
     // Check if this view is not destroyed. Since the loading process was async,
     // the view might end up being destroyed by the time rendering happens.
     if (isDestroyed(hostLView))
@@ -20249,12 +20105,26 @@ function renderDeferBlockState(newState, tNode, lContainer) {
     ngDevMode && assertTNodeForLView(tNode, hostLView);
     const lDetails = getLDeferBlockDetails(hostLView, tNode);
     ngDevMode && assertDefined(lDetails, 'Expected a defer block state defined');
+    const currentState = lDetails[DEFER_BLOCK_STATE];
+    if (isValidStateChange(currentState, newState) &&
+        isValidStateChange(lDetails[NEXT_DEFER_BLOCK_STATE] ?? -1, newState)) {
+        const tDetails = getTDeferBlockDetails(hostTView, tNode);
+        const needsScheduling = getLoadingBlockAfter(tDetails) !== null ||
+            getMinimumDurationForState(tDetails, DeferBlockState.Loading) !== null ||
+            getMinimumDurationForState(tDetails, DeferBlockState.Placeholder);
+        if (ngDevMode && needsScheduling) {
+            assertDefined(applyDeferBlockStateWithSchedulingImpl, 'Expected scheduling function to be defined');
+        }
+        const applyStateFn = needsScheduling ? applyDeferBlockStateWithSchedulingImpl : applyDeferBlockState;
+        applyStateFn(newState, lDetails, lContainer, tNode, hostLView);
+    }
+}
+/**
+ * Applies changes to the DOM to reflect a given state.
+ */
+function applyDeferBlockState(newState, lDetails, lContainer, tNode, hostLView) {
     const stateTmplIndex = getTemplateIndexForState(newState, hostLView, tNode);
-    // Note: we transition to the next state if the previous state was represented
-    // with a number that is less than the next state. For example, if the current
-    // state is "loading" (represented as `2`), we should not show a placeholder
-    // (represented as `1`).
-    if (lDetails[DEFER_BLOCK_STATE] < newState && stateTmplIndex !== null) {
+    if (stateTmplIndex !== null) {
         lDetails[DEFER_BLOCK_STATE] = newState;
         const hostTView = hostLView[TVIEW];
         const adjustedIndex = stateTmplIndex + HEADER_OFFSET;
@@ -20266,8 +20136,80 @@ function renderDeferBlockState(newState, tNode, lContainer) {
         const dehydratedView = findMatchingDehydratedView(lContainer, tNode.tView.ssrId);
         const embeddedLView = createAndRenderEmbeddedLView(hostLView, tNode, null, { dehydratedView });
         addLViewToLContainer(lContainer, embeddedLView, viewIndex, shouldAddViewToDom(tNode, dehydratedView));
+        markViewDirty(embeddedLView);
     }
 }
+/**
+ * Extends the `applyDeferBlockState` with timer-based scheduling.
+ * This function becomes available on a page if there are defer blocks
+ * that use `after` or `minimum` parameters in the `@loading` or
+ * `@placeholder` blocks.
+ */
+function applyDeferBlockStateWithScheduling(newState, lDetails, lContainer, tNode, hostLView) {
+    const now = Date.now();
+    const hostTView = hostLView[TVIEW];
+    const tDetails = getTDeferBlockDetails(hostTView, tNode);
+    if (lDetails[STATE_IS_FROZEN_UNTIL] === null || lDetails[STATE_IS_FROZEN_UNTIL] <= now) {
+        lDetails[STATE_IS_FROZEN_UNTIL] = null;
+        const loadingAfter = getLoadingBlockAfter(tDetails);
+        const inLoadingAfterPhase = lDetails[LOADING_AFTER_CLEANUP_FN] !== null;
+        if (newState === DeferBlockState.Loading && loadingAfter !== null && !inLoadingAfterPhase) {
+            // Trying to render loading, but it has an `after` config,
+            // so schedule an update action after a timeout.
+            lDetails[NEXT_DEFER_BLOCK_STATE] = newState;
+            const cleanupFn = scheduleDeferBlockUpdate(loadingAfter, lDetails, tNode, lContainer, hostLView);
+            lDetails[LOADING_AFTER_CLEANUP_FN] = cleanupFn;
+        }
+        else {
+            // If we transition to a complete or an error state and there is a pending
+            // operation to render loading after a timeout - invoke a cleanup operation,
+            // which stops the timer.
+            if (newState > DeferBlockState.Loading && inLoadingAfterPhase) {
+                lDetails[LOADING_AFTER_CLEANUP_FN]();
+                lDetails[LOADING_AFTER_CLEANUP_FN] = null;
+                lDetails[NEXT_DEFER_BLOCK_STATE] = null;
+            }
+            applyDeferBlockState(newState, lDetails, lContainer, tNode, hostLView);
+            const duration = getMinimumDurationForState(tDetails, newState);
+            if (duration !== null) {
+                lDetails[STATE_IS_FROZEN_UNTIL] = now + duration;
+                scheduleDeferBlockUpdate(duration, lDetails, tNode, lContainer, hostLView);
+            }
+        }
+    }
+    else {
+        // We are still rendering the previous state.
+        // Update the `NEXT_DEFER_BLOCK_STATE`, which would be
+        // picked up once it's time to transition to the next state.
+        lDetails[NEXT_DEFER_BLOCK_STATE] = newState;
+    }
+}
+/**
+ * Schedules an update operation after a specified timeout.
+ */
+function scheduleDeferBlockUpdate(timeout, lDetails, tNode, lContainer, hostLView) {
+    const callback = () => {
+        const nextState = lDetails[NEXT_DEFER_BLOCK_STATE];
+        lDetails[STATE_IS_FROZEN_UNTIL] = null;
+        lDetails[NEXT_DEFER_BLOCK_STATE] = null;
+        if (nextState !== null) {
+            renderDeferBlockState(nextState, tNode, lContainer);
+        }
+    };
+    return scheduleTimerTrigger(timeout, callback, hostLView, true);
+}
+/**
+ * Checks whether we can transition to the next state.
+ *
+ * We transition to the next state if the previous state was represented
+ * with a number that is less than the next state. For example, if the current
+ * state is "loading" (represented as `1`), we should not show a placeholder
+ * (represented as `0`), but we can show a completed state (represented as `2`)
+ * or an error state (represented as `3`).
+ */
+function isValidStateChange(currentState, newState) {
+    return currentState < newState;
+}
 /**
  * Trigger prefetching of dependencies for a defer block.
  *
@@ -20419,11 +20361,9 @@ function triggerDeferBlock(lView, tNode) {
     if (!shouldTriggerDeferBlock(injector))
         return;
     const tDetails = getTDeferBlockDetails(tView, tNode);
-    // Condition is triggered, try to render loading state and start downloading.
-    // Note: if a block is in a loading, completed or an error state, this call would be a noop.
-    renderDeferBlockState(DeferBlockState.Loading, tNode, lContainer);
     switch (tDetails.loadingState) {
         case DeferDependenciesLoadingState.NOT_STARTED:
+            renderDeferBlockState(DeferBlockState.Loading, tNode, lContainer);
             triggerResourceLoading(tDetails, lView);
             // The `loadingState` might have changed to "loading".
             if (tDetails.loadingState ===
@@ -20432,6 +20372,7 @@ function triggerDeferBlock(lView, tNode) {
             }
             break;
         case DeferDependenciesLoadingState.IN_PROGRESS:
+            renderDeferBlockState(DeferBlockState.Loading, tNode, lContainer);
             renderDeferStateAfterResourceLoading(tDetails, tNode, lContainer);
             break;
         case DeferDependenciesLoadingState.COMPLETE:
@@ -27359,6 +27300,18 @@ function ɵɵgetComponentDepsFactory(type, rawImports) {
     };
 }
 
+/**
+ * Sets the debug info for an Angular class.
+ *
+ * This runtime is guarded by ngDevMode flag.
+ */
+function ɵsetClassDebugInfo(type, debugInfo) {
+    const def = getComponentDef(type);
+    if (def !== null) {
+        def.debugInfo = debugInfo;
+    }
+}
+
 /**
  * A mapping of the @angular/core API surface used in generated expressions to the actual symbols.
  *
@@ -27497,6 +27450,7 @@ const angularCoreEnv = (() => ({
     'ɵɵdeferPrefetchOnHover': ɵɵdeferPrefetchOnHover,
     'ɵɵdeferPrefetchOnInteraction': ɵɵdeferPrefetchOnInteraction,
     'ɵɵdeferPrefetchOnViewport': ɵɵdeferPrefetchOnViewport,
+    'ɵɵdeferEnableTimerScheduling': ɵɵdeferEnableTimerScheduling,
     'ɵɵrepeater': ɵɵrepeater,
     'ɵɵrepeaterCreate': ɵɵrepeaterCreate,
     'ɵɵrepeaterTrackByIndex': ɵɵrepeaterTrackByIndex,
@@ -27527,6 +27481,7 @@ const angularCoreEnv = (() => ({
     'ɵɵsetNgModuleScope': ɵɵsetNgModuleScope,
     'ɵɵregisterNgModuleType': registerNgModuleType,
     'ɵɵgetComponentDepsFactory': ɵɵgetComponentDepsFactory,
+    'ɵsetClassDebugInfo': ɵsetClassDebugInfo,
     'ɵɵsanitizeHtml': ɵɵsanitizeHtml,
     'ɵɵsanitizeStyle': ɵɵsanitizeStyle,
     'ɵɵsanitizeResourceUrl': ɵɵsanitizeResourceUrl,
@@ -28743,7 +28698,7 @@ const ITS_JUST_ANGULAR = true;
  *
  * The following example illustrates how to configure a multi-provider using `APP_INITIALIZER` token
  * and a function returning a promise.
- *
+ * ### Example with NgModule-based application
  * ```
  *  function initializeApp(): Promise<any> {
  *    return new Promise((resolve, reject) => {
@@ -28765,11 +28720,38 @@ const ITS_JUST_ANGULAR = true;
  *  export class AppModule {}
  * ```
  *
+ * ### Example with standalone application
+ * ```
+ * export function initializeApp(http: HttpClient) {
+ *   return (): Promise<any> =>
+ *     firstValueFrom(
+ *       http
+ *         .get("https://someUrl.com/api/user")
+ *         .pipe(tap(user => { ... }))
+ *     );
+ * }
+ *
+ * bootstrapApplication(App, {
+ *   providers: [
+ *     provideHttpClient(),
+ *     {
+ *       provide: APP_INITIALIZER,
+ *       useFactory: initializeApp,
+ *       multi: true,
+ *       deps: [HttpClient],
+ *     },
+ *   ],
+ * });
+
+ * ```
+ *
+ *
  * It's also possible to configure a multi-provider using `APP_INITIALIZER` token and a function
  * returning an observable, see an example below. Note: the `HttpClient` in this example is used for
  * demo purposes to illustrate how the factory function can work with other providers available
  * through DI.
  *
+ * ### Example with NgModule-based application
  * ```
  *  function initializeAppFactory(httpClient: HttpClient): () => Observable<any> {
  *   return () => httpClient.get("https://someUrl.com/api/user")
@@ -28792,6 +28774,27 @@ const ITS_JUST_ANGULAR = true;
  *  export class AppModule {}
  * ```
  *
+ * ### Example with standalone application
+ *
+ *  function initializeAppFactory(httpClient: HttpClient): () => Observable<any> {
+ *   return () => httpClient.get("https://someUrl.com/api/user")
+ *     .pipe(
+ *        tap(user => { ... })
+ *     );
+ *  }
+ *
+ * bootstrapApplication(App, {
+ *   providers: [
+ *     provideHttpClient(),
+ *     {
+ *       provide: APP_INITIALIZER,
+ *       useFactory: initializeApp,
+ *       multi: true,
+ *       deps: [HttpClient],
+ *     },
+ *   ],
+ * });
+ *
  * @publicApi
  */
 const APP_INITIALIZER = new InjectionToken('Application Initializer');
@@ -29049,6 +29052,147 @@ var MissingTranslationStrategy;
     MissingTranslationStrategy[MissingTranslationStrategy["Ignore"] = 2] = "Ignore";
 })(MissingTranslationStrategy || (MissingTranslationStrategy = {}));
 
+// A delay in milliseconds before the scan is run after onLoad, to avoid any
+// potential race conditions with other LCP-related functions. This delay
+// happens outside of the main JavaScript execution and will only effect the timing
+// on when the warning becomes visible in the console.
+const SCAN_DELAY = 200;
+const OVERSIZED_IMAGE_TOLERANCE = 1200;
+class ImagePerformanceWarning {
+    constructor() {
+        // Map of full image URLs -> original `ngSrc` values.
+        this.window = null;
+        this.observer = null;
+        this.options = inject(IMAGE_CONFIG);
+    }
+    start() {
+        if (typeof PerformanceObserver === 'undefined' ||
+            (this.options?.disableImageSizeWarning && this.options?.disableImageLazyLoadWarning)) {
+            return;
+        }
+        this.observer = this.initPerformanceObserver();
+        const win = getDocument().defaultView;
+        if (typeof win !== 'undefined') {
+            this.window = win;
+            // Wait to avoid race conditions where LCP image triggers
+            // load event before it's recorded by the performance observer
+            const waitToScan = () => {
+                setTimeout(this.scanImages.bind(this), SCAN_DELAY);
+            };
+            this.window?.addEventListener('load', waitToScan);
+        }
+    }
+    ngOnDestroy() {
+        this.observer?.disconnect();
+    }
+    initPerformanceObserver() {
+        if (typeof PerformanceObserver === 'undefined') {
+            return null;
+        }
+        const observer = new PerformanceObserver((entryList) => {
+            const entries = entryList.getEntries();
+            if (entries.length === 0)
+                return;
+            // We use the latest entry produced by the `PerformanceObserver` as the best
+            // signal on which element is actually an LCP one. As an example, the first image to load on
+            // a page, by virtue of being the only thing on the page so far, is often a LCP candidate
+            // and gets reported by PerformanceObserver, but isn't necessarily the LCP element.
+            const lcpElement = entries[entries.length - 1];
+            // Cast to `any` due to missing `element` on the `LargestContentfulPaint` type of entry.
+            // See https://developer.mozilla.org/en-US/docs/Web/API/LargestContentfulPaint
+            const imgSrc = lcpElement.element?.src ?? '';
+            // Exclude `data:` and `blob:` URLs, since they are fetched resources.
+            if (imgSrc.startsWith('data:') || imgSrc.startsWith('blob:'))
+                return;
+            this.lcpImageUrl = imgSrc;
+        });
+        observer.observe({ type: 'largest-contentful-paint', buffered: true });
+        return observer;
+    }
+    scanImages() {
+        const images = getDocument().querySelectorAll('img');
+        let lcpElementFound, lcpElementLoadedCorrectly = false;
+        images.forEach(image => {
+            if (!this.options?.disableImageSizeWarning) {
+                for (const image of images) {
+                    // Image elements using the NgOptimizedImage directive are excluded,
+                    // as that directive has its own version of this check.
+                    if (!image.getAttribute('ng-img') && this.isOversized(image)) {
+                        logOversizedImageWarning(image.src);
+                    }
+                }
+            }
+            if (!this.options?.disableImageLazyLoadWarning && this.lcpImageUrl) {
+                if (image.src === this.lcpImageUrl) {
+                    lcpElementFound = true;
+                    if (image.loading !== 'lazy' || image.getAttribute('ng-img')) {
+                        // This variable is set to true and never goes back to false to account
+                        // for the case where multiple images have the same src url, and some
+                        // have lazy loading while others don't.
+                        // Also ignore NgOptimizedImage because there's a different warning for that.
+                        lcpElementLoadedCorrectly = true;
+                    }
+                }
+            }
+        });
+        if (lcpElementFound && !lcpElementLoadedCorrectly && this.lcpImageUrl &&
+            !this.options?.disableImageLazyLoadWarning) {
+            logLazyLCPWarning(this.lcpImageUrl);
+        }
+    }
+    isOversized(image) {
+        if (!this.window) {
+            return false;
+        }
+        const computedStyle = this.window.getComputedStyle(image);
+        let renderedWidth = parseFloat(computedStyle.getPropertyValue('width'));
+        let renderedHeight = parseFloat(computedStyle.getPropertyValue('height'));
+        const boxSizing = computedStyle.getPropertyValue('box-sizing');
+        const objectFit = computedStyle.getPropertyValue('object-fit');
+        if (objectFit === `cover`) {
+            // Object fit cover may indicate a use case such as a sprite sheet where
+            // this warning does not apply.
+            return false;
+        }
+        if (boxSizing === 'border-box') {
+            const paddingTop = computedStyle.getPropertyValue('padding-top');
+            const paddingRight = computedStyle.getPropertyValue('padding-right');
+            const paddingBottom = computedStyle.getPropertyValue('padding-bottom');
+            const paddingLeft = computedStyle.getPropertyValue('padding-left');
+            renderedWidth -= parseFloat(paddingRight) + parseFloat(paddingLeft);
+            renderedHeight -= parseFloat(paddingTop) + parseFloat(paddingBottom);
+        }
+        const intrinsicWidth = image.naturalWidth;
+        const intrinsicHeight = image.naturalHeight;
+        const recommendedWidth = this.window.devicePixelRatio * renderedWidth;
+        const recommendedHeight = this.window.devicePixelRatio * renderedHeight;
+        const oversizedWidth = (intrinsicWidth - recommendedWidth) >= OVERSIZED_IMAGE_TOLERANCE;
+        const oversizedHeight = (intrinsicHeight - recommendedHeight) >= OVERSIZED_IMAGE_TOLERANCE;
+        return oversizedWidth || oversizedHeight;
+    }
+    static { this.ɵfac = function ImagePerformanceWarning_Factory(t) { return new (t || ImagePerformanceWarning)(); }; }
+    static { this.ɵprov = /*@__PURE__*/ ɵɵdefineInjectable({ token: ImagePerformanceWarning, factory: ImagePerformanceWarning.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(ImagePerformanceWarning, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], () => [], null); })();
+function logLazyLCPWarning(src) {
+    console.warn(formatRuntimeError(-913 /* RuntimeErrorCode.IMAGE_PERFORMANCE_WARNING */, `An image with src ${src} is the Largest Contentful Paint (LCP) element ` +
+        `but was given a "loading" value of "lazy", which can negatively impact` +
+        `application loading performance. This warning can be addressed by ` +
+        `changing the loading value of the LCP image to "eager", or by using the ` +
+        `NgOptimizedImage directive's prioritization utilities. For more ` +
+        `information about addressing or disabling this warning, see ` +
+        `https://angular.io/errors/NG2965`));
+}
+function logOversizedImageWarning(src) {
+    console.warn(formatRuntimeError(-913 /* RuntimeErrorCode.IMAGE_PERFORMANCE_WARNING */, `An image with src ${src} has intrinsic file dimensions much larger than its ` +
+        `rendered size. This can negatively impact application loading performance. ` +
+        `For more information about addressing or disabling this warning, see ` +
+        `https://angular.io/errors/NG2965`));
+}
+
 /**
  * *Internal* service that keeps track of pending tasks happening in the system
  * during the initial rendering. No tasks are tracked after an initial
@@ -29299,7 +29443,35 @@ function handleInjectEvent(context, data) {
         instantiatedTokenToDependencies.set(context.token, []);
     }
     const { token, value, flags } = data;
-    instantiatedTokenToDependencies.get(context.token).push({ token, value, flags });
+    assertDefined(context.token, 'Injector profiler context token is undefined.');
+    const dependencies = instantiatedTokenToDependencies.get(context.token);
+    assertDefined(dependencies, 'Could not resolve dependencies for token.');
+    if (context.injector instanceof NodeInjector) {
+        dependencies.push({ token, value, flags, injectedIn: getNodeInjectorContext(context.injector) });
+    }
+    else {
+        dependencies.push({ token, value, flags });
+    }
+}
+/**
+ *
+ * Returns the LView and TNode associated with a NodeInjector. Returns undefined if the injector
+ * is not a NodeInjector.
+ *
+ * @param injector
+ * @returns {lView: LView, tNode: TNode}|undefined
+ */
+function getNodeInjectorContext(injector) {
+    if (!(injector instanceof NodeInjector)) {
+        throwError('getNodeInjectorContext must be called with a NodeInjector');
+    }
+    const lView = getNodeInjectorLView(injector);
+    const tNode = getNodeInjectorTNode(injector);
+    if (tNode === null) {
+        return;
+    }
+    assertTNodeForLView(tNode, lView);
+    return { lView, tNode };
 }
 /**
  *
@@ -29428,14 +29600,10 @@ function getDependenciesFromInjectable(injector, token) {
     if (instance === null) {
         throw new Error(`Unable to determine instance of ${token} in given injector`);
     }
-    let diResolver = injector;
-    if (injector instanceof NodeInjector) {
-        diResolver = getNodeInjectorLView(injector);
-    }
-    const { resolverToTokenToDependencies } = getFrameworkDIDebugData();
-    let dependencies = resolverToTokenToDependencies.get(diResolver)?.get?.(token) ?? [];
+    const unformattedDependencies = getDependenciesForTokenInInjector(token, injector);
     const resolutionPath = getInjectorResolutionPath(injector);
-    dependencies = dependencies.map(dep => {
+    const dependencies = unformattedDependencies.map(dep => {
+        // convert injection flags to booleans
         const flags = dep.flags;
         dep.flags = {
             optional: (8 /* InternalInjectFlags.Optional */ & flags) === 8 /* InternalInjectFlags.Optional */,
@@ -29443,6 +29611,7 @@ function getDependenciesFromInjectable(injector, token) {
             self: (2 /* InternalInjectFlags.Self */ & flags) === 2 /* InternalInjectFlags.Self */,
             skipSelf: (4 /* InternalInjectFlags.SkipSelf */ & flags) === 4 /* InternalInjectFlags.SkipSelf */,
         };
+        // find the injector that provided the dependency
         for (let i = 0; i < resolutionPath.length; i++) {
             const injectorToCheck = resolutionPath[i];
             // if skipSelf is true we skip the first injector
@@ -29475,10 +29644,42 @@ function getDependenciesFromInjectable(injector, token) {
                 break;
             }
         }
-        return dep;
+        // injectedIn contains private fields, so we omit it from the response
+        const formattedDependency = {
+            value: dep.value,
+        };
+        if (dep.token)
+            formattedDependency.token = dep.token;
+        if (dep.flags)
+            formattedDependency.flags = dep.flags;
+        if (dep.providedIn)
+            formattedDependency.providedIn = dep.providedIn;
+        return formattedDependency;
     });
     return { instance, dependencies };
 }
+function getDependenciesForTokenInInjector(token, injector) {
+    const { resolverToTokenToDependencies } = getFrameworkDIDebugData();
+    if (!(injector instanceof NodeInjector)) {
+        return resolverToTokenToDependencies.get(injector)?.get?.(token) ?? [];
+    }
+    const lView = getNodeInjectorLView(injector);
+    const tokenDependencyMap = resolverToTokenToDependencies.get(lView);
+    const dependencies = tokenDependencyMap?.get(token) ?? [];
+    // In the NodeInjector case, all injections for every node are stored in the same lView.
+    // We use the injectedIn field of the dependency to filter out the dependencies that
+    // do not come from the same node as the instance we're looking at.
+    return dependencies.filter(dependency => {
+        const dependencyNode = dependency.injectedIn?.tNode;
+        if (dependencyNode === undefined) {
+            return false;
+        }
+        const instanceNode = getNodeInjectorTNode(injector);
+        assertTNode(dependencyNode);
+        assertTNode(instanceNode);
+        return dependencyNode === instanceNode;
+    });
+}
 /**
  * Gets the class associated with an injector that contains a provider `imports` array in it's
  * definition
@@ -29741,8 +29942,7 @@ function getInjectorMetadata(injector) {
         const lView = getNodeInjectorLView(injector);
         const tNode = getNodeInjectorTNode(injector);
         assertTNodeForLView(tNode, lView);
-        assertDefined(lView[tNode.index][HOST], 'Could not find node in element view.');
-        return { type: 'element', source: lView[tNode.index][HOST] };
+        return { type: 'element', source: getNativeByTNode(tNode, lView) };
     }
     if (injector instanceof R3Injector) {
         return { type: 'environment', source: injector.source ?? null };
@@ -30316,7 +30516,7 @@ function publishDefaultGlobalUtils() {
  * Sets the error for an invalid write to a signal to be an Angular `RuntimeError`.
  */
 function publishSignalConfiguration() {
-    setThrowInvalidWriteToSignalError(() => {
+    setThrowInvalidWriteToSignalError$1(() => {
         throw new RuntimeError(600 /* RuntimeErrorCode.SIGNAL_WRITE_FROM_ILLEGAL_CONTEXT */, ngDevMode &&
             'Writing to signals is not allowed in a `computed` or an `effect` by default. ' +
                 'Use `allowSignalWrites` in the `CreateEffectOptions` to enable this inside effects.');
@@ -30443,6 +30643,10 @@ function internalCreateApplication(config) {
                     if (rootComponent !== undefined) {
                         appRef.bootstrap(rootComponent);
                     }
+                    if (typeof ngDevMode === 'undefined' || ngDevMode) {
+                        const imagePerformanceService = envInjector.get(ImagePerformanceWarning);
+                        imagePerformanceService.start();
+                    }
                     return appRef;
                 });
             });
@@ -32939,114 +33143,645 @@ class IterableDiffers {
         }
     }
 }
-function getTypeNameForDebugging(type) {
-    return type['name'] || typeof type;
-}
-
-function defaultKeyValueDiffersFactory() {
-    return new KeyValueDiffers([new DefaultKeyValueDifferFactory()]);
-}
+function getTypeNameForDebugging(type) {
+    return type['name'] || typeof type;
+}
+
+function defaultKeyValueDiffersFactory() {
+    return new KeyValueDiffers([new DefaultKeyValueDifferFactory()]);
+}
+/**
+ * A repository of different Map diffing strategies used by NgClass, NgStyle, and others.
+ *
+ * @publicApi
+ */
+class KeyValueDiffers {
+    /** @nocollapse */
+    static { this.ɵprov = ɵɵdefineInjectable({ token: KeyValueDiffers, providedIn: 'root', factory: defaultKeyValueDiffersFactory }); }
+    constructor(factories) {
+        this.factories = factories;
+    }
+    static create(factories, parent) {
+        if (parent) {
+            const copied = parent.factories.slice();
+            factories = factories.concat(copied);
+        }
+        return new KeyValueDiffers(factories);
+    }
+    /**
+     * Takes an array of {@link KeyValueDifferFactory} and returns a provider used to extend the
+     * inherited {@link KeyValueDiffers} instance with the provided factories and return a new
+     * {@link KeyValueDiffers} instance.
+     *
+     * @usageNotes
+     * ### Example
+     *
+     * The following example shows how to extend an existing list of factories,
+     * which will only be applied to the injector for this component and its children.
+     * This step is all that's required to make a new {@link KeyValueDiffer} available.
+     *
+     * ```
+     * @Component({
+     *   viewProviders: [
+     *     KeyValueDiffers.extend([new ImmutableMapDiffer()])
+     *   ]
+     * })
+     * ```
+     */
+    static extend(factories) {
+        return {
+            provide: KeyValueDiffers,
+            useFactory: (parent) => {
+                // if parent is null, it means that we are in the root injector and we have just overridden
+                // the default injection mechanism for KeyValueDiffers, in such a case just assume
+                // `defaultKeyValueDiffersFactory`.
+                return KeyValueDiffers.create(factories, parent || defaultKeyValueDiffersFactory());
+            },
+            // Dependency technically isn't optional, but we can provide a better error message this way.
+            deps: [[KeyValueDiffers, new SkipSelf(), new Optional()]]
+        };
+    }
+    find(kv) {
+        const factory = this.factories.find(f => f.supports(kv));
+        if (factory) {
+            return factory;
+        }
+        throw new RuntimeError(901 /* RuntimeErrorCode.NO_SUPPORTING_DIFFER_FACTORY */, ngDevMode && `Cannot find a differ supporting object '${kv}'`);
+    }
+}
+
+/**
+ * Structural diffing for `Object`s and `Map`s.
+ */
+const keyValDiff = [new DefaultKeyValueDifferFactory()];
+/**
+ * Structural diffing for `Iterable` types such as `Array`s.
+ */
+const iterableDiff = [new DefaultIterableDifferFactory()];
+const defaultIterableDiffers = new IterableDiffers(iterableDiff);
+const defaultKeyValueDiffers = new KeyValueDiffers(keyValDiff);
+
+/**
+ * @module
+ * @description
+ * Change detection enables data binding in Angular.
+ */
+
+/**
+ * This platform has to be included in any other platform
+ *
+ * @publicApi
+ */
+const platformCore = createPlatformFactory(null, 'core', []);
+
+/**
+ * Re-exported by `BrowserModule`, which is included automatically in the root
+ * `AppModule` when you create a new app with the CLI `new` command. Eagerly injects
+ * `ApplicationRef` to instantiate it.
+ *
+ * @publicApi
+ */
+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({}); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(ApplicationModule, [{
+        type: NgModule
+    }], () => [{ type: ApplicationRef }], null); })();
+
+/**
+ * The default equality function used for `signal` and `computed`, which uses referential equality.
+ */
+function defaultEquals(a, b) {
+    return Object.is(a, b);
+}
+
+/**
+ * The currently active consumer `ReactiveNode`, if running code in a reactive context.
+ *
+ * Change this via `setActiveConsumer`.
+ */
+let activeConsumer = null;
+let inNotificationPhase = false;
+/**
+ * Symbol used to tell `Signal`s apart from other functions.
+ *
+ * This can be used to auto-unwrap signals in various cases, or to auto-wrap non-signal values.
+ */
+const SIGNAL = /* @__PURE__ */ Symbol('SIGNAL');
+function setActiveConsumer(consumer) {
+    const prev = activeConsumer;
+    activeConsumer = consumer;
+    return prev;
+}
+function getActiveConsumer() {
+    return activeConsumer;
+}
+function isInNotificationPhase() {
+    return inNotificationPhase;
+}
+function isReactive(value) {
+    return value[SIGNAL] !== undefined;
+}
+const REACTIVE_NODE = {
+    version: 0,
+    dirty: false,
+    producerNode: undefined,
+    producerLastReadVersion: undefined,
+    producerIndexOfThis: undefined,
+    nextProducerIndex: 0,
+    liveConsumerNode: undefined,
+    liveConsumerIndexOfThis: undefined,
+    consumerAllowSignalWrites: false,
+    consumerIsAlwaysLive: false,
+    producerMustRecompute: () => false,
+    producerRecomputeValue: () => { },
+    consumerMarkedDirty: () => { },
+    consumerOnSignalRead: () => { },
+};
+/**
+ * Called by implementations when a producer's signal is read.
+ */
+function producerAccessed(node) {
+    if (inNotificationPhase) {
+        throw new Error(typeof ngDevMode !== 'undefined' && ngDevMode ?
+            `Assertion error: signal read during notification phase` :
+            '');
+    }
+    if (activeConsumer === null) {
+        // Accessed outside of a reactive context, so nothing to record.
+        return;
+    }
+    activeConsumer.consumerOnSignalRead(node);
+    // This producer is the `idx`th dependency of `activeConsumer`.
+    const idx = activeConsumer.nextProducerIndex++;
+    assertConsumerNode(activeConsumer);
+    if (idx < activeConsumer.producerNode.length && activeConsumer.producerNode[idx] !== node) {
+        // There's been a change in producers since the last execution of `activeConsumer`.
+        // `activeConsumer.producerNode[idx]` holds a stale dependency which will be be removed and
+        // replaced with `this`.
+        //
+        // If `activeConsumer` isn't live, then this is a no-op, since we can replace the producer in
+        // `activeConsumer.producerNode` directly. However, if `activeConsumer` is live, then we need
+        // to remove it from the stale producer's `liveConsumer`s.
+        if (consumerIsLive(activeConsumer)) {
+            const staleProducer = activeConsumer.producerNode[idx];
+            producerRemoveLiveConsumerAtIndex(staleProducer, activeConsumer.producerIndexOfThis[idx]);
+            // At this point, the only record of `staleProducer` is the reference at
+            // `activeConsumer.producerNode[idx]` which will be overwritten below.
+        }
+    }
+    if (activeConsumer.producerNode[idx] !== node) {
+        // We're a new dependency of the consumer (at `idx`).
+        activeConsumer.producerNode[idx] = node;
+        // If the active consumer is live, then add it as a live consumer. If not, then use 0 as a
+        // placeholder value.
+        activeConsumer.producerIndexOfThis[idx] =
+            consumerIsLive(activeConsumer) ? producerAddLiveConsumer(node, activeConsumer, idx) : 0;
+    }
+    activeConsumer.producerLastReadVersion[idx] = node.version;
+}
+/**
+ * Ensure this producer's `version` is up-to-date.
+ */
+function producerUpdateValueVersion(node) {
+    if (consumerIsLive(node) && !node.dirty) {
+        // A live consumer will be marked dirty by producers, so a clean state means that its version
+        // is guaranteed to be up-to-date.
+        return;
+    }
+    if (!node.producerMustRecompute(node) && !consumerPollProducersForChange(node)) {
+        // None of our producers report a change since the last time they were read, so no
+        // recomputation of our value is necessary, and we can consider ourselves clean.
+        node.dirty = false;
+        return;
+    }
+    node.producerRecomputeValue(node);
+    // After recomputing the value, we're no longer dirty.
+    node.dirty = false;
+}
+/**
+ * Propagate a dirty notification to live consumers of this producer.
+ */
+function producerNotifyConsumers(node) {
+    if (node.liveConsumerNode === undefined) {
+        return;
+    }
+    // Prevent signal reads when we're updating the graph
+    const prev = inNotificationPhase;
+    inNotificationPhase = true;
+    try {
+        for (const consumer of node.liveConsumerNode) {
+            if (!consumer.dirty) {
+                consumerMarkDirty(consumer);
+            }
+        }
+    }
+    finally {
+        inNotificationPhase = prev;
+    }
+}
+/**
+ * Whether this `ReactiveNode` in its producer capacity is currently allowed to initiate updates,
+ * based on the current consumer context.
+ */
+function producerUpdatesAllowed() {
+    return activeConsumer?.consumerAllowSignalWrites !== false;
+}
+function consumerMarkDirty(node) {
+    node.dirty = true;
+    producerNotifyConsumers(node);
+    node.consumerMarkedDirty?.(node);
+}
+/**
+ * Prepare this consumer to run a computation in its reactive context.
+ *
+ * Must be called by subclasses which represent reactive computations, before those computations
+ * begin.
+ */
+function consumerBeforeComputation(node) {
+    node && (node.nextProducerIndex = 0);
+    return setActiveConsumer(node);
+}
+/**
+ * Finalize this consumer's state after a reactive computation has run.
+ *
+ * Must be called by subclasses which represent reactive computations, after those computations
+ * have finished.
+ */
+function consumerAfterComputation(node, prevConsumer) {
+    setActiveConsumer(prevConsumer);
+    if (!node || node.producerNode === undefined || node.producerIndexOfThis === undefined ||
+        node.producerLastReadVersion === undefined) {
+        return;
+    }
+    if (consumerIsLive(node)) {
+        // For live consumers, we need to remove the producer -> consumer edge for any stale producers
+        // which weren't dependencies after the recomputation.
+        for (let i = node.nextProducerIndex; i < node.producerNode.length; i++) {
+            producerRemoveLiveConsumerAtIndex(node.producerNode[i], node.producerIndexOfThis[i]);
+        }
+    }
+    // Truncate the producer tracking arrays.
+    // Perf note: this is essentially truncating the length to `node.nextProducerIndex`, but
+    // benchmarking has shown that individual pop operations are faster.
+    while (node.producerNode.length > node.nextProducerIndex) {
+        node.producerNode.pop();
+        node.producerLastReadVersion.pop();
+        node.producerIndexOfThis.pop();
+    }
+}
+/**
+ * Determine whether this consumer has any dependencies which have changed since the last time
+ * they were read.
+ */
+function consumerPollProducersForChange(node) {
+    assertConsumerNode(node);
+    // Poll producers for change.
+    for (let i = 0; i < node.producerNode.length; i++) {
+        const producer = node.producerNode[i];
+        const seenVersion = node.producerLastReadVersion[i];
+        // First check the versions. A mismatch means that the producer's value is known to have
+        // changed since the last time we read it.
+        if (seenVersion !== producer.version) {
+            return true;
+        }
+        // The producer's version is the same as the last time we read it, but it might itself be
+        // stale. Force the producer to recompute its version (calculating a new value if necessary).
+        producerUpdateValueVersion(producer);
+        // Now when we do this check, `producer.version` is guaranteed to be up to date, so if the
+        // versions still match then it has not changed since the last time we read it.
+        if (seenVersion !== producer.version) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Disconnect this consumer from the graph.
+ */
+function consumerDestroy(node) {
+    assertConsumerNode(node);
+    if (consumerIsLive(node)) {
+        // Drop all connections from the graph to this node.
+        for (let i = 0; i < node.producerNode.length; i++) {
+            producerRemoveLiveConsumerAtIndex(node.producerNode[i], node.producerIndexOfThis[i]);
+        }
+    }
+    // Truncate all the arrays to drop all connection from this node to the graph.
+    node.producerNode.length = node.producerLastReadVersion.length = node.producerIndexOfThis.length =
+        0;
+    if (node.liveConsumerNode) {
+        node.liveConsumerNode.length = node.liveConsumerIndexOfThis.length = 0;
+    }
+}
 /**
- * A repository of different Map diffing strategies used by NgClass, NgStyle, and others.
+ * Add `consumer` as a live consumer of this node.
  *
- * @publicApi
+ * Note that this operation is potentially transitive. If this node becomes live, then it becomes
+ * a live consumer of all of its current producers.
  */
-class KeyValueDiffers {
-    /** @nocollapse */
-    static { this.ɵprov = ɵɵdefineInjectable({ token: KeyValueDiffers, providedIn: 'root', factory: defaultKeyValueDiffersFactory }); }
-    constructor(factories) {
-        this.factories = factories;
-    }
-    static create(factories, parent) {
-        if (parent) {
-            const copied = parent.factories.slice();
-            factories = factories.concat(copied);
+function producerAddLiveConsumer(node, consumer, indexOfThis) {
+    assertProducerNode(node);
+    assertConsumerNode(node);
+    if (node.liveConsumerNode.length === 0) {
+        // When going from 0 to 1 live consumers, we become a live consumer to our producers.
+        for (let i = 0; i < node.producerNode.length; i++) {
+            node.producerIndexOfThis[i] = producerAddLiveConsumer(node.producerNode[i], node, i);
         }
-        return new KeyValueDiffers(factories);
     }
-    /**
-     * Takes an array of {@link KeyValueDifferFactory} and returns a provider used to extend the
-     * inherited {@link KeyValueDiffers} instance with the provided factories and return a new
-     * {@link KeyValueDiffers} instance.
-     *
-     * @usageNotes
-     * ### Example
-     *
-     * The following example shows how to extend an existing list of factories,
-     * which will only be applied to the injector for this component and its children.
-     * This step is all that's required to make a new {@link KeyValueDiffer} available.
-     *
-     * ```
-     * @Component({
-     *   viewProviders: [
-     *     KeyValueDiffers.extend([new ImmutableMapDiffer()])
-     *   ]
-     * })
-     * ```
-     */
-    static extend(factories) {
-        return {
-            provide: KeyValueDiffers,
-            useFactory: (parent) => {
-                // if parent is null, it means that we are in the root injector and we have just overridden
-                // the default injection mechanism for KeyValueDiffers, in such a case just assume
-                // `defaultKeyValueDiffersFactory`.
-                return KeyValueDiffers.create(factories, parent || defaultKeyValueDiffersFactory());
-            },
-            // Dependency technically isn't optional, but we can provide a better error message this way.
-            deps: [[KeyValueDiffers, new SkipSelf(), new Optional()]]
-        };
+    node.liveConsumerIndexOfThis.push(indexOfThis);
+    return node.liveConsumerNode.push(consumer) - 1;
+}
+/**
+ * Remove the live consumer at `idx`.
+ */
+function producerRemoveLiveConsumerAtIndex(node, idx) {
+    assertProducerNode(node);
+    assertConsumerNode(node);
+    if (typeof ngDevMode !== 'undefined' && ngDevMode && idx >= node.liveConsumerNode.length) {
+        throw new Error(`Assertion error: active consumer index ${idx} is out of bounds of ${node.liveConsumerNode.length} consumers)`);
     }
-    find(kv) {
-        const factory = this.factories.find(f => f.supports(kv));
-        if (factory) {
-            return factory;
+    if (node.liveConsumerNode.length === 1) {
+        // When removing the last live consumer, we will no longer be live. We need to remove
+        // ourselves from our producers' tracking (which may cause consumer-producers to lose
+        // liveness as well).
+        for (let i = 0; i < node.producerNode.length; i++) {
+            producerRemoveLiveConsumerAtIndex(node.producerNode[i], node.producerIndexOfThis[i]);
         }
-        throw new RuntimeError(901 /* RuntimeErrorCode.NO_SUPPORTING_DIFFER_FACTORY */, ngDevMode && `Cannot find a differ supporting object '${kv}'`);
     }
+    // Move the last value of `liveConsumers` into `idx`. Note that if there's only a single
+    // live consumer, this is a no-op.
+    const lastIdx = node.liveConsumerNode.length - 1;
+    node.liveConsumerNode[idx] = node.liveConsumerNode[lastIdx];
+    node.liveConsumerIndexOfThis[idx] = node.liveConsumerIndexOfThis[lastIdx];
+    // Truncate the array.
+    node.liveConsumerNode.length--;
+    node.liveConsumerIndexOfThis.length--;
+    // If the index is still valid, then we need to fix the index pointer from the producer to this
+    // consumer, and update it from `lastIdx` to `idx` (accounting for the move above).
+    if (idx < node.liveConsumerNode.length) {
+        const idxProducer = node.liveConsumerIndexOfThis[idx];
+        const consumer = node.liveConsumerNode[idx];
+        assertConsumerNode(consumer);
+        consumer.producerIndexOfThis[idxProducer] = idx;
+    }
+}
+function consumerIsLive(node) {
+    return node.consumerIsAlwaysLive || (node?.liveConsumerNode?.length ?? 0) > 0;
+}
+function assertConsumerNode(node) {
+    node.producerNode ??= [];
+    node.producerIndexOfThis ??= [];
+    node.producerLastReadVersion ??= [];
+}
+function assertProducerNode(node) {
+    node.liveConsumerNode ??= [];
+    node.liveConsumerIndexOfThis ??= [];
 }
 
 /**
- * Structural diffing for `Object`s and `Map`s.
+ * Create a computed signal which derives a reactive value from an expression.
  */
-const keyValDiff = [new DefaultKeyValueDifferFactory()];
+function createComputed(computation) {
+    const node = Object.create(COMPUTED_NODE);
+    node.computation = computation;
+    const computed = () => {
+        // Check if the value needs updating before returning it.
+        producerUpdateValueVersion(node);
+        // Record that someone looked at this signal.
+        producerAccessed(node);
+        if (node.value === ERRORED) {
+            throw node.error;
+        }
+        return node.value;
+    };
+    computed[SIGNAL] = node;
+    return computed;
+}
 /**
- * Structural diffing for `Iterable` types such as `Array`s.
+ * A dedicated symbol used before a computed value has been calculated for the first time.
+ * Explicitly typed as `any` so we can use it as signal's value.
  */
-const iterableDiff = [new DefaultIterableDifferFactory()];
-const defaultIterableDiffers = new IterableDiffers(iterableDiff);
-const defaultKeyValueDiffers = new KeyValueDiffers(keyValDiff);
-
+const UNSET = /* @__PURE__ */ Symbol('UNSET');
 /**
- * @module
- * @description
- * Change detection enables data binding in Angular.
+ * A dedicated symbol used in place of a computed signal value to indicate that a given computation
+ * is in progress. Used to detect cycles in computation chains.
+ * Explicitly typed as `any` so we can use it as signal's value.
  */
-
+const COMPUTING = /* @__PURE__ */ Symbol('COMPUTING');
 /**
- * This platform has to be included in any other platform
- *
- * @publicApi
+ * A dedicated symbol used in place of a computed signal value to indicate that a given computation
+ * failed. The thrown error is cached until the computation gets dirty again.
+ * Explicitly typed as `any` so we can use it as signal's value.
  */
-const platformCore = createPlatformFactory(null, 'core', []);
+const ERRORED = /* @__PURE__ */ Symbol('ERRORED');
+// Note: Using an IIFE here to ensure that the spread assignment is not considered
+// a side-effect, ending up preserving `COMPUTED_NODE` and `REACTIVE_NODE`.
+// TODO: remove when https://github.com/evanw/esbuild/issues/3392 is resolved.
+const COMPUTED_NODE = /* @__PURE__ */ (() => {
+    return {
+        ...REACTIVE_NODE,
+        value: UNSET,
+        dirty: true,
+        error: null,
+        equal: defaultEquals,
+        producerMustRecompute(node) {
+            // Force a recomputation if there's no current value, or if the current value is in the
+            // process of being calculated (which should throw an error).
+            return node.value === UNSET || node.value === COMPUTING;
+        },
+        producerRecomputeValue(node) {
+            if (node.value === COMPUTING) {
+                // Our computation somehow led to a cyclic read of itself.
+                throw new Error('Detected cycle in computations.');
+            }
+            const oldValue = node.value;
+            node.value = COMPUTING;
+            const prevConsumer = consumerBeforeComputation(node);
+            let newValue;
+            try {
+                newValue = node.computation();
+            }
+            catch (err) {
+                newValue = ERRORED;
+                node.error = err;
+            }
+            finally {
+                consumerAfterComputation(node, prevConsumer);
+            }
+            if (oldValue !== UNSET && oldValue !== ERRORED && newValue !== ERRORED &&
+                node.equal(oldValue, newValue)) {
+                // No change to `valueVersion` - old and new values are
+                // semantically equivalent.
+                node.value = oldValue;
+                return;
+            }
+            node.value = newValue;
+            node.version++;
+        },
+    };
+})();
+
+function defaultThrowError() {
+    throw new Error();
+}
+let throwInvalidWriteToSignalErrorFn = defaultThrowError;
+function throwInvalidWriteToSignalError() {
+    throwInvalidWriteToSignalErrorFn();
+}
+function setThrowInvalidWriteToSignalError(fn) {
+    throwInvalidWriteToSignalErrorFn = fn;
+}
 
 /**
- * Re-exported by `BrowserModule`, which is included automatically in the root
- * `AppModule` when you create a new app with the CLI `new` command. Eagerly injects
- * `ApplicationRef` to instantiate it.
+ * If set, called after `WritableSignal`s are updated.
  *
- * @publicApi
+ * This hook can be used to achieve various effects, such as running effects synchronously as part
+ * of setting a signal.
  */
-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({}); }
+let postSignalSetFn = null;
+/**
+ * Create a `Signal` that can be set or updated directly.
+ */
+function createSignal(initialValue) {
+    const node = Object.create(SIGNAL_NODE);
+    node.value = initialValue;
+    const getter = (() => {
+        producerAccessed(node);
+        return node.value;
+    });
+    getter[SIGNAL] = node;
+    return getter;
+}
+function setPostSignalSetFn(fn) {
+    const prev = postSignalSetFn;
+    postSignalSetFn = fn;
+    return prev;
+}
+function signalGetFn() {
+    producerAccessed(this);
+    return this.value;
+}
+function signalSetFn(node, newValue) {
+    if (!producerUpdatesAllowed()) {
+        throwInvalidWriteToSignalError();
+    }
+    if (!node.equal(node.value, newValue)) {
+        node.value = newValue;
+        signalValueChanged(node);
+    }
+}
+function signalUpdateFn(node, updater) {
+    if (!producerUpdatesAllowed()) {
+        throwInvalidWriteToSignalError();
+    }
+    signalSetFn(node, updater(node.value));
+}
+function signalMutateFn(node, mutator) {
+    if (!producerUpdatesAllowed()) {
+        throwInvalidWriteToSignalError();
+    }
+    // Mutate bypasses equality checks as it's by definition changing the value.
+    mutator(node.value);
+    signalValueChanged(node);
+}
+// Note: Using an IIFE here to ensure that the spread assignment is not considered
+// a side-effect, ending up preserving `COMPUTED_NODE` and `REACTIVE_NODE`.
+// TODO: remove when https://github.com/evanw/esbuild/issues/3392 is resolved.
+const SIGNAL_NODE = /* @__PURE__ */ (() => {
+    return {
+        ...REACTIVE_NODE,
+        equal: defaultEquals,
+        value: undefined,
+    };
+})();
+function signalValueChanged(node) {
+    node.version++;
+    producerNotifyConsumers(node);
+    postSignalSetFn?.();
+}
+
+function createWatch(fn, schedule, allowSignalWrites) {
+    const node = Object.create(WATCH_NODE);
+    if (allowSignalWrites) {
+        node.consumerAllowSignalWrites = true;
+    }
+    node.fn = fn;
+    node.schedule = schedule;
+    const registerOnCleanup = (cleanupFn) => {
+        node.cleanupFn = cleanupFn;
+    };
+    function isWatchNodeDestroyed(node) {
+        return node.fn === null && node.schedule === null;
+    }
+    function destroyWatchNode(node) {
+        if (!isWatchNodeDestroyed(node)) {
+            consumerDestroy(node); // disconnect watcher from the reactive graph
+            node.cleanupFn();
+            // nullify references to the integration functions to mark node as destroyed
+            node.fn = null;
+            node.schedule = null;
+            node.cleanupFn = NOOP_CLEANUP_FN;
+        }
+    }
+    const run = () => {
+        if (node.fn === null) {
+            // trying to run a destroyed watch is noop
+            return;
+        }
+        if (isInNotificationPhase()) {
+            throw new Error(`Schedulers cannot synchronously execute watches while scheduling.`);
+        }
+        node.dirty = false;
+        if (node.hasRun && !consumerPollProducersForChange(node)) {
+            return;
+        }
+        node.hasRun = true;
+        const prevConsumer = consumerBeforeComputation(node);
+        try {
+            node.cleanupFn();
+            node.cleanupFn = NOOP_CLEANUP_FN;
+            node.fn(registerOnCleanup);
+        }
+        finally {
+            consumerAfterComputation(node, prevConsumer);
+        }
+    };
+    node.ref = {
+        notify: () => consumerMarkDirty(node),
+        run,
+        cleanup: () => node.cleanupFn(),
+        destroy: () => destroyWatchNode(node),
+        [SIGNAL]: node,
+    };
+    return node.ref;
+}
+const NOOP_CLEANUP_FN = () => { };
+// Note: Using an IIFE here to ensure that the spread assignment is not considered
+// a side-effect, ending up preserving `COMPUTED_NODE` and `REACTIVE_NODE`.
+// TODO: remove when https://github.com/evanw/esbuild/issues/3392 is resolved.
+const WATCH_NODE = /* @__PURE__ */ (() => {
+    return {
+        ...REACTIVE_NODE,
+        consumerIsAlwaysLive: true,
+        consumerAllowSignalWrites: false,
+        consumerMarkedDirty: (node) => {
+            if (node.schedule !== null) {
+                node.schedule(node.ref);
+            }
+        },
+        hasRun: false,
+        cleanupFn: NOOP_CLEANUP_FN,
+    };
+})();
+
+function setAlternateWeakRefImpl(impl) {
+    // TODO: remove this function
 }
-(() => { (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(ApplicationModule, [{
-        type: NgModule
-    }], () => [{ type: ApplicationRef }], null); })();
 
 /**
  * A collection that tracks all serialized views (`ngh` DOM annotations)
@@ -33868,166 +34603,6 @@ function ɵɵngDeclarePipe(decl) {
 // clang-format off
 // clang-format on
 
-/**
- * Not public API, which guarantees `EffectScheduler` only ever comes from the application root
- * injector.
- */
-const APP_EFFECT_SCHEDULER = new InjectionToken('', {
-    providedIn: 'root',
-    factory: () => inject(EffectScheduler),
-});
-/**
- * A scheduler which manages the execution of effects.
- */
-class EffectScheduler {
-    /** @nocollapse */
-    static { this.ɵprov = ɵɵdefineInjectable({
-        token: EffectScheduler,
-        providedIn: 'root',
-        factory: () => new ZoneAwareMicrotaskScheduler(),
-    }); }
-}
-/**
- * An `EffectScheduler` which is capable of queueing scheduled effects per-zone, and flushing them
- * as an explicit operation.
- */
-class ZoneAwareQueueingScheduler {
-    constructor() {
-        this.queuedEffectCount = 0;
-        this.queues = new Map();
-    }
-    scheduleEffect(handle) {
-        const zone = handle.creationZone;
-        if (!this.queues.has(zone)) {
-            this.queues.set(zone, new Set());
-        }
-        const queue = this.queues.get(zone);
-        if (queue.has(handle)) {
-            return;
-        }
-        this.queuedEffectCount++;
-        queue.add(handle);
-    }
-    /**
-     * Run all scheduled effects.
-     *
-     * Execution order of effects within the same zone is guaranteed to be FIFO, but there is no
-     * ordering guarantee between effects scheduled in different zones.
-     */
-    flush() {
-        while (this.queuedEffectCount > 0) {
-            for (const [zone, queue] of this.queues) {
-                // `zone` here must be defined.
-                if (zone === null) {
-                    this.flushQueue(queue);
-                }
-                else {
-                    zone.run(() => this.flushQueue(queue));
-                }
-            }
-        }
-    }
-    flushQueue(queue) {
-        for (const handle of queue) {
-            queue.delete(handle);
-            this.queuedEffectCount--;
-            // TODO: what happens if this throws an error?
-            handle.run();
-        }
-    }
-    /** @nocollapse */
-    static { this.ɵprov = ɵɵdefineInjectable({
-        token: ZoneAwareQueueingScheduler,
-        providedIn: 'root',
-        factory: () => new ZoneAwareQueueingScheduler(),
-    }); }
-}
-/**
- * A wrapper around `ZoneAwareQueueingScheduler` that schedules flushing via the microtask queue
- * when.
- */
-class ZoneAwareMicrotaskScheduler {
-    constructor() {
-        this.hasQueuedFlush = false;
-        this.delegate = new ZoneAwareQueueingScheduler();
-        this.flushTask = () => {
-            // Leave `hasQueuedFlush` as `true` so we don't queue another microtask if more effects are
-            // scheduled during flushing. The flush of the `ZoneAwareQueueingScheduler` delegate is
-            // guaranteed to empty the queue.
-            this.delegate.flush();
-            this.hasQueuedFlush = false;
-            // This is a variable initialization, not a method.
-            // tslint:disable-next-line:semicolon
-        };
-    }
-    scheduleEffect(handle) {
-        this.delegate.scheduleEffect(handle);
-        if (!this.hasQueuedFlush) {
-            queueMicrotask(this.flushTask);
-            this.hasQueuedFlush = true;
-        }
-    }
-}
-/**
- * Core reactive node for an Angular effect.
- *
- * `EffectHandle` combines the reactive graph's `Watch` base node for effects with the framework's
- * scheduling abstraction (`EffectScheduler`) as well as automatic cleanup via `DestroyRef` if
- * available/requested.
- */
-class EffectHandle {
-    constructor(scheduler, effectFn, creationZone, destroyRef, errorHandler, allowSignalWrites) {
-        this.scheduler = scheduler;
-        this.effectFn = effectFn;
-        this.creationZone = creationZone;
-        this.errorHandler = errorHandler;
-        this.watcher =
-            watch((onCleanup) => this.runEffect(onCleanup), () => this.schedule(), allowSignalWrites);
-        this.unregisterOnDestroy = destroyRef?.onDestroy(() => this.destroy());
-    }
-    runEffect(onCleanup) {
-        try {
-            this.effectFn(onCleanup);
-        }
-        catch (err) {
-            this.errorHandler?.handleError(err);
-        }
-    }
-    run() {
-        this.watcher.run();
-    }
-    schedule() {
-        this.scheduler.scheduleEffect(this);
-    }
-    notify() {
-        this.watcher.notify();
-    }
-    destroy() {
-        this.watcher.destroy();
-        this.unregisterOnDestroy?.();
-        // Note: if the effect is currently scheduled, it's not un-scheduled, and so the scheduler will
-        // retain a reference to it. Attempting to execute it will be a no-op.
-    }
-}
-/**
- * Create a global `Effect` for the given reactive function.
- *
- * @developerPreview
- */
-function effect(effectFn, options) {
-    !options?.injector && assertInInjectionContext(effect);
-    const injector = options?.injector ?? inject(Injector);
-    const errorHandler = injector.get(ErrorHandler, null, { optional: true });
-    const destroyRef = options?.manualCleanup !== true ? injector.get(DestroyRef) : null;
-    const handle = new EffectHandle(injector.get(APP_EFFECT_SCHEDULER), effectFn, (typeof Zone === 'undefined') ? null : Zone.current, destroyRef, errorHandler, options?.allowSignalWrites ?? false);
-    // Effects start dirty.
-    handle.notify();
-    return handle;
-}
-
-// 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
 
 /**
@@ -34215,5 +34790,5 @@ if (typeof ngDevMode !== 'undefined' && ngDevMode) {
  * Generated bundle index. Do not edit.
  */
 
-export { ANIMATION_MODULE_TYPE, APP_BOOTSTRAP_LISTENER, APP_ID, APP_INITIALIZER, AfterRenderPhase, ApplicationInitStatus, ApplicationModule, ApplicationRef, Attribute, COMPILER_OPTIONS, CSP_NONCE, CUSTOM_ELEMENTS_SCHEMA, ChangeDetectionStrategy, ChangeDetectorRef, Compiler, CompilerFactory, Component, ComponentFactory$1 as ComponentFactory, ComponentFactoryResolver$1 as ComponentFactoryResolver, ComponentRef$1 as ComponentRef, ContentChild, ContentChildren, DEFAULT_CURRENCY_CODE, DebugElement, DebugEventListener, DebugNode, DefaultIterableDiffer, DestroyRef, Directive, ENVIRONMENT_INITIALIZER, ElementRef, EmbeddedViewRef, EnvironmentInjector, ErrorHandler, EventEmitter, Host, HostBinding, HostListener, INJECTOR, Inject, InjectFlags, Injectable, InjectionToken, Injector, Input, IterableDiffers, KeyValueDiffers, LOCALE_ID, MissingTranslationStrategy, ModuleWithComponentFactories, NO_ERRORS_SCHEMA, NgModule, NgModuleFactory$1 as NgModuleFactory, NgModuleRef$1 as NgModuleRef, NgProbeToken, NgZone, Optional, Output, PACKAGE_ROOT_URL, PLATFORM_ID, PLATFORM_INITIALIZER, Pipe, PlatformRef, Query, QueryList, Renderer2, RendererFactory2, RendererStyleFlags2, Sanitizer, SecurityContext, Self, SimpleChange, SkipSelf, TRANSLATIONS, TRANSLATIONS_FORMAT, TemplateRef, Testability, TestabilityRegistry, TransferState, Type, VERSION, Version, ViewChild, ViewChildren, ViewContainerRef, ViewEncapsulation$1 as ViewEncapsulation, ViewRef, afterNextRender, afterRender, asNativeElements, assertInInjectionContext, assertPlatform, booleanAttribute, computed, createComponent, createEnvironmentInjector, createNgModule, createNgModuleRef, createPlatform, createPlatformFactory, defineInjectable, destroyPlatform, effect, enableProdMode, forwardRef, getDebugNode, getModuleFactory, getNgModuleById, getPlatform, importProvidersFrom, inject, isDevMode, isSignal, isStandalone, makeEnvironmentProviders, makeStateKey, mergeApplicationConfig, numberAttribute, platformCore, provideZoneChangeDetection, reflectComponentType, resolveForwardRef, runInInjectionContext, setTestabilityGetter, signal, untracked, ALLOW_MULTIPLE_PLATFORMS as ɵALLOW_MULTIPLE_PLATFORMS, AfterRenderEventManager as ɵAfterRenderEventManager, CONTAINER_HEADER_OFFSET as ɵCONTAINER_HEADER_OFFSET, ComponentFactory$1 as ɵComponentFactory, Console as ɵConsole, DEFAULT_LOCALE_ID as ɵDEFAULT_LOCALE_ID, DEFER_BLOCK_CONFIG as ɵDEFER_BLOCK_CONFIG, DEFER_BLOCK_DEPENDENCY_INTERCEPTOR as ɵDEFER_BLOCK_DEPENDENCY_INTERCEPTOR, DeferBlockBehavior as ɵDeferBlockBehavior, DeferBlockState as ɵDeferBlockState, ENABLED_SSR_FEATURES as ɵENABLED_SSR_FEATURES, EffectScheduler as ɵEffectScheduler, INJECTOR_SCOPE as ɵINJECTOR_SCOPE, IS_HYDRATION_DOM_REUSE_ENABLED as ɵIS_HYDRATION_DOM_REUSE_ENABLED, InitialRenderPendingTasks as ɵInitialRenderPendingTasks, LContext as ɵLContext, LifecycleHooksFeature as ɵLifecycleHooksFeature, LocaleDataIndex as ɵLocaleDataIndex, NG_COMP_DEF as ɵNG_COMP_DEF, NG_DIR_DEF as ɵNG_DIR_DEF, NG_ELEMENT_ID as ɵNG_ELEMENT_ID, NG_INJ_DEF as ɵNG_INJ_DEF, NG_MOD_DEF as ɵNG_MOD_DEF, NG_PIPE_DEF as ɵNG_PIPE_DEF, NG_PROV_DEF as ɵNG_PROV_DEF, NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR as ɵNOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR, NO_CHANGE as ɵNO_CHANGE, NgModuleFactory as ɵNgModuleFactory, NoopNgZone as ɵNoopNgZone, ReflectionCapabilities as ɵReflectionCapabilities, ComponentFactory as ɵRender3ComponentFactory, ComponentRef as ɵRender3ComponentRef, NgModuleRef as ɵRender3NgModuleRef, RuntimeError as ɵRuntimeError, SSR_CONTENT_INTEGRITY_MARKER as ɵSSR_CONTENT_INTEGRITY_MARKER, TESTABILITY as ɵTESTABILITY, TESTABILITY_GETTER as ɵTESTABILITY_GETTER, USE_RUNTIME_DEPS_TRACKER_FOR_JIT as ɵUSE_RUNTIME_DEPS_TRACKER_FOR_JIT, ViewRef$1 as ɵViewRef, XSS_SECURITY_URL as ɵXSS_SECURITY_URL, ZoneAwareQueueingScheduler as ɵZoneAwareQueueingScheduler, _sanitizeHtml as ɵ_sanitizeHtml, _sanitizeUrl as ɵ_sanitizeUrl, allowSanitizationBypassAndThrow as ɵallowSanitizationBypassAndThrow, annotateForHydration as ɵannotateForHydration, bypassSanitizationTrustHtml as ɵbypassSanitizationTrustHtml, bypassSanitizationTrustResourceUrl as ɵbypassSanitizationTrustResourceUrl, bypassSanitizationTrustScript as ɵbypassSanitizationTrustScript, bypassSanitizationTrustStyle as ɵbypassSanitizationTrustStyle, bypassSanitizationTrustUrl as ɵbypassSanitizationTrustUrl, clearResolutionOfComponentResourcesQueue as ɵclearResolutionOfComponentResourcesQueue, compileComponent as ɵcompileComponent, compileDirective as ɵcompileDirective, compileNgModule as ɵcompileNgModule, compileNgModuleDefs as ɵcompileNgModuleDefs, compileNgModuleFactory as ɵcompileNgModuleFactory, compilePipe as ɵcompilePipe, convertToBitFlags as ɵconvertToBitFlags, createInjector as ɵcreateInjector, defaultIterableDiffers as ɵdefaultIterableDiffers, defaultKeyValueDiffers as ɵdefaultKeyValueDiffers, depsTracker as ɵdepsTracker, detectChanges as ɵdetectChanges, devModeEqual as ɵdevModeEqual, findLocaleData as ɵfindLocaleData, flushModuleScopingQueueAsMuchAsPossible as ɵflushModuleScopingQueueAsMuchAsPossible, formatRuntimeError as ɵformatRuntimeError, generateStandaloneInDeclarationsError as ɵgenerateStandaloneInDeclarationsError, getAsyncClassMetadata as ɵgetAsyncClassMetadata, getDebugNode as ɵgetDebugNode, getDeferBlocks as ɵgetDeferBlocks, getDirectives as ɵgetDirectives, getHostElement as ɵgetHostElement, getInjectableDef as ɵgetInjectableDef, getLContext as ɵgetLContext, getLocaleCurrencyCode as ɵgetLocaleCurrencyCode, getLocalePluralCase as ɵgetLocalePluralCase, getSanitizationBypassType as ɵgetSanitizationBypassType, ɵgetUnknownElementStrictMode, ɵgetUnknownPropertyStrictMode, _global as ɵglobal, injectChangeDetectorRef as ɵinjectChangeDetectorRef, internalCreateApplication as ɵinternalCreateApplication, isBoundToModule as ɵisBoundToModule, isComponentDefPendingResolution as ɵisComponentDefPendingResolution, isEnvironmentProviders as ɵisEnvironmentProviders, isInjectable as ɵisInjectable, isNgModule as ɵisNgModule, isPromise as ɵisPromise, isSubscribable as ɵisSubscribable, noSideEffects as ɵnoSideEffects, patchComponentDefWithScope as ɵpatchComponentDefWithScope, publishDefaultGlobalUtils$1 as ɵpublishDefaultGlobalUtils, publishGlobalUtil as ɵpublishGlobalUtil, registerLocaleData as ɵregisterLocaleData, renderDeferBlockState as ɵrenderDeferBlockState, resetCompiledComponents as ɵresetCompiledComponents, resetJitOptions as ɵresetJitOptions, resolveComponentResources as ɵresolveComponentResources, restoreComponentResolutionQueue as ɵrestoreComponentResolutionQueue, setAllowDuplicateNgModuleIdsForTest as ɵsetAllowDuplicateNgModuleIdsForTest, setAlternateWeakRefImpl as ɵsetAlternateWeakRefImpl, setClassMetadata as ɵsetClassMetadata, setClassMetadataAsync as ɵsetClassMetadataAsync, setCurrentInjector as ɵsetCurrentInjector, setDocument as ɵsetDocument, setInjectorProfilerContext as ɵsetInjectorProfilerContext, setLocaleId as ɵsetLocaleId, ɵsetUnknownElementStrictMode, ɵsetUnknownPropertyStrictMode, store as ɵstore, stringify as ɵstringify, transitiveScopesFor as ɵtransitiveScopesFor, triggerResourceLoading as ɵtriggerResourceLoading, unregisterAllLocaleData as ɵunregisterLocaleData, unwrapSafeValue as ɵunwrapSafeValue, whenStable as ɵwhenStable, withDomHydration as ɵwithDomHydration, ɵɵCopyDefinitionFeature, FactoryTarget as ɵɵFactoryTarget, ɵɵHostDirectivesFeature, ɵɵInheritDefinitionFeature, ɵɵInputTransformsFeature, ɵɵNgOnChangesFeature, ɵɵProvidersFeature, ɵɵStandaloneFeature, ɵɵadvance, ɵɵattribute, ɵɵattributeInterpolate1, ɵɵattributeInterpolate2, ɵɵattributeInterpolate3, ɵɵattributeInterpolate4, ɵɵattributeInterpolate5, ɵɵattributeInterpolate6, ɵɵattributeInterpolate7, ɵɵattributeInterpolate8, ɵɵattributeInterpolateV, ɵɵclassMap, ɵɵclassMapInterpolate1, ɵɵclassMapInterpolate2, ɵɵclassMapInterpolate3, ɵɵclassMapInterpolate4, ɵɵclassMapInterpolate5, ɵɵclassMapInterpolate6, ɵɵclassMapInterpolate7, ɵɵclassMapInterpolate8, ɵɵclassMapInterpolateV, ɵɵclassProp, ɵɵcomponentInstance, ɵɵconditional, ɵɵcontentQuery, ɵɵdefer, ɵɵdeferOnHover, ɵɵdeferOnIdle, ɵɵdeferOnImmediate, ɵɵdeferOnInteraction, ɵɵdeferOnTimer, ɵɵdeferOnViewport, ɵɵdeferPrefetchOnHover, ɵɵdeferPrefetchOnIdle, ɵɵdeferPrefetchOnImmediate, ɵɵdeferPrefetchOnInteraction, ɵɵdeferPrefetchOnTimer, ɵɵdeferPrefetchOnViewport, ɵɵdeferPrefetchWhen, ɵɵdeferWhen, ɵɵdefineComponent, ɵɵdefineDirective, ɵɵdefineInjectable, ɵɵdefineInjector, ɵɵdefineNgModule, ɵɵdefinePipe, ɵɵdirectiveInject, ɵɵdisableBindings, ɵɵelement, ɵɵelementContainer, ɵɵelementContainerEnd, ɵɵelementContainerStart, ɵɵelementEnd, ɵɵelementStart, ɵɵenableBindings, ɵɵgetComponentDepsFactory, ɵɵgetCurrentView, ɵɵgetInheritedFactory, ɵɵhostProperty, ɵɵi18n, ɵɵi18nApply, ɵɵi18nAttributes, ɵɵi18nEnd, ɵɵi18nExp, ɵɵi18nPostprocess, ɵɵi18nStart, ɵɵinject, ɵɵinjectAttribute, ɵɵinvalidFactory, ɵɵinvalidFactoryDep, ɵɵlistener, ɵɵloadQuery, ɵɵnamespaceHTML, ɵɵnamespaceMathML, ɵɵnamespaceSVG, ɵɵnextContext, ɵɵngDeclareClassMetadata, ɵɵngDeclareComponent, ɵɵngDeclareDirective, ɵɵngDeclareFactory, ɵɵngDeclareInjectable, ɵɵngDeclareInjector, ɵɵngDeclareNgModule, ɵɵngDeclarePipe, ɵɵpipe, ɵɵpipeBind1, ɵɵpipeBind2, ɵɵpipeBind3, ɵɵpipeBind4, ɵɵpipeBindV, ɵɵprojection, ɵɵprojectionDef, ɵɵproperty, ɵɵpropertyInterpolate, ɵɵpropertyInterpolate1, ɵɵpropertyInterpolate2, ɵɵpropertyInterpolate3, ɵɵpropertyInterpolate4, ɵɵpropertyInterpolate5, ɵɵpropertyInterpolate6, ɵɵpropertyInterpolate7, ɵɵpropertyInterpolate8, ɵɵpropertyInterpolateV, ɵɵpureFunction0, ɵɵpureFunction1, ɵɵpureFunction2, ɵɵpureFunction3, ɵɵpureFunction4, ɵɵpureFunction5, ɵɵpureFunction6, ɵɵpureFunction7, ɵɵpureFunction8, ɵɵpureFunctionV, ɵɵqueryRefresh, ɵɵreference, registerNgModuleType as ɵɵregisterNgModuleType, ɵɵrepeater, ɵɵrepeaterCreate, ɵɵrepeaterTrackByIdentity, ɵɵrepeaterTrackByIndex, ɵɵresetView, ɵɵresolveBody, ɵɵresolveDocument, ɵɵresolveWindow, ɵɵrestoreView, ɵɵsanitizeHtml, ɵɵsanitizeResourceUrl, ɵɵsanitizeScript, ɵɵsanitizeStyle, ɵɵsanitizeUrl, ɵɵsanitizeUrlOrResourceUrl, ɵɵsetComponentScope, ɵɵsetNgModuleScope, ɵɵstyleMap, ɵɵstyleMapInterpolate1, ɵɵstyleMapInterpolate2, ɵɵstyleMapInterpolate3, ɵɵstyleMapInterpolate4, ɵɵstyleMapInterpolate5, ɵɵstyleMapInterpolate6, ɵɵstyleMapInterpolate7, ɵɵstyleMapInterpolate8, ɵɵstyleMapInterpolateV, ɵɵstyleProp, ɵɵstylePropInterpolate1, ɵɵstylePropInterpolate2, ɵɵstylePropInterpolate3, ɵɵstylePropInterpolate4, ɵɵstylePropInterpolate5, ɵɵstylePropInterpolate6, ɵɵstylePropInterpolate7, ɵɵstylePropInterpolate8, ɵɵstylePropInterpolateV, ɵɵsyntheticHostListener, ɵɵsyntheticHostProperty, ɵɵtemplate, ɵɵtemplateRefExtractor, ɵɵtext, ɵɵtextInterpolate, ɵɵtextInterpolate1, ɵɵtextInterpolate2, ɵɵtextInterpolate3, ɵɵtextInterpolate4, ɵɵtextInterpolate5, ɵɵtextInterpolate6, ɵɵtextInterpolate7, ɵɵtextInterpolate8, ɵɵtextInterpolateV, ɵɵtrustConstantHtml, ɵɵtrustConstantResourceUrl, ɵɵvalidateIframeAttribute, ɵɵviewQuery };
+export { ANIMATION_MODULE_TYPE, APP_BOOTSTRAP_LISTENER, APP_ID, APP_INITIALIZER, AfterRenderPhase, ApplicationInitStatus, ApplicationModule, ApplicationRef, Attribute, COMPILER_OPTIONS, CSP_NONCE, CUSTOM_ELEMENTS_SCHEMA, ChangeDetectionStrategy, ChangeDetectorRef, Compiler, CompilerFactory, Component, ComponentFactory$1 as ComponentFactory, ComponentFactoryResolver$1 as ComponentFactoryResolver, ComponentRef$1 as ComponentRef, ContentChild, ContentChildren, DEFAULT_CURRENCY_CODE, DebugElement, DebugEventListener, DebugNode, DefaultIterableDiffer, DestroyRef, Directive, ENVIRONMENT_INITIALIZER, ElementRef, EmbeddedViewRef, EnvironmentInjector, ErrorHandler, EventEmitter, Host, HostBinding, HostListener, INJECTOR, Inject, InjectFlags, Injectable, InjectionToken, Injector, Input, IterableDiffers, KeyValueDiffers, LOCALE_ID, MissingTranslationStrategy, ModuleWithComponentFactories, NO_ERRORS_SCHEMA, NgModule, NgModuleFactory$1 as NgModuleFactory, NgModuleRef$1 as NgModuleRef, NgProbeToken, NgZone, Optional, Output, PACKAGE_ROOT_URL, PLATFORM_ID, PLATFORM_INITIALIZER, Pipe, PlatformRef, Query, QueryList, Renderer2, RendererFactory2, RendererStyleFlags2, Sanitizer, SecurityContext, Self, SimpleChange, SkipSelf, TRANSLATIONS, TRANSLATIONS_FORMAT, TemplateRef, Testability, TestabilityRegistry, TransferState, Type, VERSION, Version, ViewChild, ViewChildren, ViewContainerRef, ViewEncapsulation$1 as ViewEncapsulation, ViewRef, afterNextRender, afterRender, asNativeElements, assertInInjectionContext, assertNotInReactiveContext, assertPlatform, booleanAttribute, computed, createComponent, createEnvironmentInjector, createNgModule, createNgModuleRef, createPlatform, createPlatformFactory, defineInjectable, destroyPlatform, effect, enableProdMode, forwardRef, getDebugNode, getModuleFactory, getNgModuleById, getPlatform, importProvidersFrom, inject, isDevMode, isSignal, isStandalone, makeEnvironmentProviders, makeStateKey, mergeApplicationConfig, numberAttribute, platformCore, provideZoneChangeDetection, reflectComponentType, resolveForwardRef, runInInjectionContext, setTestabilityGetter, signal, untracked, ALLOW_MULTIPLE_PLATFORMS as ɵALLOW_MULTIPLE_PLATFORMS, AfterRenderEventManager as ɵAfterRenderEventManager, CONTAINER_HEADER_OFFSET as ɵCONTAINER_HEADER_OFFSET, ComponentFactory$1 as ɵComponentFactory, Console as ɵConsole, DEFAULT_LOCALE_ID as ɵDEFAULT_LOCALE_ID, DEFER_BLOCK_CONFIG as ɵDEFER_BLOCK_CONFIG, DEFER_BLOCK_DEPENDENCY_INTERCEPTOR as ɵDEFER_BLOCK_DEPENDENCY_INTERCEPTOR, DeferBlockBehavior as ɵDeferBlockBehavior, DeferBlockState as ɵDeferBlockState, ENABLED_SSR_FEATURES as ɵENABLED_SSR_FEATURES, EffectScheduler as ɵEffectScheduler, IMAGE_CONFIG as ɵIMAGE_CONFIG, IMAGE_CONFIG_DEFAULTS as ɵIMAGE_CONFIG_DEFAULTS, INJECTOR_SCOPE as ɵINJECTOR_SCOPE, IS_HYDRATION_DOM_REUSE_ENABLED as ɵIS_HYDRATION_DOM_REUSE_ENABLED, InitialRenderPendingTasks as ɵInitialRenderPendingTasks, LContext as ɵLContext, LifecycleHooksFeature as ɵLifecycleHooksFeature, LocaleDataIndex as ɵLocaleDataIndex, NG_COMP_DEF as ɵNG_COMP_DEF, NG_DIR_DEF as ɵNG_DIR_DEF, NG_ELEMENT_ID as ɵNG_ELEMENT_ID, NG_INJ_DEF as ɵNG_INJ_DEF, NG_MOD_DEF as ɵNG_MOD_DEF, NG_PIPE_DEF as ɵNG_PIPE_DEF, NG_PROV_DEF as ɵNG_PROV_DEF, NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR as ɵNOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR, NO_CHANGE as ɵNO_CHANGE, NgModuleFactory as ɵNgModuleFactory, NoopNgZone as ɵNoopNgZone, ReflectionCapabilities as ɵReflectionCapabilities, ComponentFactory as ɵRender3ComponentFactory, ComponentRef as ɵRender3ComponentRef, NgModuleRef as ɵRender3NgModuleRef, RuntimeError as ɵRuntimeError, SSR_CONTENT_INTEGRITY_MARKER as ɵSSR_CONTENT_INTEGRITY_MARKER, TESTABILITY as ɵTESTABILITY, TESTABILITY_GETTER as ɵTESTABILITY_GETTER, USE_RUNTIME_DEPS_TRACKER_FOR_JIT as ɵUSE_RUNTIME_DEPS_TRACKER_FOR_JIT, ViewRef$1 as ɵViewRef, XSS_SECURITY_URL as ɵXSS_SECURITY_URL, ZoneAwareQueueingScheduler as ɵZoneAwareQueueingScheduler, _sanitizeHtml as ɵ_sanitizeHtml, _sanitizeUrl as ɵ_sanitizeUrl, allowSanitizationBypassAndThrow as ɵallowSanitizationBypassAndThrow, annotateForHydration as ɵannotateForHydration, bypassSanitizationTrustHtml as ɵbypassSanitizationTrustHtml, bypassSanitizationTrustResourceUrl as ɵbypassSanitizationTrustResourceUrl, bypassSanitizationTrustScript as ɵbypassSanitizationTrustScript, bypassSanitizationTrustStyle as ɵbypassSanitizationTrustStyle, bypassSanitizationTrustUrl as ɵbypassSanitizationTrustUrl, clearResolutionOfComponentResourcesQueue as ɵclearResolutionOfComponentResourcesQueue, compileComponent as ɵcompileComponent, compileDirective as ɵcompileDirective, compileNgModule as ɵcompileNgModule, compileNgModuleDefs as ɵcompileNgModuleDefs, compileNgModuleFactory as ɵcompileNgModuleFactory, compilePipe as ɵcompilePipe, convertToBitFlags as ɵconvertToBitFlags, createInjector as ɵcreateInjector, defaultIterableDiffers as ɵdefaultIterableDiffers, defaultKeyValueDiffers as ɵdefaultKeyValueDiffers, depsTracker as ɵdepsTracker, detectChanges as ɵdetectChanges, devModeEqual as ɵdevModeEqual, findLocaleData as ɵfindLocaleData, flushModuleScopingQueueAsMuchAsPossible as ɵflushModuleScopingQueueAsMuchAsPossible, formatRuntimeError as ɵformatRuntimeError, generateStandaloneInDeclarationsError as ɵgenerateStandaloneInDeclarationsError, getAsyncClassMetadata as ɵgetAsyncClassMetadata, getDebugNode as ɵgetDebugNode, getDeferBlocks as ɵgetDeferBlocks, getDirectives as ɵgetDirectives, getHostElement as ɵgetHostElement, getInjectableDef as ɵgetInjectableDef, getLContext as ɵgetLContext, getLocaleCurrencyCode as ɵgetLocaleCurrencyCode, getLocalePluralCase as ɵgetLocalePluralCase, getSanitizationBypassType as ɵgetSanitizationBypassType, ɵgetUnknownElementStrictMode, ɵgetUnknownPropertyStrictMode, _global as ɵglobal, injectChangeDetectorRef as ɵinjectChangeDetectorRef, internalCreateApplication as ɵinternalCreateApplication, isBoundToModule as ɵisBoundToModule, isComponentDefPendingResolution as ɵisComponentDefPendingResolution, isEnvironmentProviders as ɵisEnvironmentProviders, isInjectable as ɵisInjectable, isNgModule as ɵisNgModule, isPromise as ɵisPromise, isSubscribable as ɵisSubscribable, noSideEffects as ɵnoSideEffects, patchComponentDefWithScope as ɵpatchComponentDefWithScope, publishDefaultGlobalUtils$1 as ɵpublishDefaultGlobalUtils, publishGlobalUtil as ɵpublishGlobalUtil, registerLocaleData as ɵregisterLocaleData, renderDeferBlockState as ɵrenderDeferBlockState, resetCompiledComponents as ɵresetCompiledComponents, resetJitOptions as ɵresetJitOptions, resolveComponentResources as ɵresolveComponentResources, restoreComponentResolutionQueue as ɵrestoreComponentResolutionQueue, setAllowDuplicateNgModuleIdsForTest as ɵsetAllowDuplicateNgModuleIdsForTest, setAlternateWeakRefImpl as ɵsetAlternateWeakRefImpl, ɵsetClassDebugInfo, setClassMetadata as ɵsetClassMetadata, setClassMetadataAsync as ɵsetClassMetadataAsync, setCurrentInjector as ɵsetCurrentInjector, setDocument as ɵsetDocument, setInjectorProfilerContext as ɵsetInjectorProfilerContext, setLocaleId as ɵsetLocaleId, ɵsetUnknownElementStrictMode, ɵsetUnknownPropertyStrictMode, store as ɵstore, stringify as ɵstringify, transitiveScopesFor as ɵtransitiveScopesFor, triggerResourceLoading as ɵtriggerResourceLoading, truncateMiddle as ɵtruncateMiddle, unregisterAllLocaleData as ɵunregisterLocaleData, unwrapSafeValue as ɵunwrapSafeValue, whenStable as ɵwhenStable, withDomHydration as ɵwithDomHydration, ɵɵCopyDefinitionFeature, FactoryTarget as ɵɵFactoryTarget, ɵɵHostDirectivesFeature, ɵɵInheritDefinitionFeature, ɵɵInputTransformsFeature, ɵɵNgOnChangesFeature, ɵɵProvidersFeature, ɵɵStandaloneFeature, ɵɵadvance, ɵɵattribute, ɵɵattributeInterpolate1, ɵɵattributeInterpolate2, ɵɵattributeInterpolate3, ɵɵattributeInterpolate4, ɵɵattributeInterpolate5, ɵɵattributeInterpolate6, ɵɵattributeInterpolate7, ɵɵattributeInterpolate8, ɵɵattributeInterpolateV, ɵɵclassMap, ɵɵclassMapInterpolate1, ɵɵclassMapInterpolate2, ɵɵclassMapInterpolate3, ɵɵclassMapInterpolate4, ɵɵclassMapInterpolate5, ɵɵclassMapInterpolate6, ɵɵclassMapInterpolate7, ɵɵclassMapInterpolate8, ɵɵclassMapInterpolateV, ɵɵclassProp, ɵɵcomponentInstance, ɵɵconditional, ɵɵcontentQuery, ɵɵdefer, ɵɵdeferEnableTimerScheduling, ɵɵdeferOnHover, ɵɵdeferOnIdle, ɵɵdeferOnImmediate, ɵɵdeferOnInteraction, ɵɵdeferOnTimer, ɵɵdeferOnViewport, ɵɵdeferPrefetchOnHover, ɵɵdeferPrefetchOnIdle, ɵɵdeferPrefetchOnImmediate, ɵɵdeferPrefetchOnInteraction, ɵɵdeferPrefetchOnTimer, ɵɵdeferPrefetchOnViewport, ɵɵdeferPrefetchWhen, ɵɵdeferWhen, ɵɵdefineComponent, ɵɵdefineDirective, ɵɵdefineInjectable, ɵɵdefineInjector, ɵɵdefineNgModule, ɵɵdefinePipe, ɵɵdirectiveInject, ɵɵdisableBindings, ɵɵelement, ɵɵelementContainer, ɵɵelementContainerEnd, ɵɵelementContainerStart, ɵɵelementEnd, ɵɵelementStart, ɵɵenableBindings, ɵɵgetComponentDepsFactory, ɵɵgetCurrentView, ɵɵgetInheritedFactory, ɵɵhostProperty, ɵɵi18n, ɵɵi18nApply, ɵɵi18nAttributes, ɵɵi18nEnd, ɵɵi18nExp, ɵɵi18nPostprocess, ɵɵi18nStart, ɵɵinject, ɵɵinjectAttribute, ɵɵinvalidFactory, ɵɵinvalidFactoryDep, ɵɵlistener, ɵɵloadQuery, ɵɵnamespaceHTML, ɵɵnamespaceMathML, ɵɵnamespaceSVG, ɵɵnextContext, ɵɵngDeclareClassMetadata, ɵɵngDeclareComponent, ɵɵngDeclareDirective, ɵɵngDeclareFactory, ɵɵngDeclareInjectable, ɵɵngDeclareInjector, ɵɵngDeclareNgModule, ɵɵngDeclarePipe, ɵɵpipe, ɵɵpipeBind1, ɵɵpipeBind2, ɵɵpipeBind3, ɵɵpipeBind4, ɵɵpipeBindV, ɵɵprojection, ɵɵprojectionDef, ɵɵproperty, ɵɵpropertyInterpolate, ɵɵpropertyInterpolate1, ɵɵpropertyInterpolate2, ɵɵpropertyInterpolate3, ɵɵpropertyInterpolate4, ɵɵpropertyInterpolate5, ɵɵpropertyInterpolate6, ɵɵpropertyInterpolate7, ɵɵpropertyInterpolate8, ɵɵpropertyInterpolateV, ɵɵpureFunction0, ɵɵpureFunction1, ɵɵpureFunction2, ɵɵpureFunction3, ɵɵpureFunction4, ɵɵpureFunction5, ɵɵpureFunction6, ɵɵpureFunction7, ɵɵpureFunction8, ɵɵpureFunctionV, ɵɵqueryRefresh, ɵɵreference, registerNgModuleType as ɵɵregisterNgModuleType, ɵɵrepeater, ɵɵrepeaterCreate, ɵɵrepeaterTrackByIdentity, ɵɵrepeaterTrackByIndex, ɵɵresetView, ɵɵresolveBody, ɵɵresolveDocument, ɵɵresolveWindow, ɵɵrestoreView, ɵɵsanitizeHtml, ɵɵsanitizeResourceUrl, ɵɵsanitizeScript, ɵɵsanitizeStyle, ɵɵsanitizeUrl, ɵɵsanitizeUrlOrResourceUrl, ɵɵsetComponentScope, ɵɵsetNgModuleScope, ɵɵstyleMap, ɵɵstyleMapInterpolate1, ɵɵstyleMapInterpolate2, ɵɵstyleMapInterpolate3, ɵɵstyleMapInterpolate4, ɵɵstyleMapInterpolate5, ɵɵstyleMapInterpolate6, ɵɵstyleMapInterpolate7, ɵɵstyleMapInterpolate8, ɵɵstyleMapInterpolateV, ɵɵstyleProp, ɵɵstylePropInterpolate1, ɵɵstylePropInterpolate2, ɵɵstylePropInterpolate3, ɵɵstylePropInterpolate4, ɵɵstylePropInterpolate5, ɵɵstylePropInterpolate6, ɵɵstylePropInterpolate7, ɵɵstylePropInterpolate8, ɵɵstylePropInterpolateV, ɵɵsyntheticHostListener, ɵɵsyntheticHostProperty, ɵɵtemplate, ɵɵtemplateRefExtractor, ɵɵtext, ɵɵtextInterpolate, ɵɵtextInterpolate1, ɵɵtextInterpolate2, ɵɵtextInterpolate3, ɵɵtextInterpolate4, ɵɵtextInterpolate5, ɵɵtextInterpolate6, ɵɵtextInterpolate7, ɵɵtextInterpolate8, ɵɵtextInterpolateV, ɵɵtrustConstantHtml, ɵɵtrustConstantResourceUrl, ɵɵvalidateIframeAttribute, ɵɵviewQuery };
 //# sourceMappingURL=core.mjs.map