@angular/core 17.1.0-next.4 → 17.1.0-rc.0

package/fesm2022/core.mjs

@@ -1,20 +1,118 @@
 /**
- * @license Angular v17.1.0-next.4
+ * @license Angular v17.1.0-rc.0
  * (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, REACTIVE_NODE as REACTIVE_NODE$1, consumerBeforeComputation as consumerBeforeComputation$1, consumerAfterComputation as consumerAfterComputation$1, consumerPollProducersForChange as consumerPollProducersForChange$1, getActiveConsumer as getActiveConsumer$1, createWatch as createWatch$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';
+import { SIGNAL_NODE as SIGNAL_NODE$1, signalSetFn as signalSetFn$1, producerAccessed as producerAccessed$1, SIGNAL as SIGNAL$1, setActiveConsumer as setActiveConsumer$1, consumerDestroy as consumerDestroy$1, createComputed as createComputed$1, createSignal as createSignal$1, signalUpdateFn as signalUpdateFn$1, REACTIVE_NODE as REACTIVE_NODE$1, consumerBeforeComputation as consumerBeforeComputation$1, consumerAfterComputation as consumerAfterComputation$1, consumerPollProducersForChange as consumerPollProducersForChange$1, getActiveConsumer as getActiveConsumer$1, createWatch as createWatch$1, setThrowInvalidWriteToSignalError as setThrowInvalidWriteToSignalError$1 } from '@angular/core/primitives/signals';
+import { Subject, Subscription, BehaviorSubject } from 'rxjs';
+import { map, first } from 'rxjs/operators';
 
-function inputFunction(_initialValue, _opts) {
-    throw new Error('TODO');
+/**
+ * Base URL for the error details page.
+ *
+ * Keep this constant in sync across:
+ *  - packages/compiler-cli/src/ngtsc/diagnostics/src/error_details_base_url.ts
+ *  - packages/core/src/error_details_base_url.ts
+ */
+const ERROR_DETAILS_PAGE_BASE_URL = 'https://angular.io/errors';
+/**
+ * URL for the XSS security documentation.
+ */
+const XSS_SECURITY_URL = 'https://g.co/ng/security#xss';
+
+/**
+ * Class that represents a runtime error.
+ * Formats and outputs the error message in a consistent way.
+ *
+ * Example:
+ * ```
+ *  throw new RuntimeError(
+ *    RuntimeErrorCode.INJECTOR_ALREADY_DESTROYED,
+ *    ngDevMode && 'Injector has already been destroyed.');
+ * ```
+ *
+ * Note: the `message` argument contains a descriptive error message as a string in development
+ * mode (when the `ngDevMode` is defined). In production mode (after tree-shaking pass), the
+ * `message` argument becomes `false`, thus we account for it in the typings and the runtime
+ * logic.
+ */
+class RuntimeError extends Error {
+    constructor(code, message) {
+        super(formatRuntimeError(code, message));
+        this.code = code;
+    }
+}
+/**
+ * Called to format a runtime error.
+ * See additional info on the `message` argument type in the `RuntimeError` class description.
+ */
+function formatRuntimeError(code, message) {
+    // Error code might be a negative number, which is a special marker that instructs the logic to
+    // generate a link to the error details page on angular.io.
+    // We also prepend `0` to non-compile-time errors.
+    const fullCode = `NG0${Math.abs(code)}`;
+    let errorMessage = `${fullCode}${message ? ': ' + message : ''}`;
+    if (ngDevMode && code < 0) {
+        const addPeriodSeparator = !errorMessage.match(/[.,;!?\n]$/);
+        const separator = addPeriodSeparator ? '.' : '';
+        errorMessage =
+            `${errorMessage}${separator} Find more at ${ERROR_DETAILS_PAGE_BASE_URL}/${fullCode}`;
+    }
+    return errorMessage;
+}
+
+const REQUIRED_UNSET_VALUE = /* @__PURE__ */ Symbol('InputSignalNode#UNSET');
+// 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 INPUT_SIGNAL_NODE = /* @__PURE__ */ (() => {
+    return {
+        ...SIGNAL_NODE$1,
+        transformFn: undefined,
+        applyValueToInputSignal(node, value) {
+            signalSetFn$1(node, value);
+        }
+    };
+})();
+
+const ɵINPUT_SIGNAL_BRAND_READ_TYPE = /* @__PURE__ */ Symbol();
+const ɵINPUT_SIGNAL_BRAND_WRITE_TYPE = /* @__PURE__ */ Symbol();
+/**
+ * Creates an input signal.
+ *
+ * @param initialValue The initial value.
+ *   Can be set to {@link REQUIRED_UNSET_VALUE} for required inputs.
+ * @param options Additional options for the input. e.g. a transform, or an alias.
+ */
+function createInputSignal(initialValue, options) {
+    const node = Object.create(INPUT_SIGNAL_NODE);
+    node.value = initialValue;
+    // Perf note: Always set `transformFn` here to ensure that `node` always
+    // has the same v8 class shape, allowing monomorphic reads on input signals.
+    node.transformFn = options?.transform;
+    function inputValueFn() {
+        // Record that someone looked at this signal.
+        producerAccessed$1(node);
+        if (node.value === REQUIRED_UNSET_VALUE) {
+            throw new RuntimeError(-950 /* RuntimeErrorCode.REQUIRED_INPUT_NO_VALUE */, ngDevMode && 'Input is required but no value is available yet.');
+        }
+        return node.value;
+    }
+    inputValueFn[SIGNAL$1] = node;
+    return inputValueFn;
+}
+
+function inputFunction(initialValue, opts) {
+    return createInputSignal(initialValue, opts);
 }
-function inputRequiredFunction(_opts) {
-    throw new Error('TODO');
+function inputRequiredFunction(opts) {
+    return createInputSignal(REQUIRED_UNSET_VALUE, opts);
 }
 /**
+ * The `input` function allows declaration of inputs in directives and
+ * components.
+ *
  * Initializes an input with an initial value. If no explicit value
  * is specified, Angular will use `undefined`.
  *
@@ -33,6 +131,8 @@ function inputRequiredFunction(_opts) {
  *   age = input(0);                         // number
  * }
  * ```
+ *
+ * @developerPreview
  */
 const input = (() => {
     // Note: This may be considered a side-effect, but nothing will depend on
@@ -42,11 +142,6 @@ const input = (() => {
     return inputFunction;
 })();
 
-const ɵINPUT_SIGNAL_BRAND_READ_TYPE = /* @__PURE__ */ Symbol();
-const ɵINPUT_SIGNAL_BRAND_WRITE_TYPE = /* @__PURE__ */ Symbol();
-
-// Note: `input` is exported in `core.ts` due to:
-
 function getClosureSafeProperty(objWithPropertyToExtract) {
     for (let key in objWithPropertyToExtract) {
         if (objWithPropertyToExtract[key] === getClosureSafeProperty) {
@@ -194,60 +289,6 @@ function isEnvironmentProviders(value) {
     return value && !!value.ɵproviders;
 }
 
-/**
- * Base URL for the error details page.
- *
- * Keep this constant in sync across:
- *  - packages/compiler-cli/src/ngtsc/diagnostics/src/error_details_base_url.ts
- *  - packages/core/src/error_details_base_url.ts
- */
-const ERROR_DETAILS_PAGE_BASE_URL = 'https://angular.io/errors';
-/**
- * URL for the XSS security documentation.
- */
-const XSS_SECURITY_URL = 'https://g.co/ng/security#xss';
-
-/**
- * Class that represents a runtime error.
- * Formats and outputs the error message in a consistent way.
- *
- * Example:
- * ```
- *  throw new RuntimeError(
- *    RuntimeErrorCode.INJECTOR_ALREADY_DESTROYED,
- *    ngDevMode && 'Injector has already been destroyed.');
- * ```
- *
- * Note: the `message` argument contains a descriptive error message as a string in development
- * mode (when the `ngDevMode` is defined). In production mode (after tree-shaking pass), the
- * `message` argument becomes `false`, thus we account for it in the typings and the runtime
- * logic.
- */
-class RuntimeError extends Error {
-    constructor(code, message) {
-        super(formatRuntimeError(code, message));
-        this.code = code;
-    }
-}
-/**
- * Called to format a runtime error.
- * See additional info on the `message` argument type in the `RuntimeError` class description.
- */
-function formatRuntimeError(code, message) {
-    // Error code might be a negative number, which is a special marker that instructs the logic to
-    // generate a link to the error details page on angular.io.
-    // We also prepend `0` to non-compile-time errors.
-    const fullCode = `NG0${Math.abs(code)}`;
-    let errorMessage = `${fullCode}${message ? ': ' + message : ''}`;
-    if (ngDevMode && code < 0) {
-        const addPeriodSeparator = !errorMessage.match(/[.,;!?\n]$/);
-        const separator = addPeriodSeparator ? '.' : '';
-        errorMessage =
-            `${errorMessage}${separator} Find more at ${ERROR_DETAILS_PAGE_BASE_URL}/${fullCode}`;
-    }
-    return errorMessage;
-}
-
 const NG_COMP_DEF = getClosureSafeProperty({ ɵcmp: getClosureSafeProperty });
 const NG_DIR_DEF = getClosureSafeProperty({ ɵdir: getClosureSafeProperty });
 const NG_PIPE_DEF = getClosureSafeProperty({ ɵpipe: getClosureSafeProperty });
@@ -352,8 +393,9 @@ function throwInvalidProviderError(ngModuleType, providers, provider) {
 }
 /** Throws an error when a token is not found in DI. */
 function throwProviderNotFoundError(token, injectorName) {
-    const injectorDetails = injectorName ? ` in ${injectorName}` : '';
-    throw new RuntimeError(-201 /* RuntimeErrorCode.PROVIDER_NOT_FOUND */, ngDevMode && `No provider for ${stringifyForError(token)} found${injectorDetails}`);
+    const errorMessage = ngDevMode &&
+        `No provider for ${stringifyForError(token)} found${injectorName ? ` in ${injectorName}` : ''}`;
+    throw new RuntimeError(-201 /* RuntimeErrorCode.PROVIDER_NOT_FOUND */, errorMessage);
 }
 
 // The functions in this file verify that the assumptions we are making
@@ -624,7 +666,7 @@ function injectRootLimpMode(token, notFoundValue, flags) {
         return null;
     if (notFoundValue !== undefined)
         return notFoundValue;
-    throwProviderNotFoundError(stringify(token), 'Injector');
+    throwProviderNotFoundError(token, 'Injector');
 }
 /**
  * Assert that `_injectImplementation` is not `fn`.
@@ -1234,6 +1276,14 @@ if ((typeof ngDevMode === 'undefined' || ngDevMode) && initNgDevMode()) {
     Object.freeze(EMPTY_ARRAY);
 }
 
+/** Flags describing an input for a directive. */
+var InputFlags;
+(function (InputFlags) {
+    InputFlags[InputFlags["None"] = 0] = "None";
+    InputFlags[InputFlags["SignalBased"] = 1] = "SignalBased";
+    InputFlags[InputFlags["HasDecoratorInputTransform"] = 2] = "HasDecoratorInputTransform";
+})(InputFlags || (InputFlags = {}));
+
 /**
  * Returns an index of `classToSearch` in `className` taking token boundaries into account.
  *
@@ -1955,76 +2005,34 @@ function ɵɵdefineNgModule(def) {
         return res;
     });
 }
-/**
- * Inverts an inputs or outputs lookup such that the keys, which were the
- * minified keys, are part of the values, and the values are parsed so that
- * the publicName of the property is the new key
- *
- * e.g. for
- *
- * ```
- * class Comp {
- *   @Input()
- *   propName1: string;
- *
- *   @Input('publicName2')
- *   declaredPropName2: number;
- * }
- * ```
- *
- * will be serialized as
- *
- * ```
- * {
- *   propName1: 'propName1',
- *   declaredPropName2: ['publicName2', 'declaredPropName2'],
- * }
- * ```
- *
- * which is than translated by the minifier as:
- *
- * ```
- * {
- *   minifiedPropName1: 'propName1',
- *   minifiedPropName2: ['publicName2', 'declaredPropName2'],
- * }
- * ```
- *
- * becomes: (public name => minifiedName)
- *
- * ```
- * {
- *  'propName1': 'minifiedPropName1',
- *  'publicName2': 'minifiedPropName2',
- * }
- * ```
- *
- * Optionally the function can take `secondary` which will result in: (public name => declared name)
- *
- * ```
- * {
- *  'propName1': 'propName1',
- *  'publicName2': 'declaredPropName2',
- * }
- * ```
- *
-
- */
-function invertObject(obj, secondary) {
+function parseAndConvertBindingsForDefinition(obj, declaredInputs) {
     if (obj == null)
         return EMPTY_OBJ;
     const newLookup = {};
     for (const minifiedKey in obj) {
         if (obj.hasOwnProperty(minifiedKey)) {
-            let publicName = obj[minifiedKey];
-            let declaredName = publicName;
-            if (Array.isArray(publicName)) {
-                declaredName = publicName[1];
-                publicName = publicName[0];
+            const value = obj[minifiedKey];
+            let publicName;
+            let declaredName;
+            let inputFlags = InputFlags.None;
+            if (Array.isArray(value)) {
+                inputFlags = value[0];
+                publicName = value[1];
+                declaredName = value[2] ?? publicName; // declared name might not be set to save bytes.
             }
-            newLookup[publicName] = minifiedKey;
-            if (secondary) {
-                (secondary[publicName] = declaredName);
+            else {
+                publicName = value;
+                declaredName = value;
+            }
+            // For inputs, capture the declared name, or if some flags are set.
+            if (declaredInputs) {
+                // Perf note: An array is only allocated for the input if there are flags.
+                newLookup[publicName] =
+                    inputFlags !== InputFlags.None ? [minifiedKey, inputFlags] : minifiedKey;
+                declaredInputs[publicName] = declaredName;
+            }
+            else {
+                newLookup[publicName] = minifiedKey;
             }
         }
     }
@@ -2122,7 +2130,7 @@ function getNgDirectiveDef(directiveDefinition) {
         hostVars: directiveDefinition.hostVars || 0,
         hostAttrs: directiveDefinition.hostAttrs || null,
         contentQueries: directiveDefinition.contentQueries || null,
-        declaredInputs,
+        declaredInputs: declaredInputs,
         inputTransforms: null,
         inputConfig: directiveDefinition.inputs || EMPTY_OBJ,
         exportAs: directiveDefinition.exportAs || null,
@@ -2134,8 +2142,8 @@ function getNgDirectiveDef(directiveDefinition) {
         setInput: null,
         findHostDirectiveDefs: null,
         hostDirectives: null,
-        inputs: invertObject(directiveDefinition.inputs, declaredInputs),
-        outputs: invertObject(directiveDefinition.outputs),
+        inputs: parseAndConvertBindingsForDefinition(directiveDefinition.inputs, declaredInputs),
+        outputs: parseAndConvertBindingsForDefinition(directiveDefinition.outputs),
         debugInfo: null,
     };
 }
@@ -2286,11 +2294,6 @@ var LContainerFlags;
      * This flag, once set, is never unset for the `LContainer`.
      */
     LContainerFlags[LContainerFlags["HasTransplantedViews"] = 2] = "HasTransplantedViews";
-    /**
-     * Indicates that this LContainer has a view underneath it that needs to be refreshed during
-     * change detection.
-     */
-    LContainerFlags[LContainerFlags["HasChildViewsToRefresh"] = 4] = "HasChildViewsToRefresh";
 })(LContainerFlags || (LContainerFlags = {}));
 
 /**
@@ -2488,6 +2491,15 @@ class SimpleChange {
     }
 }
 
+function applyValueToInputField(instance, inputSignalNode, privateName, value) {
+    if (inputSignalNode !== null) {
+        inputSignalNode.applyValueToInputSignal(inputSignalNode, value);
+    }
+    else {
+        instance[privateName] = value;
+    }
+}
+
 /**
  * The NgOnChangesFeature decorates a component with support for the ngOnChanges
  * lifecycle hook, so it should be included in any component that implements
@@ -2553,7 +2565,7 @@ function rememberChangeHistoryAndInvokeOnChangesHook() {
         this.ngOnChanges(current);
     }
 }
-function ngOnChangesSetInput(instance, value, publicName, privateName) {
+function ngOnChangesSetInput(instance, inputSignalNode, 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) ||
@@ -2562,7 +2574,7 @@ function ngOnChangesSetInput(instance, value, publicName, privateName) {
     const previous = simpleChangesStore.previous;
     const previousChange = previous[declaredName];
     current[declaredName] = new SimpleChange(previousChange && previousChange.currentValue, value, previous === EMPTY_OBJ);
-    instance[privateName] = value;
+    applyValueToInputField(instance, inputSignalNode, privateName, value);
 }
 const SIMPLE_CHANGES_STORE = '__ngSimpleChanges__';
 function getSimpleChangesStore(instance) {
@@ -2604,6 +2616,15 @@ const profiler = function (event, instance, hookOrListener) {
 const SVG_NAMESPACE = 'svg';
 const MATH_ML_NAMESPACE = 'math';
 
+// TODO(atscott): flip default internally ASAP and externally for v18 (#52928)
+let _ensureDirtyViewsAreAlwaysReachable = false;
+function getEnsureDirtyViewsAreAlwaysReachable() {
+    return _ensureDirtyViewsAreAlwaysReachable;
+}
+function setEnsureDirtyViewsAreAlwaysReachable(v) {
+    _ensureDirtyViewsAreAlwaysReachable = v;
+}
+
 /**
  * For efficiency reasons we often put several different data types (`RNode`, `LView`, `LContainer`)
  * in same location in `LView`. This is because we don't want to pre-allocate space for it
@@ -2770,10 +2791,21 @@ function requiresRefreshOrTraversal(lView) {
  * parents above.
  */
 function updateAncestorTraversalFlagsOnAttach(lView) {
-    if (!requiresRefreshOrTraversal(lView)) {
-        return;
+    // TODO(atscott): Simplify if...else cases once getEnsureDirtyViewsAreAlwaysReachable is always
+    // `true`. When we attach a view that's marked `Dirty`, we should ensure that it is reached during
+    // the next CD traversal so we add the `RefreshView` flag and mark ancestors accordingly.
+    if (requiresRefreshOrTraversal(lView)) {
+        markAncestorsForTraversal(lView);
+    }
+    else if (lView[FLAGS] & 64 /* LViewFlags.Dirty */) {
+        if (getEnsureDirtyViewsAreAlwaysReachable()) {
+            lView[FLAGS] |= 1024 /* LViewFlags.RefreshView */;
+            markAncestorsForTraversal(lView);
+        }
+        else {
+            lView[ENVIRONMENT].changeDetectionScheduler?.notify();
+        }
     }
-    markAncestorsForTraversal(lView);
 }
 /**
  * Ensures views above the given `lView` are traversed during change detection even when they are
@@ -2783,24 +2815,19 @@ function updateAncestorTraversalFlagsOnAttach(lView) {
  * flag is already `true` or the `lView` is detached.
  */
 function markAncestorsForTraversal(lView) {
-    let parent = lView[PARENT];
+    lView[ENVIRONMENT].changeDetectionScheduler?.notify();
+    let parent = getLViewParent(lView);
     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[FLAGS] & LContainerFlags.HasChildViewsToRefresh) ||
-            (isLView(parent) && parent[FLAGS] & 8192 /* LViewFlags.HasChildViewsToRefresh */))) {
+        if (parent[FLAGS] & 8192 /* LViewFlags.HasChildViewsToRefresh */) {
             break;
         }
-        if (isLContainer(parent)) {
-            parent[FLAGS] |= LContainerFlags.HasChildViewsToRefresh;
-        }
-        else {
-            parent[FLAGS] |= 8192 /* LViewFlags.HasChildViewsToRefresh */;
-            if (!viewAttachedToChangeDetector(parent)) {
-                break;
-            }
+        parent[FLAGS] |= 8192 /* LViewFlags.HasChildViewsToRefresh */;
+        if (!viewAttachedToChangeDetector(parent)) {
+            break;
         }
-        parent = parent[PARENT];
+        parent = getLViewParent(parent);
     }
 }
 /**
@@ -2826,6 +2853,16 @@ function removeLViewOnDestroy(lView, onDestroyCallback) {
         lView[ON_DESTROY_HOOKS].splice(destroyCBIdx, 1);
     }
 }
+/**
+ * Gets the parent LView of the passed LView, if the PARENT is an LContainer, will get the parent of
+ * that LContainer, which is an LView
+ * @param lView the lView whose parent to get
+ */
+function getLViewParent(lView) {
+    ngDevMode && assertLView(lView);
+    const parent = lView[PARENT];
+    return isLContainer(parent) ? parent[PARENT] : parent;
+}
 
 const instructionState = {
     lFrame: createLFrame(null),
@@ -3818,11 +3855,12 @@ function hasParentInjector(parentLocation) {
     return parentLocation !== NO_PARENT_INJECTOR;
 }
 function getParentInjectorIndex(parentLocation) {
-    ngDevMode && assertNumber(parentLocation, 'Number expected');
-    ngDevMode && assertNotEqual(parentLocation, -1, 'Not a valid state.');
-    const parentInjectorIndex = parentLocation & 32767 /* RelativeInjectorLocationFlags.InjectorIndexMask */;
-    ngDevMode &&
+    if (ngDevMode) {
+        assertNumber(parentLocation, 'Number expected');
+        assertNotEqual(parentLocation, -1, 'Not a valid state.');
+        const parentInjectorIndex = parentLocation & 32767 /* RelativeInjectorLocationFlags.InjectorIndexMask */;
         assertGreaterThan(parentInjectorIndex, HEADER_OFFSET, 'Parent injector must be pointing past HEADER_OFFSET.');
+    }
     return parentLocation & 32767 /* RelativeInjectorLocationFlags.InjectorIndexMask */;
 }
 function getParentInjectorViewOffset(parentLocation) {
@@ -6189,9 +6227,11 @@ class R3Injector extends EnvironmentInjector {
             multiRecord.multi.push(provider);
         }
         else {
-            const existing = this.records.get(token);
-            if (ngDevMode && existing && existing.multi !== undefined) {
-                throwMixedMultiProviderError();
+            if (ngDevMode) {
+                const existing = this.records.get(token);
+                if (existing && existing.multi !== undefined) {
+                    throwMixedMultiProviderError();
+                }
             }
         }
         this.records.set(token, record);
@@ -6259,8 +6299,8 @@ function getUndecoratedInjectableFactory(token) {
     // If the token has parameters then it has dependencies that we cannot resolve implicitly.
     const paramLength = token.length;
     if (paramLength > 0) {
-        const args = newArray(paramLength, '?');
-        throw new RuntimeError(204 /* RuntimeErrorCode.INVALID_INJECTION_TOKEN */, ngDevMode && `Can't resolve all parameters for ${stringify(token)}: (${args.join(', ')}).`);
+        throw new RuntimeError(204 /* RuntimeErrorCode.INVALID_INJECTION_TOKEN */, ngDevMode &&
+            `Can't resolve all parameters for ${stringify(token)}: (${newArray(paramLength, '?').join(', ')}).`);
     }
     // The constructor function appears to have no parameters.
     // This might be because it inherits from a super-class. In which case, use an injectable
@@ -7954,63 +7994,6 @@ function ensureIcuContainerVisitorLoaded(loader) {
     }
 }
 
-/**
- * Gets the parent LView of the passed LView, if the PARENT is an LContainer, will get the parent of
- * that LContainer, which is an LView
- * @param lView the lView whose parent to get
- */
-function getLViewParent(lView) {
-    ngDevMode && assertLView(lView);
-    const parent = lView[PARENT];
-    return isLContainer(parent) ? parent[PARENT] : parent;
-}
-/**
- * Retrieve the root view from any component or `LView` by walking the parent `LView` until
- * reaching the root `LView`.
- *
- * @param componentOrLView any component or `LView`
- */
-function getRootView(componentOrLView) {
-    ngDevMode && assertDefined(componentOrLView, 'component');
-    let lView = isLView(componentOrLView) ? componentOrLView : readPatchedLView(componentOrLView);
-    while (lView && !(lView[FLAGS] & 512 /* LViewFlags.IsRoot */)) {
-        lView = getLViewParent(lView);
-    }
-    ngDevMode && assertLView(lView);
-    return lView;
-}
-/**
- * Returns the context information associated with the application where the target is situated. It
- * does this by walking the parent views until it gets to the root view, then getting the context
- * off of that.
- *
- * @param viewOrComponent the `LView` or component to get the root context for.
- */
-function getRootContext(viewOrComponent) {
-    const rootView = getRootView(viewOrComponent);
-    ngDevMode &&
-        assertDefined(rootView[CONTEXT], 'Root view has no context. Perhaps it is disconnected?');
-    return rootView[CONTEXT];
-}
-/**
- * Gets the first `LContainer` in the LView or `null` if none exists.
- */
-function getFirstLContainer(lView) {
-    return getNearestLContainer(lView[CHILD_HEAD]);
-}
-/**
- * Gets the next `LContainer` that is a sibling of the given container.
- */
-function getNextLContainer(container) {
-    return getNearestLContainer(container[NEXT]);
-}
-function getNearestLContainer(viewOrContainer) {
-    while (viewOrContainer !== null && !isLContainer(viewOrContainer)) {
-        viewOrContainer = viewOrContainer[NEXT];
-    }
-    return viewOrContainer;
-}
-
 /**
  * NOTE: for performance reasons, the possible actions are inlined within the function instead of
  * being passed as an argument.
@@ -8093,8 +8076,7 @@ function createElementNode(renderer, name, namespace) {
  * @param lView The view from which elements should be added or removed
  */
 function removeViewFromDOM(tView, lView) {
-    const renderer = lView[RENDERER];
-    applyView(tView, lView, renderer, 2 /* WalkTNodeTreeAction.Detach */, null, null);
+    detachViewFromDOM(tView, lView);
     lView[HOST] = null;
     lView[T_HOST] = null;
 }
@@ -8124,6 +8106,9 @@ function addViewToDOM(tView, parentTNode, renderer, lView, parentNativeNode, bef
  * @param lView the `LView` to be detached.
  */
 function detachViewFromDOM(tView, lView) {
+    // The scheduler must be notified because the animation engine is what actually does the DOM
+    // removal and only runs at the end of change detection.
+    lView[ENVIRONMENT].changeDetectionScheduler?.notify();
     applyView(tView, lView, lView[RENDERER], 2 /* WalkTNodeTreeAction.Detach */, null, null);
 }
 /**
@@ -8255,8 +8240,7 @@ function detachMovedView(declarationContainer, lView) {
         assertDefined(declarationContainer[MOVED_VIEWS], 'A projected view should belong to a non-empty projected views collection');
     const movedViews = declarationContainer[MOVED_VIEWS];
     const declarationViewIndex = movedViews.indexOf(lView);
-    const insertionLContainer = lView[PARENT];
-    ngDevMode && assertLContainer(insertionLContainer);
+    ngDevMode && assertLContainer(lView[PARENT]);
     movedViews.splice(declarationViewIndex, 1);
 }
 /**
@@ -9880,6 +9864,12 @@ function getSanitizer() {
     return lView && lView[ENVIRONMENT].sanitizer;
 }
 
+/**
+ * Injectable that is notified when an `LView` is made aware of changes to application state.
+ */
+class ChangeDetectionScheduler {
+}
+
 /**
  * Create a `StateKey<T>` that can be used to store value of type T with `TransferState`.
  *
@@ -10060,7 +10050,7 @@ const SSR_CONTENT_INTEGRITY_MARKER = 'nghm';
  * @param injector Injector that this component has access to.
  * @param isRootView Specifies whether we trying to read hydration info for the root view.
  */
-let _retrieveHydrationInfoImpl = (rNode, injector, isRootView) => null;
+let _retrieveHydrationInfoImpl = () => null;
 function retrieveHydrationInfoImpl(rNode, injector, isRootView = false) {
     let nghAttrValue = rNode.getAttribute(NGH_ATTR_NAME);
     if (nghAttrValue == null)
@@ -10450,24 +10440,6 @@ class Sanitizer {
     }); }
 }
 
-/**
- * @description Represents the version of Angular
- *
- * @publicApi
- */
-class Version {
-    constructor(full) {
-        this.full = full;
-        this.major = full.split('.')[0];
-        this.minor = full.split('.')[1];
-        this.patch = full.split('.').slice(2).join('.');
-    }
-}
-/**
- * @publicApi
- */
-const VERSION = new Version('17.1.0-next.4');
-
 // This default value is when checking the hierarchy for a token.
 //
 // It means both:
@@ -11742,6 +11714,53 @@ const REACTIVE_LVIEW_CONSUMER_NODE = {
     },
 };
 
+/**
+ * Retrieve the root view from any component or `LView` by walking the parent `LView` until
+ * reaching the root `LView`.
+ *
+ * @param componentOrLView any component or `LView`
+ */
+function getRootView(componentOrLView) {
+    ngDevMode && assertDefined(componentOrLView, 'component');
+    let lView = isLView(componentOrLView) ? componentOrLView : readPatchedLView(componentOrLView);
+    while (lView && !(lView[FLAGS] & 512 /* LViewFlags.IsRoot */)) {
+        lView = getLViewParent(lView);
+    }
+    ngDevMode && assertLView(lView);
+    return lView;
+}
+/**
+ * Returns the context information associated with the application where the target is situated. It
+ * does this by walking the parent views until it gets to the root view, then getting the context
+ * off of that.
+ *
+ * @param viewOrComponent the `LView` or component to get the root context for.
+ */
+function getRootContext(viewOrComponent) {
+    const rootView = getRootView(viewOrComponent);
+    ngDevMode &&
+        assertDefined(rootView[CONTEXT], 'Root view has no context. Perhaps it is disconnected?');
+    return rootView[CONTEXT];
+}
+/**
+ * Gets the first `LContainer` in the LView or `null` if none exists.
+ */
+function getFirstLContainer(lView) {
+    return getNearestLContainer(lView[CHILD_HEAD]);
+}
+/**
+ * Gets the next `LContainer` that is a sibling of the given container.
+ */
+function getNextLContainer(container) {
+    return getNearestLContainer(container[NEXT]);
+}
+function getNearestLContainer(viewOrContainer) {
+    while (viewOrContainer !== null && !isLContainer(viewOrContainer)) {
+        viewOrContainer = viewOrContainer[NEXT];
+    }
+    return viewOrContainer;
+}
+
 const ERROR_ORIGINAL_ERROR = 'ngOriginalError';
 function wrappedError(message, originalError) {
     const msg = `${message} caused by: ${originalError instanceof Error ? originalError.message : originalError}`;
@@ -11983,7 +12002,7 @@ const NO_CHANGE = (typeof ngDevMode === 'undefined' || ngDevMode) ? { __brand__:
  *
  * @codeGenApi
  */
-function ɵɵadvance(delta) {
+function ɵɵadvance(delta = 1) {
     ngDevMode && assertGreaterThan(delta, 0, 'Can only advance forward');
     selectIndexInternal(getTView(), getLView(), getSelectedIndex() + delta, !!ngDevMode && isInCheckNoChangesMode());
 }
@@ -12044,6 +12063,39 @@ function ɵɵinvalidFactory() {
     throw new Error(msg);
 }
 
+function writeToDirectiveInput(def, instance, publicName, privateName, flags, value) {
+    const prevConsumer = setActiveConsumer$1(null);
+    try {
+        // If we know we are dealing with a signal input, we cache its reference
+        // in a tree-shakable way. The input signal node can then be used for
+        // value transform execution or actual value updates without introducing
+        // additional megamorphic accesses for accessing the instance field.
+        let inputSignalNode = null;
+        if ((flags & InputFlags.SignalBased) !== 0) {
+            const field = instance[privateName];
+            inputSignalNode = field[SIGNAL$1];
+        }
+        // If there is a signal node and a transform, run it before potentially
+        // delegating to features like `NgOnChanges`.
+        if (inputSignalNode !== null && inputSignalNode.transformFn !== undefined) {
+            value = inputSignalNode.transformFn(value);
+        }
+        // If there is a decorator input transform, run it.
+        if ((flags & InputFlags.HasDecoratorInputTransform) !== 0) {
+            value = def.inputTransforms[privateName].call(instance, value);
+        }
+        if (def.setInput !== null) {
+            def.setInput(instance, inputSignalNode, value, publicName, privateName);
+        }
+        else {
+            applyValueToInputField(instance, inputSignalNode, privateName, value);
+        }
+    }
+    finally {
+        setActiveConsumer$1(prevConsumer);
+    }
+}
+
 /**
  * Invoke `HostBindingsFunction`s for view.
  *
@@ -12082,7 +12134,8 @@ function processHostBindingOpCodes(tView, lView) {
 function createLView(parentLView, tView, context, flags, host, tHostNode, environment, renderer, injector, embeddedViewInjector, hydrationInfo) {
     const lView = tView.blueprint.slice();
     lView[HOST] = host;
-    lView[FLAGS] = flags | 4 /* LViewFlags.CreationMode */ | 128 /* LViewFlags.Attached */ | 8 /* LViewFlags.FirstLViewPass */;
+    lView[FLAGS] = flags | 4 /* LViewFlags.CreationMode */ | 128 /* LViewFlags.Attached */ | 8 /* LViewFlags.FirstLViewPass */ |
+        64 /* LViewFlags.Dirty */;
     if (embeddedViewInjector !== null ||
         (parentLView && (parentLView[FLAGS] & 2048 /* LViewFlags.HasEmbeddedViewInjector */))) {
         lView[FLAGS] |= 2048 /* LViewFlags.HasEmbeddedViewInjector */;
@@ -12392,7 +12445,7 @@ function applyRootElementTransform(rootElement) {
  *
  * @param rootElement the app root HTML Element
  */
-let _applyRootElementTransformImpl = (rootElement) => null;
+let _applyRootElementTransformImpl = () => null;
 /**
  * Processes text node markers before hydration begins. This replaces any special comment
  * nodes that were added prior to serialization are swapped out to restore proper text
@@ -12499,42 +12552,61 @@ function createTNode(tView, tParent, type, index, value, attrs) {
     }
     return tNode;
 }
-/**
- * Generates the `PropertyAliases` data structure from the provided input/output mapping.
- * @param aliasMap Input/output mapping from the directive definition.
- * @param directiveIndex Index of the directive.
- * @param propertyAliases Object in which to store the results.
- * @param hostDirectiveAliasMap Object used to alias or filter out properties for host directives.
- * If the mapping is provided, it'll act as an allowlist, as well as a mapping of what public
- * name inputs/outputs should be exposed under.
- */
-function generatePropertyAliases(aliasMap, directiveIndex, propertyAliases, hostDirectiveAliasMap) {
+function captureNodeBindings(mode, aliasMap, directiveIndex, bindingsResult, hostDirectiveAliasMap) {
     for (let publicName in aliasMap) {
-        if (aliasMap.hasOwnProperty(publicName)) {
-            propertyAliases = propertyAliases === null ? {} : propertyAliases;
-            const internalName = aliasMap[publicName];
-            // If there are no host directive mappings, we want to remap using the alias map from the
-            // definition itself. If there is an alias map, it has two functions:
-            // 1. It serves as an allowlist of bindings that are exposed by the host directives. Only the
-            // ones inside the host directive map will be exposed on the host.
-            // 2. The public name of the property is aliased using the host directive alias map, rather
-            // than the alias map from the definition.
-            if (hostDirectiveAliasMap === null) {
-                addPropertyAlias(propertyAliases, directiveIndex, publicName, internalName);
-            }
-            else if (hostDirectiveAliasMap.hasOwnProperty(publicName)) {
-                addPropertyAlias(propertyAliases, directiveIndex, hostDirectiveAliasMap[publicName], internalName);
+        if (!aliasMap.hasOwnProperty(publicName)) {
+            continue;
+        }
+        const value = aliasMap[publicName];
+        if (value === undefined) {
+            continue;
+        }
+        bindingsResult ??= {};
+        let internalName;
+        let inputFlags = InputFlags.None;
+        // For inputs, the value might be an array capturing additional
+        // input flags.
+        if (Array.isArray(value)) {
+            internalName = value[0];
+            inputFlags = value[1];
+        }
+        else {
+            internalName = value;
+        }
+        // If there are no host directive mappings, we want to remap using the alias map from the
+        // definition itself. If there is an alias map, it has two functions:
+        // 1. It serves as an allowlist of bindings that are exposed by the host directives. Only the
+        // ones inside the host directive map will be exposed on the host.
+        // 2. The public name of the property is aliased using the host directive alias map, rather
+        // than the alias map from the definition.
+        let finalPublicName = publicName;
+        if (hostDirectiveAliasMap !== null) {
+            // If there is no mapping, it's not part of the allowlist and this input/output
+            // is not captured and should be ignored.
+            if (!hostDirectiveAliasMap.hasOwnProperty(publicName)) {
+                continue;
             }
+            finalPublicName = hostDirectiveAliasMap[publicName];
+        }
+        if (mode === 0 /* CaptureNodeBindingMode.Inputs */) {
+            addPropertyBinding(bindingsResult, directiveIndex, finalPublicName, internalName, inputFlags);
+        }
+        else {
+            addPropertyBinding(bindingsResult, directiveIndex, finalPublicName, internalName);
         }
     }
-    return propertyAliases;
+    return bindingsResult;
 }
-function addPropertyAlias(propertyAliases, directiveIndex, publicName, internalName) {
-    if (propertyAliases.hasOwnProperty(publicName)) {
-        propertyAliases[publicName].push(directiveIndex, internalName);
+function addPropertyBinding(bindings, directiveIndex, publicName, internalName, inputFlags) {
+    let values;
+    if (bindings.hasOwnProperty(publicName)) {
+        (values = bindings[publicName]).push(directiveIndex, internalName);
     }
     else {
-        propertyAliases[publicName] = [directiveIndex, internalName];
+        values = bindings[publicName] = [directiveIndex, internalName];
+    }
+    if (inputFlags !== undefined) {
+        values.push(inputFlags);
     }
 }
 /**
@@ -12555,10 +12627,8 @@ function initializeInputAndOutputAliases(tView, tNode, hostDirectiveDefinitionMa
         const aliasData = hostDirectiveDefinitionMap ? hostDirectiveDefinitionMap.get(directiveDef) : null;
         const aliasedInputs = aliasData ? aliasData.inputs : null;
         const aliasedOutputs = aliasData ? aliasData.outputs : null;
-        inputsStore =
-            generatePropertyAliases(directiveDef.inputs, directiveIndex, inputsStore, aliasedInputs);
-        outputsStore =
-            generatePropertyAliases(directiveDef.outputs, directiveIndex, outputsStore, aliasedOutputs);
+        inputsStore = captureNodeBindings(0 /* CaptureNodeBindingMode.Inputs */, directiveDef.inputs, directiveIndex, inputsStore, aliasedInputs);
+        outputsStore = captureNodeBindings(1 /* CaptureNodeBindingMode.Outputs */, directiveDef.outputs, directiveIndex, outputsStore, aliasedOutputs);
         // Do not use unbound attributes as inputs to structural directives, since structural
         // directive inputs can only be set using microsyntax (e.g. `<div *dir="exp">`).
         // TODO(FW-1930): microsyntax expressions may also contain unbound/static attributes, which
@@ -12675,7 +12745,7 @@ function setNgReflectProperties(lView, element, type, dataValue, value) {
          * e.g. [0, 'change', 'change-minified']
          * we want to set the reflected property with the privateName: dataValue[i+1]
          */
-        for (let i = 0; i < dataValue.length; i += 2) {
+        for (let i = 0; i < dataValue.length; i += 3) {
             setNgReflectProperty(lView, element, type, dataValue[i + 1], value);
         }
     }
@@ -13067,8 +13137,9 @@ function setInputsFromAttrs(lView, directiveIndex, instance, def, tNode, initial
         for (let i = 0; i < initialInputs.length;) {
             const publicName = initialInputs[i++];
             const privateName = initialInputs[i++];
+            const flags = initialInputs[i++];
             const value = initialInputs[i++];
-            writeToDirectiveInput(def, instance, publicName, privateName, value);
+            writeToDirectiveInput(def, instance, publicName, privateName, flags, value);
             if (ngDevMode) {
                 const nativeElement = getNativeByTNode(tNode, lView);
                 setNgReflectProperty(lView, nativeElement, tNode.type, privateName, value);
@@ -13076,24 +13147,6 @@ function setInputsFromAttrs(lView, directiveIndex, instance, def, tNode, initial
         }
     }
 }
-function writeToDirectiveInput(def, instance, publicName, privateName, value) {
-    const prevConsumer = setActiveConsumer$1(null);
-    try {
-        const inputTransforms = def.inputTransforms;
-        if (inputTransforms !== null && inputTransforms.hasOwnProperty(privateName)) {
-            value = inputTransforms[privateName].call(instance, value);
-        }
-        if (def.setInput !== null) {
-            def.setInput(instance, value, publicName, privateName);
-        }
-        else {
-            instance[privateName] = value;
-        }
-    }
-    finally {
-        setActiveConsumer$1(prevConsumer);
-    }
-}
 /**
  * Generates initialInputData for a node and stores it in the template's static storage
  * so subsequent template invocations don't have to recalculate it.
@@ -13134,9 +13187,9 @@ function generateInitialInputs(inputs, directiveIndex, attrs) {
             // through the directive def, but we want to do it using the inputs store so that it can
             // account for host directive aliases.
             const inputConfig = inputs[attrName];
-            for (let j = 0; j < inputConfig.length; j += 2) {
+            for (let j = 0; j < inputConfig.length; j += 3) {
                 if (inputConfig[j] === directiveIndex) {
-                    inputsToStore.push(attrName, inputConfig[j + 1], attrs[i + 1]);
+                    inputsToStore.push(attrName, inputConfig[j + 1], inputConfig[j + 2], attrs[i + 1]);
                     // A directive can't have multiple inputs with the same name so we can break here.
                     break;
                 }
@@ -13323,10 +13376,11 @@ function setInputsForProperty(tView, lView, inputs, publicName, value) {
     for (let i = 0; i < inputs.length;) {
         const index = inputs[i++];
         const privateName = inputs[i++];
+        const flags = inputs[i++];
         const instance = lView[index];
         ngDevMode && assertIndexInRange(lView, index);
         const def = tView.data[index];
-        writeToDirectiveInput(def, instance, publicName, privateName, value);
+        writeToDirectiveInput(def, instance, publicName, privateName, flags, value);
     }
 }
 /**
@@ -13348,14 +13402,12 @@ const MAXIMUM_REFRESH_RERUNS = 100;
 function detectChangesInternal(lView, notifyErrorHandler = true) {
     const environment = lView[ENVIRONMENT];
     const rendererFactory = environment.rendererFactory;
-    const afterRenderEventManager = environment.afterRenderEventManager;
     // Check no changes mode is a dev only mode used to verify that bindings have not changed
     // since they were assigned. We do not want to invoke renderer factory functions in that mode
     // to avoid any possible side-effects.
     const checkNoChangesMode = !!ngDevMode && isInCheckNoChangesMode();
     if (!checkNoChangesMode) {
         rendererFactory.begin?.();
-        afterRenderEventManager?.begin();
     }
     try {
         detectChangesInViewWhileDirty(lView);
@@ -13372,8 +13424,6 @@ function detectChangesInternal(lView, notifyErrorHandler = true) {
             // One final flush of the effects queue to catch any effects created in `ngAfterViewInit` or
             // other post-order hooks.
             environment.inlineEffectRunner?.flush();
-            // Invoke all callbacks registered via `after*Render`, if needed.
-            afterRenderEventManager?.end();
         }
     }
 }
@@ -13579,7 +13629,6 @@ function viewShouldHaveReactiveConsumer(tView) {
  */
 function detectChangesInEmbeddedViews(lView, mode) {
     for (let lContainer = getFirstLContainer(lView); lContainer !== null; lContainer = getNextLContainer(lContainer)) {
-        lContainer[FLAGS] &= ~LContainerFlags.HasChildViewsToRefresh;
         for (let i = CONTAINER_HEADER_OFFSET; i < lContainer.length; i++) {
             const embeddedLView = lContainer[i];
             detectChangesInViewIfAttached(embeddedLView, mode);
@@ -13691,6 +13740,7 @@ function detectChangesInChildComponents(hostLView, components, mode) {
  * @returns the root LView
  */
 function markViewDirty(lView) {
+    lView[ENVIRONMENT].changeDetectionScheduler?.notify();
     while (lView) {
         lView[FLAGS] |= 64 /* LViewFlags.Dirty */;
         const parent = getLViewParent(lView);
@@ -13984,6 +14034,7 @@ class ViewRef$1 {
             throw new RuntimeError(902 /* RuntimeErrorCode.VIEW_ALREADY_ATTACHED */, ngDevMode && 'This view is already attached to a ViewContainer!');
         }
         this._appRef = appRef;
+        updateAncestorTraversalFlagsOnAttach(this._lView);
     }
 }
 
@@ -14243,11 +14294,11 @@ class ZoneAwareMicrotaskScheduler {
  * available/requested.
  */
 class EffectHandle {
-    constructor(scheduler, effectFn, creationZone, destroyRef, errorHandler, allowSignalWrites) {
+    constructor(scheduler, effectFn, creationZone, destroyRef, injector, allowSignalWrites) {
         this.scheduler = scheduler;
         this.effectFn = effectFn;
         this.creationZone = creationZone;
-        this.errorHandler = errorHandler;
+        this.injector = injector;
         this.watcher = createWatch$1((onCleanup) => this.runEffect(onCleanup), () => this.schedule(), allowSignalWrites);
         this.unregisterOnDestroy = destroyRef?.onDestroy(() => this.destroy());
     }
@@ -14256,7 +14307,10 @@ class EffectHandle {
             this.effectFn(onCleanup);
         }
         catch (err) {
-            this.errorHandler?.handleError(err);
+            // Inject the `ErrorHandler` here in order to avoid circular DI error
+            // if the effect is used inside of a custom `ErrorHandler`.
+            const errorHandler = this.injector.get(ErrorHandler, null, { optional: true });
+            errorHandler?.handleError(err);
         }
     }
     run() {
@@ -14283,9 +14337,8 @@ function effect(effectFn, options) {
             '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);
+    const handle = new EffectHandle(injector.get(APP_EFFECT_SCHEDULER), effectFn, (typeof Zone === 'undefined') ? null : Zone.current, destroyRef, injector, options?.allowSignalWrites ?? false);
     // Effects need to be marked dirty manually to trigger their initial run. The timing of this
     // marking matters, because the effects may read signals that track component inputs, which are
     // only available after those components have had their first update pass.
@@ -14328,7 +14381,6 @@ function performanceMarkFeature(feature) {
     performance?.mark?.('mark_feature_usage', { detail: { feature } });
 }
 
-/// <reference types="rxjs" />
 class EventEmitter_ extends Subject {
     constructor(isAsync = false) {
         super();
@@ -14827,63 +14879,6 @@ class NoopNgZone {
         return fn.apply(applyThis, applyArgs);
     }
 }
-/**
- * Token used to drive ApplicationRef.isStable
- *
- * TODO: This should be moved entirely to NgZone (as a breaking change) so it can be tree-shakeable
- * for `NoopNgZone` which is always just an `Observable` of `true`. Additionally, we should consider
- * whether the property on `NgZone` should be `Observable` or `Signal`.
- */
-const ZONE_IS_STABLE_OBSERVABLE = new InjectionToken(ngDevMode ? 'isStable Observable' : '', {
-    providedIn: 'root',
-    // TODO(atscott): Replace this with a suitable default like `new
-    // BehaviorSubject(true).asObservable`. Again, long term this won't exist on ApplicationRef at
-    // all but until we can remove it, we need a default value zoneless.
-    factory: isStableFactory,
-});
-function isStableFactory() {
-    const zone = inject(NgZone);
-    let _stable = true;
-    const isCurrentlyStable = new Observable((observer) => {
-        _stable = zone.isStable && !zone.hasPendingMacrotasks && !zone.hasPendingMicrotasks;
-        zone.runOutsideAngular(() => {
-            observer.next(_stable);
-            observer.complete();
-        });
-    });
-    const isStable = new Observable((observer) => {
-        // Create the subscription to onStable outside the Angular Zone so that
-        // the callback is run outside the Angular Zone.
-        let stableSub;
-        zone.runOutsideAngular(() => {
-            stableSub = zone.onStable.subscribe(() => {
-                NgZone.assertNotInAngularZone();
-                // Check whether there are no pending macro/micro tasks in the next tick
-                // to allow for NgZone to update the state.
-                queueMicrotask(() => {
-                    if (!_stable && !zone.hasPendingMacrotasks && !zone.hasPendingMicrotasks) {
-                        _stable = true;
-                        observer.next(true);
-                    }
-                });
-            });
-        });
-        const unstableSub = zone.onUnstable.subscribe(() => {
-            NgZone.assertInAngularZone();
-            if (_stable) {
-                _stable = false;
-                zone.runOutsideAngular(() => {
-                    observer.next(false);
-                });
-            }
-        });
-        return () => {
-            stableSub.unsubscribe();
-            unstableSub.unsubscribe();
-        };
-    });
-    return merge$1(isCurrentlyStable, isStable.pipe(share()));
-}
 function shouldBeIgnoredByZone(applyArgs) {
     if (!Array.isArray(applyArgs)) {
         return false;
@@ -14906,8 +14901,6 @@ function getNgZone(ngZoneToUse = 'zone.js', options) {
     return ngZoneToUse;
 }
 
-// Public API for Zone
-
 /**
  * The phase to run an `afterRender` or `afterNextRender` callback in.
  *
@@ -15176,13 +15169,6 @@ class AfterRenderCallbackHandlerImpl {
         };
         this.deferredCallbacks = new Set();
     }
-    validateBegin() {
-        if (this.executingCallbacks) {
-            throw new RuntimeError(102 /* RuntimeErrorCode.RECURSIVE_APPLICATION_RENDER */, ngDevMode &&
-                'A new render operation began before the previous operation ended. ' +
-                    'Did you trigger change detection from afterRender or afterNextRender?');
-        }
-    }
     register(callback) {
         // If we're currently running callbacks, new callbacks should be deferred
         // until the next render operation.
@@ -15194,9 +15180,11 @@ class AfterRenderCallbackHandlerImpl {
         this.deferredCallbacks.delete(callback);
     }
     execute() {
+        let callbacksExecuted = false;
         this.executingCallbacks = true;
         for (const bucket of Object.values(this.buckets)) {
             for (const callback of bucket) {
+                callbacksExecuted = true;
                 callback.invoke();
             }
         }
@@ -15205,6 +15193,7 @@ class AfterRenderCallbackHandlerImpl {
             this.buckets[callback.phase].add(callback);
         }
         this.deferredCallbacks.clear();
+        return callbacksExecuted;
     }
     destroy() {
         for (const bucket of Object.values(this.buckets)) {
@@ -15219,37 +15208,25 @@ class AfterRenderCallbackHandlerImpl {
  */
 class AfterRenderEventManager {
     constructor() {
-        this.renderDepth = 0;
         /* @internal */
         this.handler = null;
         /* @internal */
         this.internalCallbacks = [];
     }
     /**
-     * Mark the beginning of a render operation (i.e. CD cycle).
-     * Throws if called while executing callbacks.
+     * Executes callbacks. Returns `true` if any callbacks executed.
      */
-    begin() {
-        this.handler?.validateBegin();
-        this.renderDepth++;
-    }
-    /**
-     * Mark the end of a render operation. Callbacks will be
-     * executed if there are no more pending operations.
-     */
-    end() {
-        ngDevMode && assertGreaterThan(this.renderDepth, 0, 'renderDepth must be greater than 0');
-        this.renderDepth--;
-        if (this.renderDepth === 0) {
-            // Note: internal callbacks power `internalAfterNextRender`. Since internal callbacks
-            // are fairly trivial, they are kept separate so that `AfterRenderCallbackHandlerImpl`
-            // can still be tree-shaken unless used by the application.
-            for (const callback of this.internalCallbacks) {
-                callback();
-            }
-            this.internalCallbacks.length = 0;
-            this.handler?.execute();
+    execute() {
+        // Note: internal callbacks power `internalAfterNextRender`. Since internal callbacks
+        // are fairly trivial, they are kept separate so that `AfterRenderCallbackHandlerImpl`
+        // can still be tree-shaken unless used by the application.
+        const callbacks = [...this.internalCallbacks];
+        this.internalCallbacks.length = 0;
+        for (const callback of callbacks) {
+            callback();
         }
+        const handlerCallbacksExecuted = this.handler?.execute();
+        return !!handlerCallbacksExecuted || callbacks.length > 0;
     }
     ngOnDestroy() {
         this.handler?.destroy();
@@ -15429,11 +15406,18 @@ class ComponentFactoryResolver extends ComponentFactoryResolver$1 {
 }
 function toRefArray(map) {
     const array = [];
-    for (let nonMinified in map) {
-        if (map.hasOwnProperty(nonMinified)) {
-            const minified = map[nonMinified];
-            array.push({ propName: minified, templateName: nonMinified });
+    for (const publicName in map) {
+        if (!map.hasOwnProperty(publicName)) {
+            continue;
         }
+        const value = map[publicName];
+        if (value === undefined) {
+            continue;
+        }
+        array.push({
+            propName: Array.isArray(value) ? value[0] : value,
+            templateName: publicName,
+        });
     }
     return array;
 }
@@ -15525,12 +15509,14 @@ class ComponentFactory extends ComponentFactory$1 {
         }
         const sanitizer = rootViewInjector.get(Sanitizer, null);
         const afterRenderEventManager = rootViewInjector.get(AfterRenderEventManager, null);
+        const changeDetectionScheduler = rootViewInjector.get(ChangeDetectionScheduler, null);
         const environment = {
             rendererFactory,
             sanitizer,
             // We don't use inline effects (yet).
             inlineEffectRunner: null,
             afterRenderEventManager,
+            changeDetectionScheduler,
         };
         const hostRenderer = rendererFactory.createRenderer(null, this.componentDef);
         // Determine a tag name used for creating host elements when this component is created
@@ -15539,12 +15525,13 @@ class ComponentFactory extends ComponentFactory$1 {
         const hostRNode = rootSelectorOrNode ?
             locateHostElement(hostRenderer, rootSelectorOrNode, this.componentDef.encapsulation, rootViewInjector) :
             createElementNode(hostRenderer, elementName, getNamespace(elementName));
-        // Signal components use the granular "RefreshView"  for change detection
-        const signalFlags = (4096 /* LViewFlags.SignalView */ | 512 /* LViewFlags.IsRoot */);
-        // Non-signal components use the traditional "CheckAlways or OnPush/Dirty" change detection
-        const nonSignalFlags = this.componentDef.onPush ? 64 /* LViewFlags.Dirty */ | 512 /* LViewFlags.IsRoot */ :
-            16 /* LViewFlags.CheckAlways */ | 512 /* LViewFlags.IsRoot */;
-        const rootFlags = this.componentDef.signals ? signalFlags : nonSignalFlags;
+        let rootFlags = 512 /* LViewFlags.IsRoot */;
+        if (this.componentDef.signals) {
+            rootFlags |= 4096 /* LViewFlags.SignalView */;
+        }
+        else if (!this.componentDef.onPush) {
+            rootFlags |= 16 /* LViewFlags.CheckAlways */;
+        }
         let hydrationInfo = null;
         if (hostRNode !== null) {
             hydrationInfo = retrieveHydrationInfo(hostRNode, rootViewInjector, true /* isRootView */);
@@ -15751,7 +15738,8 @@ function createRootComponent(componentView, rootComponentDef, rootDirectives, ho
 /** Sets the static attributes on a root component. */
 function setRootNodeAttributes(hostRenderer, componentDef, hostRNode, rootSelectorOrNode) {
     if (rootSelectorOrNode) {
-        setUpAttributes(hostRenderer, hostRNode, ['ng-version', VERSION.full]);
+        // The placeholder will be replaced with the actual version at build time.
+        setUpAttributes(hostRenderer, hostRNode, ['ng-version', '17.1.0-rc.0']);
     }
     else {
         // If host element is created as a part of this function call (i.e. `rootSelectorOrNode`
@@ -15844,15 +15832,8 @@ function ɵɵInheritDefinitionFeature(definition) {
                 superViewQuery && inheritViewQuery(definition, superViewQuery);
                 superContentQueries && inheritContentQueries(definition, superContentQueries);
                 // Merge inputs and outputs
-                fillProperties(definition.inputs, superDef.inputs);
-                fillProperties(definition.declaredInputs, superDef.declaredInputs);
+                mergeInputsWithTransforms(definition, superDef);
                 fillProperties(definition.outputs, superDef.outputs);
-                if (superDef.inputTransforms !== null) {
-                    if (writeableDef.inputTransforms === null) {
-                        writeableDef.inputTransforms = {};
-                    }
-                    fillProperties(writeableDef.inputTransforms, superDef.inputTransforms);
-                }
                 // Merge animations metadata.
                 // If `superDef` is a Component, the `data` field is present (defaults to an empty object).
                 if (isComponentDef(superDef) && superDef.data.animation) {
@@ -15887,6 +15868,35 @@ function ɵɵInheritDefinitionFeature(definition) {
     }
     mergeHostAttrsAcrossInheritance(inheritanceChain);
 }
+function mergeInputsWithTransforms(target, source) {
+    for (const key in source.inputs) {
+        if (!source.inputs.hasOwnProperty(key)) {
+            continue;
+        }
+        if (target.inputs.hasOwnProperty(key)) {
+            continue;
+        }
+        const value = source.inputs[key];
+        if (value === undefined) {
+            continue;
+        }
+        target.inputs[key] = value;
+        target.declaredInputs[key] = source.declaredInputs[key];
+        // If the input is inherited, and we have a transform for it, we also inherit it.
+        // Note that transforms should not be inherited if the input has its own metadata
+        // in the `source` directive itself already (i.e. the input is re-declared/overridden).
+        if (source.inputTransforms !== null) {
+            // Note: transforms are stored with their minified names.
+            // Perf: only access the minified name when there are source transforms.
+            const minifiedName = Array.isArray(value) ? value[0] : value;
+            if (!source.inputTransforms.hasOwnProperty(minifiedName)) {
+                continue;
+            }
+            target.inputTransforms ??= {};
+            target.inputTransforms[minifiedName] = source.inputTransforms[minifiedName];
+        }
+    }
+}
 /**
  * Merge the `hostAttrs` and `hostVars` from the inherited parent to the base class.
  *
@@ -16172,8 +16182,7 @@ function validateMappings(bindingType, def, hostDirectiveBindings) {
                 throw new RuntimeError(311 /* RuntimeErrorCode.HOST_DIRECTIVE_UNDEFINED_BINDING */, `Directive ${className} does not have an ${bindingType} with a public name of ${publicName}.`);
             }
             const remappedPublicName = hostDirectiveBindings[publicName];
-            if (bindings.hasOwnProperty(remappedPublicName) && remappedPublicName !== publicName &&
-                bindings[remappedPublicName] !== publicName) {
+            if (bindings.hasOwnProperty(remappedPublicName) && remappedPublicName !== publicName) {
                 throw new RuntimeError(312 /* RuntimeErrorCode.HOST_DIRECTIVE_CONFLICTING_ALIAS */, `Cannot alias ${bindingType} ${publicName} of host directive ${className} to ${remappedPublicName}, because it already has a different ${bindingType} with the same public name.`);
             }
         }
@@ -16196,13 +16205,12 @@ function ɵɵInputTransformsFeature(definition) {
             // Note: the private names are used for the keys, rather than the public ones, because public
             // names can be re-aliased in host directives which would invalidate the lookup.
             const value = inputs[minifiedKey];
-            if (Array.isArray(value) && value[2]) {
-                inputTransforms[minifiedKey] = value[2];
+            if (Array.isArray(value) && value[3]) {
+                inputTransforms[minifiedKey] = value[3];
             }
         }
     }
-    definition.inputTransforms =
-        inputTransforms;
+    definition.inputTransforms = inputTransforms;
 }
 
 // TODO(misko): consider inlining
@@ -17103,8 +17111,8 @@ function insertTStylingBinding(tData, tNode, tStylingKeyWithStatic, index, isHos
     if (isKeyDuplicateOfStatic) {
         tData[index + 1] = setTStylingRangePrevDuplicate(tData[index + 1]);
     }
-    markDuplicates(tData, tStylingKey, index, true, isClassBinding);
-    markDuplicates(tData, tStylingKey, index, false, isClassBinding);
+    markDuplicates(tData, tStylingKey, index, true);
+    markDuplicates(tData, tStylingKey, index, false);
     markDuplicateOfResidualStyling(tNode, tStylingKey, tData, index, isClassBinding);
     tBindings = toTStylingRange(tmplHead, tmplTail);
     if (isClassBinding) {
@@ -17188,7 +17196,7 @@ function markDuplicateOfResidualStyling(tNode, tStylingKey, tData, index, isClas
  *        - `true` for previous (lower priority);
  *        - `false` for next (higher priority).
  */
-function markDuplicates(tData, tStylingKey, index, isPrevDir, isClassBinding) {
+function markDuplicates(tData, tStylingKey, index, isPrevDir) {
     const tStylingAtIndex = tData[index + 1];
     const isMap = tStylingKey === null;
     let cursor = isPrevDir ? getTStylingRangePrev(tStylingAtIndex) : getTStylingRangeNext(tStylingAtIndex);
@@ -19490,7 +19498,7 @@ function locateDehydratedViewsInContainer(currentRNode, serializedViews) {
  * stored on a given lContainer.
  * Returns `null` by default, when hydration is not enabled.
  */
-let _findMatchingDehydratedViewImpl = (lContainer, template) => null;
+let _findMatchingDehydratedViewImpl = () => null;
 /**
  * Retrieves the next dehydrated view from the LContainer and verifies that
  * it matches a given template id (from the TView that was used to create this
@@ -20230,7 +20238,7 @@ function insertAnchorNode(hostLView, hostTNode) {
     return commentNode;
 }
 let _locateOrCreateAnchorNode = createAnchorNode;
-let _populateDehydratedViewsInLContainer = (lContainer, tNode, hostLView) => false; // noop by default
+let _populateDehydratedViewsInLContainer = () => false; // noop by default
 /**
  * Looks up dehydrated views that belong to a given LContainer and populates
  * this information into the `LContainer[DEHYDRATED_VIEWS]` slot. When running
@@ -20545,10 +20553,12 @@ class RepeaterMetadata {
  * @param emptyTemplateFn Reference to the template function of the empty block.
  * @param emptyDecls The number of nodes, local refs, and pipes for the empty block.
  * @param emptyVars The number of bindings for the empty block.
+ * @param emptyTagName The name of the empty block container element, if applicable
+ * @param emptyAttrsIndex Index of the empty block template attributes in the `consts` array.
  *
  * @codeGenApi
  */
-function ɵɵrepeaterCreate(index, templateFn, decls, vars, tagName, attrsIndex, trackByFn, trackByUsesComponentInstance, emptyTemplateFn, emptyDecls, emptyVars) {
+function ɵɵrepeaterCreate(index, templateFn, decls, vars, tagName, attrsIndex, trackByFn, trackByUsesComponentInstance, emptyTemplateFn, emptyDecls, emptyVars, emptyTagName, emptyAttrsIndex) {
     performanceMarkFeature('NgControlFlow');
     const hasEmptyBlock = emptyTemplateFn !== undefined;
     const hostLView = getLView();
@@ -20565,7 +20575,7 @@ function ɵɵrepeaterCreate(index, templateFn, decls, vars, tagName, attrsIndex,
             assertDefined(emptyDecls, 'Missing number of declarations for the empty repeater block.');
         ngDevMode &&
             assertDefined(emptyVars, 'Missing number of bindings for the empty repeater block.');
-        ɵɵtemplate(index + 2, emptyTemplateFn, emptyDecls, emptyVars);
+        ɵɵtemplate(index + 2, emptyTemplateFn, emptyDecls, emptyVars, emptyTagName, emptyAttrsIndex);
     }
 }
 class LiveCollectionLContainerImpl extends LiveCollection {
@@ -20806,6 +20816,8 @@ function invokeAllTriggerCleanupFns(lDetails) {
     invokeTriggerCleanupFns(0 /* TriggerType.Regular */, lDetails);
 }
 
+// Public API for Zone
+
 /**
  * Calculates a data slot index for defer block info (either static or
  * instance-specific), given an index of a defer instruction.
@@ -20975,8 +20987,6 @@ function onInteraction(trigger, callback) {
         // are referencing it.
         entry = new DeferEventEntry();
         interactionTriggers.set(trigger, entry);
-        // Ensure that the handler runs in the NgZone
-        ngDevMode && NgZone.assertInAngularZone();
         for (const name of interactionEventNames) {
             trigger.addEventListener(name, entry.listener, eventListenerOptions);
         }
@@ -21004,8 +21014,6 @@ function onHover(trigger, callback) {
     if (!entry) {
         entry = new DeferEventEntry();
         hoverTriggers.set(trigger, entry);
-        // Ensure that the handler runs in the NgZone
-        ngDevMode && NgZone.assertInAngularZone();
         for (const name of hoverEventNames) {
             trigger.addEventListener(name, entry.listener, eventListenerOptions);
         }
@@ -27134,8 +27142,9 @@ function getDirectiveMetadata$1(directiveOrComponentInstance) {
     // To ensure we don't get the metadata of the directive, we want to call `getComponentDef` first.
     const componentDef = getComponentDef(constructor);
     if (componentDef) {
+        const inputs = extractInputDebugMetadata(componentDef.inputs);
         return {
-            inputs: componentDef.inputs,
+            inputs,
             outputs: componentDef.outputs,
             encapsulation: componentDef.encapsulation,
             changeDetection: componentDef.onPush ? ChangeDetectionStrategy.OnPush :
@@ -27144,7 +27153,8 @@ function getDirectiveMetadata$1(directiveOrComponentInstance) {
     }
     const directiveDef = getDirectiveDef(constructor);
     if (directiveDef) {
-        return { inputs: directiveDef.inputs, outputs: directiveDef.outputs };
+        const inputs = extractInputDebugMetadata(directiveDef.inputs);
+        return { inputs, outputs: directiveDef.outputs };
     }
     return null;
 }
@@ -27298,6 +27308,36 @@ function assertDomElement(value) {
         throw new Error('Expecting instance of DOM Element');
     }
 }
+/**
+ * A directive definition holds additional metadata using bitwise flags to indicate
+ * for example whether it is signal based.
+ *
+ * This information needs to be separate from the `publicName -> minifiedName`
+ * mappings for backwards compatibility.
+ */
+function extractInputDebugMetadata(inputs) {
+    const res = {};
+    for (const key in inputs) {
+        if (!inputs.hasOwnProperty(key)) {
+            continue;
+        }
+        const value = inputs[key];
+        if (value === undefined) {
+            continue;
+        }
+        let minifiedName;
+        if (Array.isArray(value)) {
+            minifiedName = value[0];
+            // flags are not used for now.
+            // TODO: Consider exposing flag information in discovery.
+        }
+        else {
+            minifiedName = value;
+        }
+        res[key] = minifiedName;
+    }
+    return res;
+}
 
 /**
  * The name of a field that Angular monkey-patches onto a component
@@ -28842,6 +28882,7 @@ const angularCoreEnv = (() => ({
     'ɵɵvalidateIframeAttribute': ɵɵvalidateIframeAttribute,
     'forwardRef': forwardRef,
     'resolveForwardRef': resolveForwardRef,
+    'ɵɵInputFlags': InputFlags,
 }))();
 
 let jitOptions = null;
@@ -30008,6 +30049,25 @@ const NgModule = makeDecorator('NgModule', (ngModule) => ngModule, undefined, un
  * to be used by the decorator versions of these annotations.
  */
 
+/**
+ * @description Represents the version of Angular
+ *
+ * @publicApi
+ */
+class Version {
+    constructor(full) {
+        this.full = full;
+        const parts = full.split('.');
+        this.major = parts[0];
+        this.minor = parts[1];
+        this.patch = parts.slice(2).join('.');
+    }
+}
+/**
+ * @publicApi
+ */
+const VERSION = new Version('17.1.0-rc.0');
+
 /*
  * This file exists to support compilation of @angular/core in Ivy mode.
  *
@@ -30046,45 +30106,6 @@ class Console {
         args: [{ providedIn: 'platform' }]
     }], null, null); })();
 
-/**
- * *Internal* service that keeps track of pending tasks happening in the system
- * during the initial rendering. No tasks are tracked after an initial
- * rendering.
- *
- * This information is needed to make sure that the serialization on the server
- * is delayed until all tasks in the queue (such as an initial navigation or a
- * pending HTTP request) are completed.
- */
-class InitialRenderPendingTasks {
-    constructor() {
-        this.taskId = 0;
-        this.pendingTasks = new Set();
-        this.hasPendingTasks = new BehaviorSubject(false);
-    }
-    add() {
-        this.hasPendingTasks.next(true);
-        const taskId = this.taskId++;
-        this.pendingTasks.add(taskId);
-        return taskId;
-    }
-    remove(taskId) {
-        this.pendingTasks.delete(taskId);
-        if (this.pendingTasks.size === 0) {
-            this.hasPendingTasks.next(false);
-        }
-    }
-    ngOnDestroy() {
-        this.pendingTasks.clear();
-        this.hasPendingTasks.next(false);
-    }
-    static { this.ɵfac = function InitialRenderPendingTasks_Factory(t) { return new (t || InitialRenderPendingTasks)(); }; }
-    static { this.ɵprov = /*@__PURE__*/ ɵɵdefineInjectable({ token: InitialRenderPendingTasks, factory: InitialRenderPendingTasks.ɵfac, providedIn: 'root' }); }
-}
-(() => { (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(InitialRenderPendingTasks, [{
-        type: Injectable,
-        args: [{ providedIn: 'root' }]
-    }], null, null); })();
-
 /**
  * Combination of NgModuleFactory and ComponentFactories.
  *
@@ -30191,6 +30212,53 @@ const COMPILER_OPTIONS = new InjectionToken('compilerOptions');
 class CompilerFactory {
 }
 
+/**
+ * *Internal* service that keeps track of pending tasks happening in the system.
+ *
+ * This information is needed to make sure that the serialization on the server
+ * is delayed until all tasks in the queue (such as an initial navigation or a
+ * pending HTTP request) are completed.
+ *
+ * Pending tasks continue to contribute to the stableness of `ApplicationRef`
+ * throughout the lifetime of the application.
+ */
+class PendingTasks {
+    constructor() {
+        this.taskId = 0;
+        this.pendingTasks = new Set();
+        this.hasPendingTasks = new BehaviorSubject(false);
+    }
+    get _hasPendingTasks() {
+        return this.hasPendingTasks.value;
+    }
+    add() {
+        if (!this._hasPendingTasks) {
+            this.hasPendingTasks.next(true);
+        }
+        const taskId = this.taskId++;
+        this.pendingTasks.add(taskId);
+        return taskId;
+    }
+    remove(taskId) {
+        this.pendingTasks.delete(taskId);
+        if (this.pendingTasks.size === 0 && this._hasPendingTasks) {
+            this.hasPendingTasks.next(false);
+        }
+    }
+    ngOnDestroy() {
+        this.pendingTasks.clear();
+        if (this._hasPendingTasks) {
+            this.hasPendingTasks.next(false);
+        }
+    }
+    static { this.ɵfac = function PendingTasks_Factory(t) { return new (t || PendingTasks)(); }; }
+    static { this.ɵprov = /*@__PURE__*/ ɵɵdefineInjectable({ token: PendingTasks, factory: PendingTasks.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(PendingTasks, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], null, null); })();
+
 /**
  * These are the data structures that our framework injector profiler will fill with data in order
  * to support DI debugging APIs.
@@ -30996,6 +31064,28 @@ function getModuleInjectorOfNodeInjector(injector) {
  * tools are patched (window.ng).
  * */
 const GLOBAL_PUBLISH_EXPANDO_KEY = 'ng';
+const globalUtilsFunctions = {
+    /**
+     * Warning: functions that start with `ɵ` are considered *INTERNAL* and should not be relied upon
+     * in application's code. The contract of those functions might be changed in any release and/or a
+     * function can be removed completely.
+     */
+    'ɵgetDependenciesFromInjectable': getDependenciesFromInjectable,
+    'ɵgetInjectorProviders': getInjectorProviders,
+    'ɵgetInjectorResolutionPath': getInjectorResolutionPath,
+    'ɵgetInjectorMetadata': getInjectorMetadata,
+    'ɵsetProfiler': setProfiler,
+    'getDirectiveMetadata': getDirectiveMetadata$1,
+    'getComponent': getComponent,
+    'getContext': getContext,
+    'getListeners': getListeners,
+    'getOwningComponent': getOwningComponent,
+    'getHostElement': getHostElement,
+    'getInjector': getInjector,
+    'getRootComponents': getRootComponents,
+    'getDirectives': getDirectives,
+    'applyChanges': applyChanges,
+};
 let _published = false;
 /**
  * Publishes a collection of default debug tools onto`window.ng`.
@@ -31007,26 +31097,9 @@ function publishDefaultGlobalUtils$1() {
     if (!_published) {
         _published = true;
         setupFrameworkInjectorProfiler();
-        publishGlobalUtil('ɵgetDependenciesFromInjectable', getDependenciesFromInjectable);
-        publishGlobalUtil('ɵgetInjectorProviders', getInjectorProviders);
-        publishGlobalUtil('ɵgetInjectorResolutionPath', getInjectorResolutionPath);
-        publishGlobalUtil('ɵgetInjectorMetadata', getInjectorMetadata);
-        /**
-         * 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.
-         */
-        publishGlobalUtil('ɵsetProfiler', setProfiler);
-        publishGlobalUtil('getDirectiveMetadata', getDirectiveMetadata$1);
-        publishGlobalUtil('getComponent', getComponent);
-        publishGlobalUtil('getContext', getContext);
-        publishGlobalUtil('getListeners', getListeners);
-        publishGlobalUtil('getOwningComponent', getOwningComponent);
-        publishGlobalUtil('getHostElement', getHostElement);
-        publishGlobalUtil('getInjector', getInjector);
-        publishGlobalUtil('getRootComponents', getRootComponents);
-        publishGlobalUtil('getDirectives', getDirectives);
-        publishGlobalUtil('applyChanges', applyChanges);
+        for (const [methodName, method] of Object.entries(globalUtilsFunctions)) {
+            publishGlobalUtil(methodName, method);
+        }
     }
 }
 /**
@@ -31041,13 +31114,8 @@ function publishGlobalUtil(name, fn) {
         //   for typings for AngularJS (via `goog.provide('ng....')`).
         const w = _global;
         ngDevMode && assertDefined(fn, 'function not defined');
-        if (w) {
-            let container = w[GLOBAL_PUBLISH_EXPANDO_KEY];
-            if (!container) {
-                container = w[GLOBAL_PUBLISH_EXPANDO_KEY] = {};
-            }
-            container[name] = fn;
-        }
+        w[GLOBAL_PUBLISH_EXPANDO_KEY] ??= {};
+        w[GLOBAL_PUBLISH_EXPANDO_KEY][name] = fn;
     }
 }
 
@@ -31091,13 +31159,6 @@ class Testability {
         this.registry = registry;
         this._pendingCount = 0;
         this._isZoneStable = true;
-        /**
-         * Whether any work was done since the last 'whenStable' callback. This is
-         * useful to detect if this could have potentially destabilized another
-         * component while it is stabilizing.
-         * @internal
-         */
-        this._didWork = false;
         this._callbacks = [];
         this.taskTrackingZone = null;
         // If there was no Testability logic registered in the global scope
@@ -31115,7 +31176,6 @@ class Testability {
     _watchAngularEvents() {
         this._ngZone.onUnstable.subscribe({
             next: () => {
-                this._didWork = true;
                 this._isZoneStable = false;
             }
         });
@@ -31137,7 +31197,6 @@ class Testability {
      */
     increasePendingRequestCount() {
         this._pendingCount += 1;
-        this._didWork = true;
         return this._pendingCount;
     }
     /**
@@ -31165,9 +31224,8 @@ class Testability {
                 while (this._callbacks.length !== 0) {
                     let cb = this._callbacks.pop();
                     clearTimeout(cb.timeoutId);
-                    cb.doneCb(this._didWork);
+                    cb.doneCb();
                 }
-                this._didWork = false;
             });
         }
         else {
@@ -31180,7 +31238,6 @@ class Testability {
                 }
                 return true;
             });
-            this._didWork = true;
         }
     }
     getPendingTasks() {
@@ -31203,7 +31260,7 @@ class Testability {
         if (timeout && timeout > 0) {
             timeoutId = setTimeout(() => {
                 this._callbacks = this._callbacks.filter((cb) => cb.timeoutId !== timeoutId);
-                cb(this._didWork, this.getPendingTasks());
+                cb();
             }, timeout);
         }
         this._callbacks.push({ doneCb: cb, timeoutId: timeoutId, updateCb: updateCb });
@@ -31225,7 +31282,6 @@ class Testability {
             throw new Error('Task tracking zone is required when passing an update callback to ' +
                 'whenStable(). Is "zone.js/plugins/task-tracking" loaded?');
         }
-        // These arguments are 'Function' above to keep the public API simple.
         this.addCallback(doneCb, timeout, updateCb);
         this._runCallbacksIfReady();
     }
@@ -31734,7 +31790,7 @@ class ApplicationRef {
         /** @internal */
         this._views = [];
         this.internalErrorHandler = inject(INTERNAL_APPLICATION_ERROR_HANDLER);
-        this.zoneIsStable = inject(ZONE_IS_STABLE_OBSERVABLE);
+        this.afterRenderEffectManager = inject(AfterRenderEventManager);
         /**
          * Get a list of component types registered to this application.
          * This list is populated even before the component is created.
@@ -31747,8 +31803,7 @@ class ApplicationRef {
         /**
          * Returns an Observable that indicates when the application is stable or unstable.
          */
-        this.isStable = inject(InitialRenderPendingTasks)
-            .hasPendingTasks.pipe(switchMap(hasPendingTasks => hasPendingTasks ? of(false) : this.zoneIsStable), distinctUntilChanged());
+        this.isStable = inject(PendingTasks).hasPendingTasks.pipe(map(pending => !pending));
         this._injector = inject(EnvironmentInjector);
     }
     /**
@@ -31806,10 +31861,12 @@ class ApplicationRef {
         const initStatus = this._injector.get(ApplicationInitStatus);
         if (!initStatus.done) {
             const standalone = !isComponentFactory && isStandalone(componentOrFactory);
-            const errorMessage = 'Cannot bootstrap as there are still asynchronous initializers running.' +
-                (standalone ? '' :
-                    ' Bootstrap components in the `ngDoBootstrap` method of the root module.');
-            throw new RuntimeError(405 /* RuntimeErrorCode.ASYNC_INITIALIZERS_STILL_RUNNING */, (typeof ngDevMode === 'undefined' || ngDevMode) && errorMessage);
+            const errorMessage = (typeof ngDevMode === 'undefined' || ngDevMode) &&
+                'Cannot bootstrap as there are still asynchronous initializers running.' +
+                    (standalone ?
+                        '' :
+                        ' Bootstrap components in the `ngDoBootstrap` method of the root module.');
+            throw new RuntimeError(405 /* RuntimeErrorCode.ASYNC_INITIALIZERS_STILL_RUNNING */, errorMessage);
         }
         let componentFactory;
         if (isComponentFactory) {
@@ -31870,6 +31927,18 @@ class ApplicationRef {
             this.internalErrorHandler(e);
         }
         finally {
+            // Catch any `ExpressionChanged...` errors and report them to error handler like above
+            try {
+                const callbacksExecuted = this.afterRenderEffectManager.execute();
+                if ((typeof ngDevMode === 'undefined' || ngDevMode) && callbacksExecuted) {
+                    for (let view of this._views) {
+                        view.checkNoChanges();
+                    }
+                }
+            }
+            catch (e) {
+                this.internalErrorHandler(e);
+            }
             this._runningTick = false;
         }
     }
@@ -32052,8 +32121,17 @@ function internalProvideZoneChangeDetection(ngZoneFactory) {
                 return () => ngZoneChangeDetectionScheduler.initialize();
             },
         },
+        {
+            provide: ENVIRONMENT_INITIALIZER,
+            multi: true,
+            useFactory: () => {
+                const service = inject(ZoneStablePendingTask);
+                return () => {
+                    service.initialize();
+                };
+            }
+        },
         { provide: INTERNAL_APPLICATION_ERROR_HANDLER, useFactory: ngZoneApplicationErrorHandlerFactory },
-        { provide: ZONE_IS_STABLE_OBSERVABLE, useFactory: isStableFactory },
     ];
 }
 function ngZoneApplicationErrorHandlerFactory() {
@@ -32099,6 +32177,50 @@ function getNgZoneOptions(options) {
         shouldCoalesceRunChangeDetection: options?.runCoalescing ?? false,
     };
 }
+class ZoneStablePendingTask {
+    constructor() {
+        this.subscription = new Subscription();
+        this.initialized = false;
+        this.zone = inject(NgZone);
+        this.pendingTasks = inject(PendingTasks);
+    }
+    initialize() {
+        if (this.initialized) {
+            return;
+        }
+        this.initialized = true;
+        let task = null;
+        if (!this.zone.isStable && !this.zone.hasPendingMacrotasks && !this.zone.hasPendingMicrotasks) {
+            task = this.pendingTasks.add();
+        }
+        this.zone.runOutsideAngular(() => {
+            this.subscription.add(this.zone.onStable.subscribe(() => {
+                NgZone.assertNotInAngularZone();
+                // Check whether there are no pending macro/micro tasks in the next tick
+                // to allow for NgZone to update the state.
+                queueMicrotask(() => {
+                    if (task !== null && !this.zone.hasPendingMacrotasks && !this.zone.hasPendingMicrotasks) {
+                        this.pendingTasks.remove(task);
+                        task = null;
+                    }
+                });
+            }));
+        });
+        this.subscription.add(this.zone.onUnstable.subscribe(() => {
+            NgZone.assertInAngularZone();
+            task ??= this.pendingTasks.add();
+        }));
+    }
+    ngOnDestroy() {
+        this.subscription.unsubscribe();
+    }
+    static { this.ɵfac = function ZoneStablePendingTask_Factory(t) { return new (t || ZoneStablePendingTask)(); }; }
+    static { this.ɵprov = /*@__PURE__*/ ɵɵdefineInjectable({ token: ZoneStablePendingTask, factory: ZoneStablePendingTask.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(ZoneStablePendingTask, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], null, null); })();
 
 /**
  * Work out the locale from the potential global properties.
@@ -33720,14 +33842,6 @@ function signalUpdateFn(node, updater) {
     }
     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.
@@ -34061,6 +34175,49 @@ function internalCreateApplication(config) {
     }
 }
 
+class ChangeDetectionSchedulerImpl {
+    constructor() {
+        this.appRef = inject(ApplicationRef);
+        this.taskService = inject(PendingTasks);
+        this.pendingRenderTaskId = null;
+    }
+    notify() {
+        if (this.pendingRenderTaskId !== null)
+            return;
+        this.pendingRenderTaskId = this.taskService.add();
+        setTimeout(() => {
+            try {
+                if (!this.appRef.destroyed) {
+                    this.appRef.tick();
+                }
+            }
+            finally {
+                // If this is the last task, the service will synchronously emit a stable notification. If
+                // there is a subscriber that then acts in a way that tries to notify the scheduler again,
+                // we need to be able to respond to schedule a new change detection. Therefore, we should
+                // clear the task ID before removing it from the pending tasks (or the tasks service should
+                // not synchronously emit stable, similar to how Zone stableness only happens if it's still
+                // stable after a microtask).
+                const taskId = this.pendingRenderTaskId;
+                this.pendingRenderTaskId = null;
+                this.taskService.remove(taskId);
+            }
+        });
+    }
+    static { this.ɵfac = function ChangeDetectionSchedulerImpl_Factory(t) { return new (t || ChangeDetectionSchedulerImpl)(); }; }
+    static { this.ɵprov = /*@__PURE__*/ ɵɵdefineInjectable({ token: ChangeDetectionSchedulerImpl, factory: ChangeDetectionSchedulerImpl.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(ChangeDetectionSchedulerImpl, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], null, null); })();
+function provideZonelessChangeDetection() {
+    return makeEnvironmentProviders([
+        { provide: ChangeDetectionScheduler, useExisting: ChangeDetectionSchedulerImpl },
+        { provide: NgZone, useClass: NoopNgZone },
+    ]);
+}
+
 /**
  * Retrieves all defer blocks in a given LView.
  *
@@ -35113,5 +35270,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, 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, EffectScheduler as ɵEffectScheduler, IMAGE_CONFIG as ɵIMAGE_CONFIG, IMAGE_CONFIG_DEFAULTS as ɵIMAGE_CONFIG_DEFAULTS, INJECTOR_SCOPE as ɵINJECTOR_SCOPE, ɵINPUT_SIGNAL_BRAND_WRITE_TYPE, IS_HYDRATION_DOM_REUSE_ENABLED as ɵIS_HYDRATION_DOM_REUSE_ENABLED, 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, devModeEqual as ɵdevModeEqual, findLocaleData as ɵfindLocaleData, flushModuleScopingQueueAsMuchAsPossible as ɵflushModuleScopingQueueAsMuchAsPossible, formatRuntimeError as ɵformatRuntimeError, generateStandaloneInDeclarationsError as ɵgenerateStandaloneInDeclarationsError, getAsyncClassMetadataFn as ɵgetAsyncClassMetadataFn, getDebugNode as ɵgetDebugNode, getDeferBlocks as ɵgetDeferBlocks, getDirectives as ɵgetDirectives, getHostElement as ɵgetHostElement, getInjectableDef as ɵgetInjectableDef, getLContext as ɵgetLContext, getLocaleCurrencyCode as ɵgetLocaleCurrencyCode, getLocalePluralCase as ɵgetLocalePluralCase, getSanitizationBypassType as ɵgetSanitizationBypassType, ɵgetUnknownElementStrictMode, ɵgetUnknownPropertyStrictMode, _global as ɵglobal, injectChangeDetectorRef as ɵinjectChangeDetectorRef, input as ɵinput, inputFunction as ɵinputFunctionForApiGuard, inputRequiredFunction as ɵinputFunctionRequiredForApiGuard, internalAfterNextRender as ɵinternalAfterNextRender, internalCreateApplication as ɵinternalCreateApplication, isBoundToModule as ɵisBoundToModule, isComponentDefPendingResolution as ɵisComponentDefPendingResolution, isEnvironmentProviders as ɵisEnvironmentProviders, isInjectable as ɵisInjectable, isNgModule as ɵisNgModule, isPromise as ɵisPromise, isSubscribable as ɵisSubscribable, noSideEffects as ɵnoSideEffects, patchComponentDefWithScope as ɵpatchComponentDefWithScope, performanceMarkFeature as ɵperformanceMarkFeature, 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 };
+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, input, 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, ChangeDetectionScheduler as ɵChangeDetectionScheduler, ComponentFactory$1 as ɵComponentFactory, Console as ɵConsole, DEFAULT_LOCALE_ID as ɵDEFAULT_LOCALE_ID, DEFER_BLOCK_CONFIG as ɵDEFER_BLOCK_CONFIG, DEFER_BLOCK_DEPENDENCY_INTERCEPTOR as ɵDEFER_BLOCK_DEPENDENCY_INTERCEPTOR, DeferBlockBehavior as ɵDeferBlockBehavior, DeferBlockState as ɵDeferBlockState, EffectScheduler as ɵEffectScheduler, IMAGE_CONFIG as ɵIMAGE_CONFIG, IMAGE_CONFIG_DEFAULTS as ɵIMAGE_CONFIG_DEFAULTS, INJECTOR_SCOPE as ɵINJECTOR_SCOPE, ɵINPUT_SIGNAL_BRAND_WRITE_TYPE, IS_HYDRATION_DOM_REUSE_ENABLED as ɵIS_HYDRATION_DOM_REUSE_ENABLED, LContext as ɵLContext, LifecycleHooksFeature as ɵLifecycleHooksFeature, LocaleDataIndex as ɵLocaleDataIndex, NG_COMP_DEF as ɵNG_COMP_DEF, NG_DIR_DEF as ɵNG_DIR_DEF, NG_ELEMENT_ID as ɵNG_ELEMENT_ID, NG_INJ_DEF as ɵNG_INJ_DEF, NG_MOD_DEF as ɵNG_MOD_DEF, NG_PIPE_DEF as ɵNG_PIPE_DEF, NG_PROV_DEF as ɵNG_PROV_DEF, NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR as ɵNOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR, NO_CHANGE as ɵNO_CHANGE, NgModuleFactory as ɵNgModuleFactory, NoopNgZone as ɵNoopNgZone, PendingTasks as ɵPendingTasks, ReflectionCapabilities as ɵReflectionCapabilities, ComponentFactory as ɵRender3ComponentFactory, ComponentRef as ɵRender3ComponentRef, NgModuleRef as ɵRender3NgModuleRef, RuntimeError as ɵRuntimeError, SSR_CONTENT_INTEGRITY_MARKER as ɵSSR_CONTENT_INTEGRITY_MARKER, TESTABILITY as ɵTESTABILITY, TESTABILITY_GETTER as ɵTESTABILITY_GETTER, USE_RUNTIME_DEPS_TRACKER_FOR_JIT as ɵUSE_RUNTIME_DEPS_TRACKER_FOR_JIT, ViewRef$1 as ɵViewRef, XSS_SECURITY_URL as ɵXSS_SECURITY_URL, 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, devModeEqual as ɵdevModeEqual, findLocaleData as ɵfindLocaleData, flushModuleScopingQueueAsMuchAsPossible as ɵflushModuleScopingQueueAsMuchAsPossible, formatRuntimeError as ɵformatRuntimeError, generateStandaloneInDeclarationsError as ɵgenerateStandaloneInDeclarationsError, getAsyncClassMetadataFn as ɵgetAsyncClassMetadataFn, getDebugNode as ɵgetDebugNode, getDeferBlocks as ɵgetDeferBlocks, getDirectives as ɵgetDirectives, getEnsureDirtyViewsAreAlwaysReachable as ɵgetEnsureDirtyViewsAreAlwaysReachable, getHostElement as ɵgetHostElement, getInjectableDef as ɵgetInjectableDef, getLContext as ɵgetLContext, getLocaleCurrencyCode as ɵgetLocaleCurrencyCode, getLocalePluralCase as ɵgetLocalePluralCase, getSanitizationBypassType as ɵgetSanitizationBypassType, ɵgetUnknownElementStrictMode, ɵgetUnknownPropertyStrictMode, _global as ɵglobal, injectChangeDetectorRef as ɵinjectChangeDetectorRef, internalAfterNextRender as ɵinternalAfterNextRender, internalCreateApplication as ɵinternalCreateApplication, isBoundToModule as ɵisBoundToModule, isComponentDefPendingResolution as ɵisComponentDefPendingResolution, isEnvironmentProviders as ɵisEnvironmentProviders, isInjectable as ɵisInjectable, isNgModule as ɵisNgModule, isPromise as ɵisPromise, isSubscribable as ɵisSubscribable, noSideEffects as ɵnoSideEffects, patchComponentDefWithScope as ɵpatchComponentDefWithScope, performanceMarkFeature as ɵperformanceMarkFeature, provideZonelessChangeDetection as ɵprovideZonelessChangeDetection, registerLocaleData as ɵregisterLocaleData, renderDeferBlockState as ɵrenderDeferBlockState, resetCompiledComponents as ɵresetCompiledComponents, resetJitOptions as ɵresetJitOptions, resolveComponentResources as ɵresolveComponentResources, restoreComponentResolutionQueue as ɵrestoreComponentResolutionQueue, setAllowDuplicateNgModuleIdsForTest as ɵsetAllowDuplicateNgModuleIdsForTest, setAlternateWeakRefImpl as ɵsetAlternateWeakRefImpl, ɵsetClassDebugInfo, setClassMetadata as ɵsetClassMetadata, setClassMetadataAsync as ɵsetClassMetadataAsync, setCurrentInjector as ɵsetCurrentInjector, setDocument as ɵsetDocument, setEnsureDirtyViewsAreAlwaysReachable as ɵsetEnsureDirtyViewsAreAlwaysReachable, setInjectorProfilerContext as ɵsetInjectorProfilerContext, setLocaleId as ɵsetLocaleId, ɵsetUnknownElementStrictMode, ɵsetUnknownPropertyStrictMode, store as ɵstore, stringify as ɵstringify, transitiveScopesFor as ɵtransitiveScopesFor, triggerResourceLoading as ɵtriggerResourceLoading, truncateMiddle as ɵtruncateMiddle, unregisterAllLocaleData as ɵunregisterLocaleData, unwrapSafeValue as ɵunwrapSafeValue, whenStable as ɵwhenStable, withDomHydration as ɵwithDomHydration, ɵɵCopyDefinitionFeature, FactoryTarget as ɵɵFactoryTarget, ɵɵHostDirectivesFeature, ɵɵInheritDefinitionFeature, InputFlags as ɵɵInputFlags, ɵɵInputTransformsFeature, ɵɵNgOnChangesFeature, ɵɵProvidersFeature, ɵɵStandaloneFeature, ɵɵadvance, ɵɵattribute, ɵɵattributeInterpolate1, ɵɵattributeInterpolate2, ɵɵattributeInterpolate3, ɵɵattributeInterpolate4, ɵɵattributeInterpolate5, ɵɵattributeInterpolate6, ɵɵattributeInterpolate7, ɵɵattributeInterpolate8, ɵɵattributeInterpolateV, ɵɵclassMap, ɵɵclassMapInterpolate1, ɵɵclassMapInterpolate2, ɵɵclassMapInterpolate3, ɵɵclassMapInterpolate4, ɵɵclassMapInterpolate5, ɵɵclassMapInterpolate6, ɵɵclassMapInterpolate7, ɵɵclassMapInterpolate8, ɵɵclassMapInterpolateV, ɵɵclassProp, ɵɵcomponentInstance, ɵɵconditional, ɵɵcontentQuery, ɵɵ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