@angular/core 17.0.0-next.3 → 17.0.0-next.5

package/fesm2022/core.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v17.0.0-next.3
+ * @license Angular v17.0.0-next.5
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -2264,7 +2264,7 @@ function getFactoryDef(type, throwNotFound) {
  *
  * This can be used to auto-unwrap signals in various cases, or to auto-wrap non-signal values.
  */
-const SIGNAL = Symbol('SIGNAL');
+const SIGNAL = /* @__PURE__ */ Symbol('SIGNAL');
 /**
  * Checks if the given `value` is a reactive `Signal`.
  *
@@ -2304,6 +2304,9 @@ function setActiveConsumer(consumer) {
     activeConsumer = consumer;
     return prev;
 }
+function isInNotificationPhase() {
+    return inNotificationPhase;
+}
 const REACTIVE_NODE = {
     version: 0,
     dirty: false,
@@ -2442,7 +2445,9 @@ function consumerAfterComputation(node, prevConsumer) {
         }
     }
     // Truncate the producer tracking arrays.
-    for (let i = node.nextProducerIndex; i < node.producerNode.length; i++) {
+    // Perf note: this is essentially truncating the length to `node.nextProducerIndex`, but
+    // benchmarking has shown that individual pop operations are faster.
+    while (node.producerNode.length > node.nextProducerIndex) {
         node.producerNode.pop();
         node.producerLastReadVersion.pop();
         node.producerIndexOfThis.pop();
@@ -2516,6 +2521,9 @@ function producerAddLiveConsumer(node, consumer, indexOfThis) {
 function producerRemoveLiveConsumerAtIndex(node, idx) {
     assertProducerNode(node);
     assertConsumerNode(node);
+    if (typeof ngDevMode !== 'undefined' && ngDevMode && idx >= node.liveConsumerNode.length) {
+        throw new Error(`Assertion error: active consumer index ${idx} is out of bounds of ${node.liveConsumerNode.length} consumers)`);
+    }
     if (node.liveConsumerNode.length === 1) {
         // When removing the last live consumer, we will no longer be live. We need to remove
         // ourselves from our producers' tracking (which may cause consumer-producers to lose
@@ -2580,60 +2588,65 @@ function computed(computation, options) {
  * A dedicated symbol used before a computed value has been calculated for the first time.
  * Explicitly typed as `any` so we can use it as signal's value.
  */
-const UNSET = Symbol('UNSET');
+const UNSET = /* @__PURE__ */ Symbol('UNSET');
 /**
  * A dedicated symbol used in place of a computed signal value to indicate that a given computation
  * is in progress. Used to detect cycles in computation chains.
  * Explicitly typed as `any` so we can use it as signal's value.
  */
-const COMPUTING = Symbol('COMPUTING');
+const COMPUTING = /* @__PURE__ */ Symbol('COMPUTING');
 /**
  * A dedicated symbol used in place of a computed signal value to indicate that a given computation
  * failed. The thrown error is cached until the computation gets dirty again.
  * Explicitly typed as `any` so we can use it as signal's value.
  */
-const ERRORED = Symbol('ERRORED');
-const COMPUTED_NODE = {
-    ...REACTIVE_NODE,
-    value: UNSET,
-    dirty: true,
-    error: null,
-    equal: defaultEquals,
-    producerMustRecompute(node) {
-        // Force a recomputation if there's no current value, or if the current value is in the process
-        // of being calculated (which should throw an error).
-        return node.value === UNSET || node.value === COMPUTING;
-    },
-    producerRecomputeValue(node) {
-        if (node.value === COMPUTING) {
-            // Our computation somehow led to a cyclic read of itself.
-            throw new Error('Detected cycle in computations.');
-        }
-        const oldValue = node.value;
-        node.value = COMPUTING;
-        const prevConsumer = consumerBeforeComputation(node);
-        let newValue;
-        try {
-            newValue = node.computation();
-        }
-        catch (err) {
-            newValue = ERRORED;
-            node.error = err;
-        }
-        finally {
-            consumerAfterComputation(node, prevConsumer);
-        }
-        if (oldValue !== UNSET && oldValue !== ERRORED && newValue !== ERRORED &&
-            node.equal(oldValue, newValue)) {
-            // No change to `valueVersion` - old and new values are
-            // semantically equivalent.
-            node.value = oldValue;
-            return;
-        }
-        node.value = newValue;
-        node.version++;
-    },
-};
+const ERRORED = /* @__PURE__ */ Symbol('ERRORED');
+// Note: Using an IIFE here to ensure that the spread assignment is not considered
+// a side-effect, ending up preserving `COMPUTED_NODE` and `REACTIVE_NODE`.
+// TODO: remove when https://github.com/evanw/esbuild/issues/3392 is resolved.
+const COMPUTED_NODE = /* @__PURE__ */ (() => {
+    return {
+        ...REACTIVE_NODE,
+        value: UNSET,
+        dirty: true,
+        error: null,
+        equal: defaultEquals,
+        producerMustRecompute(node) {
+            // Force a recomputation if there's no current value, or if the current value is in the
+            // process of being calculated (which should throw an error).
+            return node.value === UNSET || node.value === COMPUTING;
+        },
+        producerRecomputeValue(node) {
+            if (node.value === COMPUTING) {
+                // Our computation somehow led to a cyclic read of itself.
+                throw new Error('Detected cycle in computations.');
+            }
+            const oldValue = node.value;
+            node.value = COMPUTING;
+            const prevConsumer = consumerBeforeComputation(node);
+            let newValue;
+            try {
+                newValue = node.computation();
+            }
+            catch (err) {
+                newValue = ERRORED;
+                node.error = err;
+            }
+            finally {
+                consumerAfterComputation(node, prevConsumer);
+            }
+            if (oldValue !== UNSET && oldValue !== ERRORED && newValue !== ERRORED &&
+                node.equal(oldValue, newValue)) {
+                // No change to `valueVersion` - old and new values are
+                // semantically equivalent.
+                node.value = oldValue;
+                return;
+            }
+            node.value = newValue;
+            node.version++;
+        },
+    };
+})();
 
 function defaultThrowError() {
     throw new Error();
@@ -2678,11 +2691,16 @@ function setPostSignalSetFn(fn) {
     postSignalSetFn = fn;
     return prev;
 }
-const SIGNAL_NODE = {
-    ...REACTIVE_NODE,
-    equal: defaultEquals,
-    readonlyFn: undefined,
-};
+// Note: Using an IIFE here to ensure that the spread assignment is not considered
+// a side-effect, ending up preserving `COMPUTED_NODE` and `REACTIVE_NODE`.
+// TODO: remove when https://github.com/evanw/esbuild/issues/3392 is resolved.
+const SIGNAL_NODE = /* @__PURE__ */ (() => {
+    return {
+        ...REACTIVE_NODE,
+        equal: defaultEquals,
+        readonlyFn: undefined,
+    };
+})();
 function signalValueChanged(node) {
     node.version++;
     producerNotifyConsumers(node);
@@ -2751,7 +2769,27 @@ function watch(fn, schedule, allowSignalWrites) {
     const registerOnCleanup = (cleanupFn) => {
         node.cleanupFn = cleanupFn;
     };
+    function isWatchNodeDestroyed(node) {
+        return node.fn === null && node.schedule === null;
+    }
+    function destroyWatchNode(node) {
+        if (!isWatchNodeDestroyed(node)) {
+            consumerDestroy(node); // disconnect watcher from the reactive graph
+            node.cleanupFn();
+            // nullify references to the integration functions to mark node as destroyed
+            node.fn = null;
+            node.schedule = null;
+            node.cleanupFn = NOOP_CLEANUP_FN;
+        }
+    }
     const run = () => {
+        if (node.fn === null) {
+            // trying to run a destroyed watch is noop
+            return;
+        }
+        if (isInNotificationPhase()) {
+            throw new Error(`Schedulers cannot synchronously execute watches while scheduling.`);
+        }
         node.dirty = false;
         if (node.hasRun && !consumerPollProducersForChange(node)) {
             return;
@@ -2771,20 +2809,28 @@ function watch(fn, schedule, allowSignalWrites) {
         notify: () => consumerMarkDirty(node),
         run,
         cleanup: () => node.cleanupFn(),
+        destroy: () => destroyWatchNode(node),
     };
     return node.ref;
 }
 const NOOP_CLEANUP_FN = () => { };
-const WATCH_NODE = {
-    ...REACTIVE_NODE,
-    consumerIsAlwaysLive: true,
-    consumerAllowSignalWrites: false,
-    consumerMarkedDirty: (node) => {
-        node.schedule(node.ref);
-    },
-    hasRun: false,
-    cleanupFn: NOOP_CLEANUP_FN,
-};
+// Note: Using an IIFE here to ensure that the spread assignment is not considered
+// a side-effect, ending up preserving `COMPUTED_NODE` and `REACTIVE_NODE`.
+// TODO: remove when https://github.com/evanw/esbuild/issues/3392 is resolved.
+const WATCH_NODE = /* @__PURE__ */ (() => {
+    return {
+        ...REACTIVE_NODE,
+        consumerIsAlwaysLive: true,
+        consumerAllowSignalWrites: false,
+        consumerMarkedDirty: (node) => {
+            if (node.schedule !== null) {
+                node.schedule(node.ref);
+            }
+        },
+        hasRun: false,
+        cleanupFn: NOOP_CLEANUP_FN,
+    };
+})();
 
 function setAlternateWeakRefImpl(impl) {
     // TODO: remove this function
@@ -5861,19 +5907,32 @@ function resolveComponentResources(resourceResolver) {
                 component.template = template;
             }));
         }
-        const styleUrls = component.styleUrls;
-        const styles = component.styles || (component.styles = []);
-        const styleOffset = component.styles.length;
-        styleUrls && styleUrls.forEach((styleUrl, index) => {
-            styles.push(''); // pre-allocate array.
-            promises.push(cachedResourceResolve(styleUrl).then((style) => {
-                styles[styleOffset + index] = style;
-                styleUrls.splice(styleUrls.indexOf(styleUrl), 1);
-                if (styleUrls.length == 0) {
-                    component.styleUrls = undefined;
-                }
+        const styles = typeof component.styles === 'string' ? [component.styles] : (component.styles || []);
+        component.styles = styles;
+        if (component.styleUrl && component.styleUrls?.length) {
+            throw new Error('@Component cannot define both `styleUrl` and `styleUrls`. ' +
+                'Use `styleUrl` if the component has one stylesheet, or `styleUrls` if it has multiple');
+        }
+        else if (component.styleUrls?.length) {
+            const styleOffset = component.styles.length;
+            const styleUrls = component.styleUrls;
+            component.styleUrls.forEach((styleUrl, index) => {
+                styles.push(''); // pre-allocate array.
+                promises.push(cachedResourceResolve(styleUrl).then((style) => {
+                    styles[styleOffset + index] = style;
+                    styleUrls.splice(styleUrls.indexOf(styleUrl), 1);
+                    if (styleUrls.length == 0) {
+                        component.styleUrls = undefined;
+                    }
+                }));
+            });
+        }
+        else if (component.styleUrl) {
+            promises.push(cachedResourceResolve(component.styleUrl).then((style) => {
+                styles.push(style);
+                component.styleUrl = undefined;
             }));
-        });
+        }
         const fullyResolved = Promise.all(promises).then(() => componentDefResolved(type));
         componentResolved.push(fullyResolved);
     });
@@ -5894,7 +5953,7 @@ function isComponentDefPendingResolution(type) {
 }
 function componentNeedsResolution(component) {
     return !!((component.templateUrl && !component.hasOwnProperty('template')) ||
-        component.styleUrls && component.styleUrls.length);
+        (component.styleUrls && component.styleUrls.length) || component.styleUrl);
 }
 function clearResolutionOfComponentResourcesQueue() {
     const old = componentResourceResolutionQueue;
@@ -6368,8 +6427,7 @@ class R3Injector extends EnvironmentInjector {
         if (record != null && typeof record.value === 'string') {
             this.scopes.add(record.value);
         }
-        this.injectorDefTypes =
-            new Set(this.get(INJECTOR_DEF_TYPES.multi, EMPTY_ARRAY, InjectFlags.Self));
+        this.injectorDefTypes = new Set(this.get(INJECTOR_DEF_TYPES, EMPTY_ARRAY, InjectFlags.Self));
     }
     /**
      * Destroy the injector and release references to every instance or provider associated with it.
@@ -6503,7 +6561,7 @@ class R3Injector extends EnvironmentInjector {
             prevInjectContext = setInjectorProfilerContext({ injector: this, token: null });
         }
         try {
-            const initializers = this.get(ENVIRONMENT_INITIALIZER.multi, EMPTY_ARRAY, InjectFlags.Self);
+            const initializers = this.get(ENVIRONMENT_INITIALIZER, EMPTY_ARRAY, InjectFlags.Self);
             if (ngDevMode && !Array.isArray(initializers)) {
                 throw new RuntimeError(-209 /* RuntimeErrorCode.INVALID_MULTI_PROVIDER */, 'Unexpected type of the `ENVIRONMENT_INITIALIZER` token value ' +
                     `(expected an array, but got ${typeof initializers}). ` +
@@ -7305,12 +7363,13 @@ class DepsTracker {
                 dependencies: [
                     ...scope.compilation.directives,
                     ...scope.compilation.pipes,
+                    ...scope.compilation.ngModules,
                 ]
             };
         }
         else {
             if (!this.ownerNgModule.has(type)) {
-                return { dependencies: [] };
+                throw new RuntimeError(1001 /* RuntimeErrorCode.RUNTIME_DEPS_ORPHAN_COMPONENT */, `Orphan component found! Trying to render the component ${type.name} without first loading the NgModule that declares it. Make sure that you import the component's NgModule in the NgModule or the standalone component in which you are trying to render this component. Also make sure the way the app is bundled and served always includes the component's NgModule before the component.`);
             }
             const scope = this.getNgModuleScope(this.ownerNgModule.get(type));
             if (scope.compilation.isPoisoned) {
@@ -7417,6 +7476,12 @@ class DepsTracker {
                 // check for it.
                 addSet(exportedScope.exported.directives, scope.exported.directives);
                 addSet(exportedScope.exported.pipes, scope.exported.pipes);
+                // Some test toolings which run in JIT mode depend on this behavior that the exported scope
+                // should also be present in the compilation scope, even though AoT does not support this
+                // and it is also in odds with NgModule metadata definitions. Without this some tests in
+                // Google will fail.
+                addSet(exportedScope.exported.directives, scope.compilation.directives);
+                addSet(exportedScope.exported.pipes, scope.compilation.pipes);
             }
             else if (isPipe(exported)) {
                 scope.exported.pipes.add(exported);
@@ -7442,9 +7507,10 @@ class DepsTracker {
                 // Standalone components are always able to self-reference.
                 directives: new Set([type]),
                 pipes: new Set(),
+                ngModules: new Set(),
             },
         };
-        for (const rawImport of rawImports ?? []) {
+        for (const rawImport of flatten(rawImports ?? [])) {
             const imported = resolveForwardRef(rawImport);
             try {
                 verifyStandaloneImport(imported, type);
@@ -7455,6 +7521,7 @@ class DepsTracker {
                 return ans;
             }
             if (isNgModule(imported)) {
+                ans.compilation.ngModules.add(imported);
                 const importedScope = this.getNgModuleScope(imported);
                 // Short-circuit if an imported NgModule has corrupted exported scope.
                 if (importedScope.exported.isPoisoned) {
@@ -10834,7 +10901,7 @@ class Version {
 /**
  * @publicApi
  */
-const VERSION = new Version('17.0.0-next.3');
+const VERSION = new Version('17.0.0-next.5');
 
 // This default value is when checking the hierarchy for a token.
 //
@@ -10855,6 +10922,66 @@ const VERSION = new Version('17.0.0-next.3');
 // - mod2.injector.get(token, default)
 const NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR = {};
 
+const ERROR_ORIGINAL_ERROR = 'ngOriginalError';
+function wrappedError(message, originalError) {
+    const msg = `${message} caused by: ${originalError instanceof Error ? originalError.message : originalError}`;
+    const error = Error(msg);
+    error[ERROR_ORIGINAL_ERROR] = originalError;
+    return error;
+}
+function getOriginalError(error) {
+    return error[ERROR_ORIGINAL_ERROR];
+}
+
+/**
+ * Provides a hook for centralized exception handling.
+ *
+ * The default implementation of `ErrorHandler` prints error messages to the `console`. To
+ * intercept error handling, write a custom exception handler that replaces this default as
+ * appropriate for your app.
+ *
+ * @usageNotes
+ * ### Example
+ *
+ * ```
+ * class MyErrorHandler implements ErrorHandler {
+ *   handleError(error) {
+ *     // do something with the exception
+ *   }
+ * }
+ *
+ * @NgModule({
+ *   providers: [{provide: ErrorHandler, useClass: MyErrorHandler}]
+ * })
+ * class MyModule {}
+ * ```
+ *
+ * @publicApi
+ */
+class ErrorHandler {
+    constructor() {
+        /**
+         * @internal
+         */
+        this._console = console;
+    }
+    handleError(error) {
+        const originalError = this._findOriginalError(error);
+        this._console.error('ERROR', error);
+        if (originalError) {
+            this._console.error('ORIGINAL ERROR', originalError);
+        }
+    }
+    /** @internal */
+    _findOriginalError(error) {
+        let e = error && getOriginalError(error);
+        while (e && getOriginalError(e)) {
+            e = getOriginalError(e);
+        }
+        return e || null;
+    }
+}
+
 /**
  * `DestroyRef` lets you set callbacks to run for any cleanup or destruction behavior.
  * The scope of this destruction depends on where `DestroyRef` is injected. If `DestroyRef`
@@ -11460,10 +11587,77 @@ function shouldBeIgnoredByZone(applyArgs) {
 
 // Public API for Zone
 
+/**
+ * The phase to run an `afterRender` or `afterNextRender` callback in.
+ *
+ * Callbacks in the same phase run in the order they are registered. Phases run in the
+ * following order after each render:
+ *
+ *   1. `AfterRenderPhase.EarlyRead`
+ *   2. `AfterRenderPhase.Write`
+ *   3. `AfterRenderPhase.MixedReadWrite`
+ *   4. `AfterRenderPhase.Read`
+ *
+ * Angular is unable to verify or enforce that phases are used correctly, and instead
+ * relies on each developer to follow the guidelines documented for each value and
+ * carefully choose the appropriate one, refactoring their code if necessary. By doing
+ * so, Angular is better able to minimize the performance degradation associated with
+ * manual DOM access, ensuring the best experience for the end users of your application
+ * or library.
+ *
+ * @developerPreview
+ */
+var AfterRenderPhase;
+(function (AfterRenderPhase) {
+    /**
+     * Use `AfterRenderPhase.EarlyRead` for callbacks that only need to **read** from the
+     * DOM before a subsequent `AfterRenderPhase.Write` callback, for example to perform
+     * custom layout that the browser doesn't natively support. **Never** use this phase
+     * for callbacks that can write to the DOM or when `AfterRenderPhase.Read` is adequate.
+     *
+     * <div class="alert is-important">
+     *
+     * Using this value can degrade performance.
+     * Instead, prefer using built-in browser functionality when possible.
+     *
+     * </div>
+     */
+    AfterRenderPhase[AfterRenderPhase["EarlyRead"] = 0] = "EarlyRead";
+    /**
+     * Use `AfterRenderPhase.Write` for callbacks that only **write** to the DOM. **Never**
+     * use this phase for callbacks that can read from the DOM.
+     */
+    AfterRenderPhase[AfterRenderPhase["Write"] = 1] = "Write";
+    /**
+     * Use `AfterRenderPhase.MixedReadWrite` for callbacks that read from or write to the
+     * DOM, that haven't been refactored to use a different phase. **Never** use this phase
+     * for callbacks that can use a different phase instead.
+     *
+     * <div class="alert is-critical">
+     *
+     * Using this value can **significantly** degrade performance.
+     * Instead, prefer refactoring into multiple callbacks using a more specific phase.
+     *
+     * </div>
+     */
+    AfterRenderPhase[AfterRenderPhase["MixedReadWrite"] = 2] = "MixedReadWrite";
+    /**
+     * Use `AfterRenderPhase.Read` for callbacks that only **read** from the DOM. **Never**
+     * use this phase for callbacks that can write to the DOM.
+     */
+    AfterRenderPhase[AfterRenderPhase["Read"] = 3] = "Read";
+})(AfterRenderPhase || (AfterRenderPhase = {}));
 /**
  * Register a callback to be invoked each time the application
  * finishes rendering.
  *
+ * <div class="alert is-critical">
+ *
+ * You should always explicitly specify a non-default [phase](api/core/AfterRenderPhase), or you
+ * risk significant performance degradation.
+ *
+ * </div>
+ *
  * Note that the callback will run
  * - in the order it was registered
  * - once per render
@@ -11494,7 +11688,7 @@ function shouldBeIgnoredByZone(applyArgs) {
  *   constructor() {
  *     afterRender(() => {
  *       console.log('content height: ' + this.contentRef.nativeElement.scrollHeight);
- *     });
+ *     }, {phase: AfterRenderPhase.Read});
  *   }
  * }
  * ```
@@ -11509,23 +11703,32 @@ function afterRender(callback, options) {
     }
     let destroy;
     const unregisterFn = injector.get(DestroyRef).onDestroy(() => destroy?.());
-    const manager = injector.get(AfterRenderEventManager);
+    const afterRenderEventManager = injector.get(AfterRenderEventManager);
     // Lazily initialize the handler implementation, if necessary. This is so that it can be
     // tree-shaken if `afterRender` and `afterNextRender` aren't used.
-    const handler = manager.handler ??= new AfterRenderCallbackHandlerImpl();
+    const callbackHandler = afterRenderEventManager.handler ??= new AfterRenderCallbackHandlerImpl();
     const ngZone = injector.get(NgZone);
-    const instance = new AfterRenderCallback(() => ngZone.runOutsideAngular(callback));
+    const errorHandler = injector.get(ErrorHandler, null, { optional: true });
+    const phase = options?.phase ?? AfterRenderPhase.MixedReadWrite;
+    const instance = new AfterRenderCallback(ngZone, errorHandler, phase, callback);
     destroy = () => {
-        handler.unregister(instance);
+        callbackHandler.unregister(instance);
         unregisterFn();
     };
-    handler.register(instance);
+    callbackHandler.register(instance);
     return { destroy };
 }
 /**
  * Register a callback to be invoked the next time the application
  * finishes rendering.
  *
+ * <div class="alert is-critical">
+ *
+ * You should always explicitly specify a non-default [phase](api/core/AfterRenderPhase), or you
+ * risk significant performance degradation.
+ *
+ * </div>
+ *
  * Note that the callback will run
  * - in the order it was registered
  * - on browser platforms only
@@ -11557,7 +11760,7 @@ function afterRender(callback, options) {
  *   constructor() {
  *     afterNextRender(() => {
  *       this.chart = new MyChart(this.chartRef.nativeElement);
- *     });
+ *     }, {phase: AfterRenderPhase.Write});
  *   }
  * }
  * ```
@@ -11572,31 +11775,41 @@ function afterNextRender(callback, options) {
     }
     let destroy;
     const unregisterFn = injector.get(DestroyRef).onDestroy(() => destroy?.());
-    const manager = injector.get(AfterRenderEventManager);
+    const afterRenderEventManager = injector.get(AfterRenderEventManager);
     // Lazily initialize the handler implementation, if necessary. This is so that it can be
     // tree-shaken if `afterRender` and `afterNextRender` aren't used.
-    const handler = manager.handler ??= new AfterRenderCallbackHandlerImpl();
+    const callbackHandler = afterRenderEventManager.handler ??= new AfterRenderCallbackHandlerImpl();
     const ngZone = injector.get(NgZone);
-    const instance = new AfterRenderCallback(() => {
+    const errorHandler = injector.get(ErrorHandler, null, { optional: true });
+    const phase = options?.phase ?? AfterRenderPhase.MixedReadWrite;
+    const instance = new AfterRenderCallback(ngZone, errorHandler, phase, () => {
         destroy?.();
-        ngZone.runOutsideAngular(callback);
+        callback();
     });
     destroy = () => {
-        handler.unregister(instance);
+        callbackHandler.unregister(instance);
         unregisterFn();
     };
-    handler.register(instance);
+    callbackHandler.register(instance);
     return { destroy };
 }
 /**
  * A wrapper around a function to be used as an after render callback.
  */
 class AfterRenderCallback {
-    constructor(callback) {
-        this.callback = callback;
+    constructor(zone, errorHandler, phase, callbackFn) {
+        this.zone = zone;
+        this.errorHandler = errorHandler;
+        this.phase = phase;
+        this.callbackFn = callbackFn;
     }
     invoke() {
-        this.callback();
+        try {
+            this.zone.runOutsideAngular(this.callbackFn);
+        }
+        catch (err) {
+            this.errorHandler?.handleError(err);
+        }
     }
 }
 /**
@@ -11606,7 +11819,13 @@ class AfterRenderCallback {
 class AfterRenderCallbackHandlerImpl {
     constructor() {
         this.executingCallbacks = false;
-        this.callbacks = new Set();
+        this.buckets = {
+            // Note: the order of these keys controls the order the phases are run.
+            [AfterRenderPhase.EarlyRead]: new Set(),
+            [AfterRenderPhase.Write]: new Set(),
+            [AfterRenderPhase.MixedReadWrite]: new Set(),
+            [AfterRenderPhase.Read]: new Set(),
+        };
         this.deferredCallbacks = new Set();
     }
     validateBegin() {
@@ -11619,30 +11838,30 @@ class AfterRenderCallbackHandlerImpl {
     register(callback) {
         // If we're currently running callbacks, new callbacks should be deferred
         // until the next render operation.
-        const target = this.executingCallbacks ? this.deferredCallbacks : this.callbacks;
+        const target = this.executingCallbacks ? this.deferredCallbacks : this.buckets[callback.phase];
         target.add(callback);
     }
     unregister(callback) {
-        this.callbacks.delete(callback);
+        this.buckets[callback.phase].delete(callback);
         this.deferredCallbacks.delete(callback);
     }
     execute() {
-        try {
-            this.executingCallbacks = true;
-            for (const callback of this.callbacks) {
+        this.executingCallbacks = true;
+        for (const bucket of Object.values(this.buckets)) {
+            for (const callback of bucket) {
                 callback.invoke();
             }
         }
-        finally {
-            this.executingCallbacks = false;
-            for (const callback of this.deferredCallbacks) {
-                this.callbacks.add(callback);
-            }
-            this.deferredCallbacks.clear();
+        this.executingCallbacks = false;
+        for (const callback of this.deferredCallbacks) {
+            this.buckets[callback.phase].add(callback);
         }
+        this.deferredCallbacks.clear();
     }
     destroy() {
-        this.callbacks.clear();
+        for (const bucket of Object.values(this.buckets)) {
+            bucket.clear();
+        }
         this.deferredCallbacks.clear();
     }
 }
@@ -11712,66 +11931,6 @@ function markViewDirty(lView) {
     return null;
 }
 
-const ERROR_ORIGINAL_ERROR = 'ngOriginalError';
-function wrappedError(message, originalError) {
-    const msg = `${message} caused by: ${originalError instanceof Error ? originalError.message : originalError}`;
-    const error = Error(msg);
-    error[ERROR_ORIGINAL_ERROR] = originalError;
-    return error;
-}
-function getOriginalError(error) {
-    return error[ERROR_ORIGINAL_ERROR];
-}
-
-/**
- * Provides a hook for centralized exception handling.
- *
- * The default implementation of `ErrorHandler` prints error messages to the `console`. To
- * intercept error handling, write a custom exception handler that replaces this default as
- * appropriate for your app.
- *
- * @usageNotes
- * ### Example
- *
- * ```
- * class MyErrorHandler implements ErrorHandler {
- *   handleError(error) {
- *     // do something with the exception
- *   }
- * }
- *
- * @NgModule({
- *   providers: [{provide: ErrorHandler, useClass: MyErrorHandler}]
- * })
- * class MyModule {}
- * ```
- *
- * @publicApi
- */
-class ErrorHandler {
-    constructor() {
-        /**
-         * @internal
-         */
-        this._console = console;
-    }
-    handleError(error) {
-        const originalError = this._findOriginalError(error);
-        this._console.error('ERROR', error);
-        if (originalError) {
-            this._console.error('ORIGINAL ERROR', originalError);
-        }
-    }
-    /** @internal */
-    _findOriginalError(error) {
-        let e = error && getOriginalError(error);
-        while (e && getOriginalError(e)) {
-            e = getOriginalError(e);
-        }
-        return e || null;
-    }
-}
-
 /**
  * Internal token that specifies whether DOM reuse logic
  * during hydration is enabled.
@@ -13480,74 +13639,6 @@ function renderChildComponents(hostLView, components) {
     }
 }
 
-/**
- * Tracks all effects registered within a given application and runs them via `flush`.
- */
-class EffectManager {
-    constructor() {
-        this.all = new Set();
-        this.queue = new Map();
-    }
-    create(effectFn, destroyRef, allowSignalWrites) {
-        const zone = (typeof Zone === 'undefined') ? null : Zone.current;
-        const w = watch(effectFn, (watch) => {
-            if (!this.all.has(watch)) {
-                return;
-            }
-            this.queue.set(watch, zone);
-        }, allowSignalWrites);
-        this.all.add(w);
-        // Effects start dirty.
-        w.notify();
-        let unregisterOnDestroy;
-        const destroy = () => {
-            w.cleanup();
-            unregisterOnDestroy?.();
-            this.all.delete(w);
-            this.queue.delete(w);
-        };
-        unregisterOnDestroy = destroyRef?.onDestroy(destroy);
-        return {
-            destroy,
-        };
-    }
-    flush() {
-        if (this.queue.size === 0) {
-            return;
-        }
-        for (const [watch, zone] of this.queue) {
-            this.queue.delete(watch);
-            if (zone) {
-                zone.run(() => watch.run());
-            }
-            else {
-                watch.run();
-            }
-        }
-    }
-    get isQueueEmpty() {
-        return this.queue.size === 0;
-    }
-    /** @nocollapse */
-    static { this.ɵprov = ɵɵdefineInjectable({
-        token: EffectManager,
-        providedIn: 'root',
-        factory: () => new EffectManager(),
-    }); }
-}
-/**
- * Create a global `Effect` for the given reactive function.
- *
- * @developerPreview
- */
-function effect(effectFn, options) {
-    !options?.injector && assertInInjectionContext(effect);
-    const injector = options?.injector ?? inject(Injector);
-    const effectManager = injector.get(EffectManager);
-    const destroyRef = options?.manualCleanup !== true ? injector.get(DestroyRef) : null;
-    return effectManager.create(effectFn, destroyRef, !!options?.allowSignalWrites);
-}
-
 /**
  * Compute the static styling (class/style) from `TAttributes`.
  *
@@ -13680,7 +13771,7 @@ function detectChangesInternal(tView, lView, context, notifyErrorHandler = true)
             rendererFactory.end?.();
             // One final flush of the effects queue to catch any effects created in `ngAfterViewInit` or
             // other post-order hooks.
-            environment.effectManager?.flush();
+            environment.inlineEffectRunner?.flush();
             // Invoke all callbacks registered via `after*Render`, if needed.
             afterRenderEventManager?.end();
         }
@@ -13722,7 +13813,7 @@ function refreshView(tView, lView, templateFn, context) {
     // 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 execute lifecycle hooks in that mode.
     const isInCheckNoChangesPass = ngDevMode && isInCheckNoChangesMode();
-    !isInCheckNoChangesPass && lView[ENVIRONMENT].effectManager?.flush();
+    !isInCheckNoChangesPass && lView[ENVIRONMENT].inlineEffectRunner?.flush();
     enterView(lView);
     try {
         resetPreOrderHookFlags(lView);
@@ -14302,12 +14393,12 @@ class ComponentFactory extends ComponentFactory$1 {
                     'Make sure that any injector used to create this component has a correct parent.');
         }
         const sanitizer = rootViewInjector.get(Sanitizer, null);
-        const effectManager = rootViewInjector.get(EffectManager, null);
         const afterRenderEventManager = rootViewInjector.get(AfterRenderEventManager, null);
         const environment = {
             rendererFactory,
             sanitizer,
-            effectManager,
+            // We don't use inline effects (yet).
+            inlineEffectRunner: null,
             afterRenderEventManager,
         };
         const hostRenderer = rendererFactory.createRenderer(null, this.componentDef);
@@ -20281,7 +20372,72 @@ function enableLocateOrCreateContainerRefImpl() {
     _populateDehydratedViewsInContainer = populateDehydratedViewsInContainerImpl;
 }
 
+/**
+ * Describes the state of defer block dependency loading.
+ */
+var DeferDependenciesLoadingState;
+(function (DeferDependenciesLoadingState) {
+    /** Initial state, dependency loading is not yet triggered */
+    DeferDependenciesLoadingState[DeferDependenciesLoadingState["NOT_STARTED"] = 0] = "NOT_STARTED";
+    /** Dependency loading was scheduled (e.g. `on idle`), but has not started yet */
+    DeferDependenciesLoadingState[DeferDependenciesLoadingState["SCHEDULED"] = 1] = "SCHEDULED";
+    /** Dependency loading is in progress */
+    DeferDependenciesLoadingState[DeferDependenciesLoadingState["IN_PROGRESS"] = 2] = "IN_PROGRESS";
+    /** Dependency loading has completed successfully */
+    DeferDependenciesLoadingState[DeferDependenciesLoadingState["COMPLETE"] = 3] = "COMPLETE";
+    /** Dependency loading has failed */
+    DeferDependenciesLoadingState[DeferDependenciesLoadingState["FAILED"] = 4] = "FAILED";
+})(DeferDependenciesLoadingState || (DeferDependenciesLoadingState = {}));
+/**
+ * Describes the current state of this {#defer} block instance.
+ *
+ * @publicApi
+ * @developerPreview
+ */
+var DeferBlockState;
+(function (DeferBlockState) {
+    /** The {:placeholder} block content is rendered */
+    DeferBlockState[DeferBlockState["Placeholder"] = 0] = "Placeholder";
+    /** The {:loading} block content is rendered */
+    DeferBlockState[DeferBlockState["Loading"] = 1] = "Loading";
+    /** The main content block content is rendered */
+    DeferBlockState[DeferBlockState["Complete"] = 2] = "Complete";
+    /** The {:error} block content is rendered */
+    DeferBlockState[DeferBlockState["Error"] = 3] = "Error";
+})(DeferBlockState || (DeferBlockState = {}));
+/**
+ * Describes the initial state of this {#defer} block instance.
+ *
+ * Note: this state is internal only and *must* be represented
+ * with a number lower than any value in the `DeferBlockState` enum.
+ */
+var DeferBlockInternalState;
+(function (DeferBlockInternalState) {
+    /** Initial state. Nothing is rendered yet. */
+    DeferBlockInternalState[DeferBlockInternalState["Initial"] = -1] = "Initial";
+})(DeferBlockInternalState || (DeferBlockInternalState = {}));
+/**
+ * A slot in the `LDeferBlockDetails` array that contains a number
+ * that represent a current block state that is being rendered.
+ */
 const DEFER_BLOCK_STATE = 0;
+/**
+ * Options for configuring defer blocks behavior.
+ * @publicApi
+ * @developerPreview
+ */
+var DeferBlockBehavior;
+(function (DeferBlockBehavior) {
+    /**
+     * Manual triggering mode for defer blocks. Provides control over when defer blocks render
+     * and which state they render. This is the default behavior in test environments.
+     */
+    DeferBlockBehavior[DeferBlockBehavior["Manual"] = 0] = "Manual";
+    /**
+     * Playthrough mode for defer blocks. This mode behaves like defer blocks would in a browser.
+     */
+    DeferBlockBehavior[DeferBlockBehavior["Playthrough"] = 1] = "Playthrough";
+})(DeferBlockBehavior || (DeferBlockBehavior = {}));
 
 /**
  * Returns whether defer blocks should be triggered.
@@ -20290,6 +20446,10 @@ const DEFER_BLOCK_STATE = 0;
  * only placeholder content is rendered (if provided).
  */
 function shouldTriggerDeferBlock(injector) {
+    const config = injector.get(DEFER_BLOCK_CONFIG, { optional: true });
+    if (config?.behavior === DeferBlockBehavior.Manual) {
+        return false;
+    }
     return isPlatformBrowser(injector);
 }
 /**
@@ -20333,7 +20493,7 @@ function ɵɵdefer(index, primaryTmplIndex, dependencyResolverFn, loadingTmplInd
                 getConstant(tViewConsts, loadingConfigIndex) :
                 null,
             dependencyResolverFn: dependencyResolverFn ?? null,
-            loadingState: 0 /* DeferDependenciesLoadingState.NOT_STARTED */,
+            loadingState: DeferDependenciesLoadingState.NOT_STARTED,
             loadingPromise: null,
         };
         setTDeferBlockDetails(tView, adjustedIndex, deferBlockConfig);
@@ -20344,7 +20504,7 @@ function ɵɵdefer(index, primaryTmplIndex, dependencyResolverFn, loadingTmplInd
     populateDehydratedViewsInContainer(lContainer);
     // Init instance-specific defer details and store it.
     const lDetails = [];
-    lDetails[DEFER_BLOCK_STATE] = 0 /* DeferBlockInstanceState.INITIAL */;
+    lDetails[DEFER_BLOCK_STATE] = DeferBlockInternalState.Initial;
     setLDeferBlockDetails(lView, adjustedIndex, lDetails);
 }
 /**
@@ -20359,13 +20519,13 @@ function ɵɵdeferWhen(rawValue) {
         const tNode = getSelectedTNode();
         const lDetails = getLDeferBlockDetails(lView, tNode);
         const renderedState = lDetails[DEFER_BLOCK_STATE];
-        if (value === false && renderedState === 0 /* DeferBlockInstanceState.INITIAL */) {
+        if (value === false && renderedState === DeferBlockInternalState.Initial) {
             // If nothing is rendered yet, render a placeholder (if defined).
             renderPlaceholder(lView, tNode);
         }
         else if (value === true &&
-            (renderedState === 0 /* DeferBlockInstanceState.INITIAL */ ||
-                renderedState === 1 /* DeferBlockInstanceState.PLACEHOLDER */)) {
+            (renderedState === DeferBlockInternalState.Initial ||
+                renderedState === DeferBlockState.Placeholder)) {
             // The `when` condition has changed to `true`, trigger defer block loading
             // if the block is either in initial (nothing is rendered) or a placeholder
             // state.
@@ -20385,9 +20545,9 @@ function ɵɵdeferPrefetchWhen(rawValue) {
         const tView = lView[TVIEW];
         const tNode = getSelectedTNode();
         const tDetails = getTDeferBlockDetails(tView, tNode);
-        if (value === true && tDetails.loadingState === 0 /* DeferDependenciesLoadingState.NOT_STARTED */) {
+        if (value === true && tDetails.loadingState === DeferDependenciesLoadingState.NOT_STARTED) {
             // If loading has not been started yet, trigger it now.
-            triggerResourceLoading(tDetails, tView, lView);
+            triggerPrefetching(tDetails, lView);
         }
     }
 }
@@ -20413,14 +20573,14 @@ function ɵɵdeferPrefetchOnIdle() {
     const tNode = getCurrentTNode();
     const tView = lView[TVIEW];
     const tDetails = getTDeferBlockDetails(tView, tNode);
-    if (tDetails.loadingState === 0 /* DeferDependenciesLoadingState.NOT_STARTED */) {
+    if (tDetails.loadingState === DeferDependenciesLoadingState.NOT_STARTED) {
         // Set loading to the scheduled state, so that we don't register it again.
-        tDetails.loadingState = 1 /* DeferDependenciesLoadingState.SCHEDULED */;
+        tDetails.loadingState = DeferDependenciesLoadingState.SCHEDULED;
         // In case of prefetching, we intentionally avoid cancelling prefetching if
         // an underlying LView get destroyed (thus passing `null` as a second argument),
         // because there might be other LViews (that represent embedded views) that
         // depend on resource loading.
-        onIdle(() => triggerResourceLoading(tDetails, tView, lView), null /* LView */);
+        onIdle(() => triggerPrefetching(tDetails, lView), null /* LView */);
     }
 }
 /**
@@ -20544,6 +20704,23 @@ function setTDeferBlockDetails(tView, deferBlockIndex, deferBlockConfig) {
     ngDevMode && assertIndexInDeclRange(tView, slotIndex);
     tView.data[slotIndex] = deferBlockConfig;
 }
+function getTemplateIndexForState(newState, hostLView, tNode) {
+    const tView = hostLView[TVIEW];
+    const tDetails = getTDeferBlockDetails(tView, tNode);
+    switch (newState) {
+        case DeferBlockState.Complete:
+            return tDetails.primaryTmplIndex;
+        case DeferBlockState.Loading:
+            return tDetails.loadingTmplIndex;
+        case DeferBlockState.Error:
+            return tDetails.errorTmplIndex;
+        case DeferBlockState.Placeholder:
+            return tDetails.placeholderTmplIndex;
+        default:
+            ngDevMode && throwError(`Unexpected defer block state: ${newState}`);
+            return null;
+    }
+}
 /**
  * Transitions a defer block to the new state. Updates the  necessary
  * data structures and renders corresponding block.
@@ -20551,9 +20728,8 @@ function setTDeferBlockDetails(tView, deferBlockIndex, deferBlockConfig) {
  * @param newState New state that should be applied to the defer block.
  * @param tNode TNode that represents a defer block.
  * @param lContainer Represents an instance of a defer block.
- * @param stateTmplIndex Index of a template that should be rendered.
  */
-function renderDeferBlockState(newState, tNode, lContainer, stateTmplIndex) {
+function renderDeferBlockState(newState, tNode, lContainer) {
     const hostLView = lContainer[PARENT];
     // Check if this view is not destroyed. Since the loading process was async,
     // the view might end up being destroyed by the time rendering happens.
@@ -20563,6 +20739,7 @@ function renderDeferBlockState(newState, tNode, lContainer, stateTmplIndex) {
     ngDevMode && assertTNodeForLView(tNode, hostLView);
     const lDetails = getLDeferBlockDetails(hostLView, tNode);
     ngDevMode && assertDefined(lDetails, 'Expected a defer block state defined');
+    const stateTmplIndex = getTemplateIndexForState(newState, hostLView, tNode);
     // Note: we transition to the next state if the previous state was represented
     // with a number that is less than the next state. For example, if the current
     // state is "loading" (represented as `2`), we should not show a placeholder
@@ -20581,18 +20758,28 @@ function renderDeferBlockState(newState, tNode, lContainer, stateTmplIndex) {
         addLViewToLContainer(lContainer, embeddedLView, viewIndex, shouldAddViewToDom(tNode, dehydratedView));
     }
 }
+/**
+ * Trigger prefetching of dependencies for a defer block.
+ *
+ * @param tDetails Static information about this defer block.
+ * @param lView LView of a host view.
+ */
+function triggerPrefetching(tDetails, lView) {
+    if (lView[INJECTOR$1] && shouldTriggerDeferBlock(lView[INJECTOR$1])) {
+        triggerResourceLoading(tDetails, lView);
+    }
+}
 /**
  * Trigger loading of defer block dependencies if the process hasn't started yet.
  *
  * @param tDetails Static information about this defer block.
- * @param tView TView of a host view.
  * @param lView LView of a host view.
  */
-function triggerResourceLoading(tDetails, tView, lView) {
+function triggerResourceLoading(tDetails, lView) {
     const injector = lView[INJECTOR$1];
-    if (!shouldTriggerDeferBlock(injector) ||
-        (tDetails.loadingState !== 0 /* DeferDependenciesLoadingState.NOT_STARTED */ &&
-            tDetails.loadingState !== 1 /* DeferDependenciesLoadingState.SCHEDULED */)) {
+    const tView = lView[TVIEW];
+    if (tDetails.loadingState !== DeferDependenciesLoadingState.NOT_STARTED &&
+        tDetails.loadingState !== DeferDependenciesLoadingState.SCHEDULED) {
         // If the loading status is different from initial one, it means that
         // the loading of dependencies is in progress and there is nothing to do
         // in this function. All details can be obtained from the `tDetails` object.
@@ -20600,7 +20787,7 @@ function triggerResourceLoading(tDetails, tView, lView) {
     }
     const primaryBlockTNode = getPrimaryBlockTNode(tView, tDetails);
     // Switch from NOT_STARTED -> IN_PROGRESS state.
-    tDetails.loadingState = 2 /* DeferDependenciesLoadingState.IN_PROGRESS */;
+    tDetails.loadingState = DeferDependenciesLoadingState.IN_PROGRESS;
     // Check if dependency function interceptor is configured.
     const deferDependencyInterceptor = injector.get(DEFER_BLOCK_DEPENDENCY_INTERCEPTOR, null, { optional: true });
     const dependenciesFn = deferDependencyInterceptor ?
@@ -20611,7 +20798,7 @@ function triggerResourceLoading(tDetails, tView, lView) {
     // thus no dynamic `import()`s were produced.
     if (!dependenciesFn) {
         tDetails.loadingPromise = Promise.resolve().then(() => {
-            tDetails.loadingState = 3 /* DeferDependenciesLoadingState.COMPLETE */;
+            tDetails.loadingState = DeferDependenciesLoadingState.COMPLETE;
         });
         return;
     }
@@ -20642,10 +20829,10 @@ function triggerResourceLoading(tDetails, tView, lView) {
         // Loading is completed, we no longer need this Promise.
         tDetails.loadingPromise = null;
         if (failed) {
-            tDetails.loadingState = 4 /* DeferDependenciesLoadingState.FAILED */;
+            tDetails.loadingState = DeferDependenciesLoadingState.FAILED;
         }
         else {
-            tDetails.loadingState = 3 /* DeferDependenciesLoadingState.COMPLETE */;
+            tDetails.loadingState = DeferDependenciesLoadingState.COMPLETE;
             // Update directive and pipe registries to add newly downloaded dependencies.
             const primaryBlockTView = primaryBlockTNode.tView;
             if (directiveDefs.length > 0) {
@@ -20667,7 +20854,7 @@ function renderPlaceholder(lView, tNode) {
     const lContainer = lView[tNode.index];
     ngDevMode && assertLContainer(lContainer);
     const tDetails = getTDeferBlockDetails(tView, tNode);
-    renderDeferBlockState(1 /* DeferBlockInstanceState.PLACEHOLDER */, tNode, lContainer, tDetails.placeholderTmplIndex);
+    renderDeferBlockState(DeferBlockState.Placeholder, tNode, lContainer);
 }
 /**
  * Subscribes to the "loading" Promise and renders corresponding defer sub-block,
@@ -20680,13 +20867,13 @@ function renderDeferStateAfterResourceLoading(tDetails, tNode, lContainer) {
     ngDevMode &&
         assertDefined(tDetails.loadingPromise, 'Expected loading Promise to exist on this defer block');
     tDetails.loadingPromise.then(() => {
-        if (tDetails.loadingState === 3 /* DeferDependenciesLoadingState.COMPLETE */) {
+        if (tDetails.loadingState === DeferDependenciesLoadingState.COMPLETE) {
             ngDevMode && assertDeferredDependenciesLoaded(tDetails);
             // Everything is loaded, show the primary block content
-            renderDeferBlockState(3 /* DeferBlockInstanceState.COMPLETE */, tNode, lContainer, tDetails.primaryTmplIndex);
+            renderDeferBlockState(DeferBlockState.Complete, tNode, lContainer);
         }
-        else if (tDetails.loadingState === 4 /* DeferDependenciesLoadingState.FAILED */) {
-            renderDeferBlockState(4 /* DeferBlockInstanceState.ERROR */, tNode, lContainer, tDetails.errorTmplIndex);
+        else if (tDetails.loadingState === DeferDependenciesLoadingState.FAILED) {
+            renderDeferBlockState(DeferBlockState.Error, tNode, lContainer);
         }
     });
 }
@@ -20710,26 +20897,26 @@ function triggerDeferBlock(lView, tNode) {
     const tDetails = getTDeferBlockDetails(tView, tNode);
     // Condition is triggered, try to render loading state and start downloading.
     // Note: if a block is in a loading, completed or an error state, this call would be a noop.
-    renderDeferBlockState(2 /* DeferBlockInstanceState.LOADING */, tNode, lContainer, tDetails.loadingTmplIndex);
+    renderDeferBlockState(DeferBlockState.Loading, tNode, lContainer);
     switch (tDetails.loadingState) {
-        case 0 /* DeferDependenciesLoadingState.NOT_STARTED */:
-        case 1 /* DeferDependenciesLoadingState.SCHEDULED */:
-            triggerResourceLoading(tDetails, lView[TVIEW], lView);
+        case DeferDependenciesLoadingState.NOT_STARTED:
+        case DeferDependenciesLoadingState.SCHEDULED:
+            triggerResourceLoading(tDetails, lView);
             // The `loadingState` might have changed to "loading".
             if (tDetails.loadingState ===
-                2 /* DeferDependenciesLoadingState.IN_PROGRESS */) {
+                DeferDependenciesLoadingState.IN_PROGRESS) {
                 renderDeferStateAfterResourceLoading(tDetails, tNode, lContainer);
             }
             break;
-        case 2 /* DeferDependenciesLoadingState.IN_PROGRESS */:
+        case DeferDependenciesLoadingState.IN_PROGRESS:
             renderDeferStateAfterResourceLoading(tDetails, tNode, lContainer);
             break;
-        case 3 /* DeferDependenciesLoadingState.COMPLETE */:
+        case DeferDependenciesLoadingState.COMPLETE:
             ngDevMode && assertDeferredDependenciesLoaded(tDetails);
-            renderDeferBlockState(3 /* DeferBlockInstanceState.COMPLETE */, tNode, lContainer, tDetails.primaryTmplIndex);
+            renderDeferBlockState(DeferBlockState.Complete, tNode, lContainer);
             break;
-        case 4 /* DeferDependenciesLoadingState.FAILED */:
-            renderDeferBlockState(4 /* DeferBlockInstanceState.ERROR */, tNode, lContainer, tDetails.errorTmplIndex);
+        case DeferDependenciesLoadingState.FAILED:
+            renderDeferBlockState(DeferBlockState.Error, tNode, lContainer);
             break;
         default:
             if (ngDevMode) {
@@ -20743,7 +20930,7 @@ function triggerDeferBlock(lView, tNode) {
  * block in completed state.
  */
 function assertDeferredDependenciesLoaded(tDetails) {
-    assertEqual(tDetails.loadingState, 3 /* DeferDependenciesLoadingState.COMPLETE */, 'Expecting all deferred dependencies to be loaded.');
+    assertEqual(tDetails.loadingState, DeferDependenciesLoadingState.COMPLETE, 'Expecting all deferred dependencies to be loaded.');
 }
 /**
  * **INTERNAL**, avoid referencing it in application code.
@@ -20752,6 +20939,55 @@ function assertDeferredDependenciesLoaded(tDetails) {
  * implementation.
  */
 const DEFER_BLOCK_DEPENDENCY_INTERCEPTOR = new InjectionToken(ngDevMode ? 'DEFER_BLOCK_DEPENDENCY_INTERCEPTOR' : '');
+/**
+ * Determines if a given value matches the expected structure of a defer block
+ *
+ * We can safely rely on the primaryTmplIndex because every defer block requires
+ * that a primary template exists. All the other template options are optional.
+ */
+function isTDeferBlockDetails(value) {
+    return (typeof value === 'object') &&
+        (typeof value.primaryTmplIndex === 'number');
+}
+/**
+ * Internal token used for configuring defer block behavior.
+ */
+const DEFER_BLOCK_CONFIG = new InjectionToken(ngDevMode ? 'DEFER_BLOCK_CONFIG' : '');
+/**
+ * Retrieves all defer blocks in a given LView.
+ *
+ * @param lView lView with defer blocks
+ * @param deferBlocks defer block aggregator array
+ */
+function getDeferBlocks(lView, deferBlocks) {
+    const tView = lView[TVIEW];
+    for (let i = HEADER_OFFSET; i < tView.bindingStartIndex; i++) {
+        if (isLContainer(lView[i])) {
+            const lContainer = lView[i];
+            // An LContainer may represent an instance of a defer block, in which case
+            // we store it as a result. Otherwise, keep iterating over LContainer views and
+            // look for defer blocks.
+            const isLast = i === tView.bindingStartIndex - 1;
+            if (!isLast) {
+                const tNode = tView.data[i];
+                const tDetails = getTDeferBlockDetails(tView, tNode);
+                if (isTDeferBlockDetails(tDetails)) {
+                    deferBlocks.push({ lContainer, lView, tNode, tDetails });
+                    // This LContainer represents a defer block, so we exit
+                    // this iteration and don't inspect views in this LContainer.
+                    continue;
+                }
+            }
+            for (let i = CONTAINER_HEADER_OFFSET; i < lContainer.length; i++) {
+                getDeferBlocks(lContainer[i], deferBlocks);
+            }
+        }
+        else if (isLView(lView[i])) {
+            // This is a component, enter the `getDeferBlocks` recursively.
+            getDeferBlocks(lView[i], deferBlocks);
+        }
+    }
+}
 
 function elementStartFirstCreatePass(index, tView, lView, name, attrsIndex, localRefsIndex) {
     ngDevMode && assertFirstCreatePass(tView);
@@ -25555,6 +25791,10 @@ function ɵɵsetNgModuleScope(type, scope) {
         ngModuleDef.declarations = convertToTypeArray(scope.declarations || EMPTY_ARRAY);
         ngModuleDef.imports = convertToTypeArray(scope.imports || EMPTY_ARRAY);
         ngModuleDef.exports = convertToTypeArray(scope.exports || EMPTY_ARRAY);
+        if (scope.bootstrap) {
+            // This only happens in local compilation mode.
+            ngModuleDef.bootstrap = convertToTypeArray(scope.bootstrap);
+        }
         depsTracker.registerNgModule(type, scope);
     });
 }
@@ -25562,11 +25802,12 @@ function convertToTypeArray(values) {
     if (typeof values === 'function') {
         return values;
     }
-    if (values.some(isForwardRef)) {
-        return () => values.map(resolveForwardRef).map(maybeUnwrapModuleWithProviders);
+    const flattenValues = flatten(values);
+    if (flattenValues.some(isForwardRef)) {
+        return () => flattenValues.map(resolveForwardRef).map(maybeUnwrapModuleWithProviders);
     }
     else {
-        return values.map(maybeUnwrapModuleWithProviders);
+        return flattenValues.map(maybeUnwrapModuleWithProviders);
     }
 }
 function maybeUnwrapModuleWithProviders(value) {
@@ -26444,6 +26685,7 @@ function getPipeDef(name, registry) {
     if (ngDevMode) {
         throw new RuntimeError(-302 /* RuntimeErrorCode.PIPE_NOT_FOUND */, getPipeNotFoundErrorMessage(name));
     }
+    return;
 }
 /**
  * Generates a helpful error message for the user when multiple pipes match the name.
@@ -27291,7 +27533,13 @@ function ɵɵtemplateRefExtractor(tNode, lView) {
 
 function ɵɵgetComponentDepsFactory(type, rawImports) {
     return () => {
-        return depsTracker.getComponentDependencies(type, rawImports).dependencies;
+        try {
+            return depsTracker.getComponentDependencies(type, rawImports).dependencies;
+        }
+        catch (e) {
+            console.error(`Computing dependencies in local compilation mode for the component "${type.name}" failed with the exception:`, e);
+            throw e;
+        }
     };
 }
 
@@ -28068,6 +28316,9 @@ function compileComponent(type, metadata) {
                     if (metadata.styleUrls && metadata.styleUrls.length) {
                         error.push(` - styleUrls: ${JSON.stringify(metadata.styleUrls)}`);
                     }
+                    if (metadata.styleUrl) {
+                        error.push(` - styleUrl: ${metadata.styleUrl}`);
+                    }
                     error.push(`Did you run and wait for 'resolveComponentResources()'?`);
                     throw new Error(error.join('\n'));
                 }
@@ -28100,7 +28351,8 @@ function compileComponent(type, metadata) {
                     typeSourceSpan: compiler.createParseSourceSpan('Component', type.name, templateUrl),
                     template: metadata.template || '',
                     preserveWhitespaces,
-                    styles: metadata.styles || EMPTY_ARRAY,
+                    styles: typeof metadata.styles === 'string' ? [metadata.styles] :
+                        (metadata.styles || EMPTY_ARRAY),
                     animations: metadata.animations,
                     // JIT components are always compiled against an empty set of `declarations`. Instead, the
                     // `directiveDefs` and `pipeDefs` are updated at a later point:
@@ -32619,6 +32871,163 @@ function ɵɵngDeclarePipe(decl) {
 // clang-format off
 // clang-format on
 
+/**
+ * Not public API, which guarantees `EffectScheduler` only ever comes from the application root
+ * injector.
+ */
+const APP_EFFECT_SCHEDULER = new InjectionToken('', {
+    providedIn: 'root',
+    factory: () => inject(EffectScheduler),
+});
+/**
+ * A scheduler which manages the execution of effects.
+ */
+class EffectScheduler {
+    /** @nocollapse */
+    static { this.ɵprov = ɵɵdefineInjectable({
+        token: EffectScheduler,
+        providedIn: 'root',
+        factory: () => new ZoneAwareMicrotaskScheduler(),
+    }); }
+}
+/**
+ * An `EffectScheduler` which is capable of queueing scheduled effects per-zone, and flushing them
+ * as an explicit operation.
+ */
+class ZoneAwareQueueingScheduler {
+    constructor() {
+        this.queuedEffectCount = 0;
+        this.queues = new Map();
+    }
+    scheduleEffect(handle) {
+        const zone = handle.creationZone;
+        if (!this.queues.has(zone)) {
+            this.queues.set(zone, new Set());
+        }
+        const queue = this.queues.get(zone);
+        if (queue.has(handle)) {
+            return;
+        }
+        this.queuedEffectCount++;
+        queue.add(handle);
+    }
+    /**
+     * Run all scheduled effects.
+     *
+     * Execution order of effects within the same zone is guaranteed to be FIFO, but there is no
+     * ordering guarantee between effects scheduled in different zones.
+     */
+    flush() {
+        while (this.queuedEffectCount > 0) {
+            for (const [zone, queue] of this.queues) {
+                // `zone` here must be defined.
+                if (zone === null) {
+                    this.flushQueue(queue);
+                }
+                else {
+                    zone.run(() => this.flushQueue(queue));
+                }
+            }
+        }
+    }
+    flushQueue(queue) {
+        for (const handle of queue) {
+            queue.delete(handle);
+            this.queuedEffectCount--;
+            // TODO: what happens if this throws an error?
+            handle.run();
+        }
+    }
+    /** @nocollapse */
+    static { this.ɵprov = ɵɵdefineInjectable({
+        token: ZoneAwareQueueingScheduler,
+        providedIn: 'root',
+        factory: () => new ZoneAwareQueueingScheduler(),
+    }); }
+}
+/**
+ * A wrapper around `ZoneAwareQueueingScheduler` that schedules flushing via the microtask queue
+ * when.
+ */
+class ZoneAwareMicrotaskScheduler {
+    constructor() {
+        this.hasQueuedFlush = false;
+        this.delegate = new ZoneAwareQueueingScheduler();
+        this.flushTask = () => {
+            // Leave `hasQueuedFlush` as `true` so we don't queue another microtask if more effects are
+            // scheduled during flushing. The flush of the `ZoneAwareQueueingScheduler` delegate is
+            // guaranteed to empty the queue.
+            this.delegate.flush();
+            this.hasQueuedFlush = false;
+            // This is a variable initialization, not a method.
+            // tslint:disable-next-line:semicolon
+        };
+    }
+    scheduleEffect(handle) {
+        this.delegate.scheduleEffect(handle);
+        if (!this.hasQueuedFlush) {
+            queueMicrotask(this.flushTask);
+            this.hasQueuedFlush = true;
+        }
+    }
+}
+/**
+ * Core reactive node for an Angular effect.
+ *
+ * `EffectHandle` combines the reactive graph's `Watch` base node for effects with the framework's
+ * scheduling abstraction (`EffectScheduler`) as well as automatic cleanup via `DestroyRef` if
+ * available/requested.
+ */
+class EffectHandle {
+    constructor(scheduler, effectFn, creationZone, destroyRef, errorHandler, allowSignalWrites) {
+        this.scheduler = scheduler;
+        this.effectFn = effectFn;
+        this.creationZone = creationZone;
+        this.errorHandler = errorHandler;
+        this.watcher =
+            watch((onCleanup) => this.runEffect(onCleanup), () => this.schedule(), allowSignalWrites);
+        this.unregisterOnDestroy = destroyRef?.onDestroy(() => this.destroy());
+    }
+    runEffect(onCleanup) {
+        try {
+            this.effectFn(onCleanup);
+        }
+        catch (err) {
+            this.errorHandler?.handleError(err);
+        }
+    }
+    run() {
+        this.watcher.run();
+    }
+    schedule() {
+        this.scheduler.scheduleEffect(this);
+    }
+    notify() {
+        this.watcher.notify();
+    }
+    destroy() {
+        this.watcher.destroy();
+        this.unregisterOnDestroy?.();
+        // Note: if the effect is currently scheduled, it's not un-scheduled, and so the scheduler will
+        // retain a reference to it. Attempting to execute it will be a no-op.
+    }
+}
+/**
+ * Create a global `Effect` for the given reactive function.
+ *
+ * @developerPreview
+ */
+function effect(effectFn, options) {
+    !options?.injector && assertInInjectionContext(effect);
+    const injector = options?.injector ?? inject(Injector);
+    const errorHandler = injector.get(ErrorHandler, null, { optional: true });
+    const destroyRef = options?.manualCleanup !== true ? injector.get(DestroyRef) : null;
+    const handle = new EffectHandle(injector.get(APP_EFFECT_SCHEDULER), effectFn, (typeof Zone === 'undefined') ? null : Zone.current, destroyRef, errorHandler, options?.allowSignalWrites ?? false);
+    // Effects start dirty.
+    handle.notify();
+    return handle;
+}
+
 // clang-format off
 // clang-format on
 
@@ -32809,5 +33218,5 @@ if (typeof ngDevMode !== 'undefined' && ngDevMode) {
  * Generated bundle index. Do not edit.
  */
 
-export { ANIMATION_MODULE_TYPE, APP_BOOTSTRAP_LISTENER, APP_ID, APP_INITIALIZER, ApplicationInitStatus, ApplicationModule, ApplicationRef, Attribute, COMPILER_OPTIONS, CSP_NONCE, CUSTOM_ELEMENTS_SCHEMA, ChangeDetectionStrategy, ChangeDetectorRef, Compiler, CompilerFactory, Component, ComponentFactory$1 as ComponentFactory, ComponentFactoryResolver$1 as ComponentFactoryResolver, ComponentRef$1 as ComponentRef, ContentChild, ContentChildren, DEFAULT_CURRENCY_CODE, DebugElement, DebugEventListener, DebugNode, DefaultIterableDiffer, DestroyRef, Directive, ENVIRONMENT_INITIALIZER, ElementRef, EmbeddedViewRef, EnvironmentInjector, ErrorHandler, EventEmitter, Host, HostBinding, HostListener, INJECTOR, Inject, InjectFlags, Injectable, InjectionToken, Injector, Input, IterableDiffers, KeyValueDiffers, LOCALE_ID, MissingTranslationStrategy, ModuleWithComponentFactories, NO_ERRORS_SCHEMA, NgModule, NgModuleFactory$1 as NgModuleFactory, NgModuleRef$1 as NgModuleRef, NgProbeToken, NgZone, Optional, Output, PACKAGE_ROOT_URL, PLATFORM_ID, PLATFORM_INITIALIZER, Pipe, PlatformRef, Query, QueryList, Renderer2, RendererFactory2, RendererStyleFlags2, Sanitizer, SecurityContext, Self, SimpleChange, SkipSelf, TRANSLATIONS, TRANSLATIONS_FORMAT, TemplateRef, Testability, TestabilityRegistry, TransferState, Type, VERSION, Version, ViewChild, ViewChildren, ViewContainerRef, ViewEncapsulation$1 as ViewEncapsulation, ViewRef, afterNextRender, afterRender, asNativeElements, assertInInjectionContext, assertPlatform, booleanAttribute, computed, createComponent, createEnvironmentInjector, createNgModule, createNgModuleRef, createPlatform, createPlatformFactory, defineInjectable, destroyPlatform, effect, enableProdMode, forwardRef, getDebugNode, getModuleFactory, getNgModuleById, getPlatform, importProvidersFrom, inject, isDevMode, isSignal, isStandalone, makeEnvironmentProviders, makeStateKey, mergeApplicationConfig, numberAttribute, platformCore, provideZoneChangeDetection, reflectComponentType, resolveForwardRef, runInInjectionContext, setTestabilityGetter, signal, untracked, ALLOW_MULTIPLE_PLATFORMS as ɵALLOW_MULTIPLE_PLATFORMS, AfterRenderEventManager as ɵAfterRenderEventManager, ComponentFactory$1 as ɵComponentFactory, Console as ɵConsole, DEFAULT_LOCALE_ID as ɵDEFAULT_LOCALE_ID, DEFER_BLOCK_DEPENDENCY_INTERCEPTOR as ɵDEFER_BLOCK_DEPENDENCY_INTERCEPTOR, ENABLED_SSR_FEATURES as ɵENABLED_SSR_FEATURES, INJECTOR_SCOPE as ɵINJECTOR_SCOPE, IS_HYDRATION_DOM_REUSE_ENABLED as ɵIS_HYDRATION_DOM_REUSE_ENABLED, InitialRenderPendingTasks as ɵInitialRenderPendingTasks, LContext as ɵLContext, LifecycleHooksFeature as ɵLifecycleHooksFeature, LocaleDataIndex as ɵLocaleDataIndex, NG_COMP_DEF as ɵNG_COMP_DEF, NG_DIR_DEF as ɵNG_DIR_DEF, NG_ELEMENT_ID as ɵNG_ELEMENT_ID, NG_INJ_DEF as ɵNG_INJ_DEF, NG_MOD_DEF as ɵNG_MOD_DEF, NG_PIPE_DEF as ɵNG_PIPE_DEF, NG_PROV_DEF as ɵNG_PROV_DEF, NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR as ɵNOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR, NO_CHANGE as ɵNO_CHANGE, NgModuleFactory as ɵNgModuleFactory, NoopNgZone as ɵNoopNgZone, ReflectionCapabilities as ɵReflectionCapabilities, ComponentFactory as ɵRender3ComponentFactory, ComponentRef as ɵRender3ComponentRef, NgModuleRef as ɵRender3NgModuleRef, RuntimeError as ɵRuntimeError, SSR_CONTENT_INTEGRITY_MARKER as ɵSSR_CONTENT_INTEGRITY_MARKER, TESTABILITY as ɵTESTABILITY, TESTABILITY_GETTER as ɵTESTABILITY_GETTER, USE_RUNTIME_DEPS_TRACKER_FOR_JIT as ɵUSE_RUNTIME_DEPS_TRACKER_FOR_JIT, ViewRef$1 as ɵViewRef, XSS_SECURITY_URL as ɵXSS_SECURITY_URL, _sanitizeHtml as ɵ_sanitizeHtml, _sanitizeUrl as ɵ_sanitizeUrl, allowSanitizationBypassAndThrow as ɵallowSanitizationBypassAndThrow, annotateForHydration as ɵannotateForHydration, bypassSanitizationTrustHtml as ɵbypassSanitizationTrustHtml, bypassSanitizationTrustResourceUrl as ɵbypassSanitizationTrustResourceUrl, bypassSanitizationTrustScript as ɵbypassSanitizationTrustScript, bypassSanitizationTrustStyle as ɵbypassSanitizationTrustStyle, bypassSanitizationTrustUrl as ɵbypassSanitizationTrustUrl, clearResolutionOfComponentResourcesQueue as ɵclearResolutionOfComponentResourcesQueue, compileComponent as ɵcompileComponent, compileDirective as ɵcompileDirective, compileNgModule as ɵcompileNgModule, compileNgModuleDefs as ɵcompileNgModuleDefs, compileNgModuleFactory as ɵcompileNgModuleFactory, compilePipe as ɵcompilePipe, convertToBitFlags as ɵconvertToBitFlags, createInjector as ɵcreateInjector, defaultIterableDiffers as ɵdefaultIterableDiffers, defaultKeyValueDiffers as ɵdefaultKeyValueDiffers, depsTracker as ɵdepsTracker, detectChanges as ɵdetectChanges, devModeEqual as ɵdevModeEqual, findLocaleData as ɵfindLocaleData, flushModuleScopingQueueAsMuchAsPossible as ɵflushModuleScopingQueueAsMuchAsPossible, formatRuntimeError as ɵformatRuntimeError, generateStandaloneInDeclarationsError as ɵgenerateStandaloneInDeclarationsError, getAsyncClassMetadata as ɵgetAsyncClassMetadata, getDebugNode as ɵgetDebugNode, getDirectives as ɵgetDirectives, getHostElement as ɵgetHostElement, getInjectableDef as ɵgetInjectableDef, getLContext as ɵgetLContext, getLocaleCurrencyCode as ɵgetLocaleCurrencyCode, getLocalePluralCase as ɵgetLocalePluralCase, getSanitizationBypassType as ɵgetSanitizationBypassType, ɵgetUnknownElementStrictMode, ɵgetUnknownPropertyStrictMode, _global as ɵglobal, injectChangeDetectorRef as ɵinjectChangeDetectorRef, internalCreateApplication as ɵinternalCreateApplication, isBoundToModule as ɵisBoundToModule, isComponentDefPendingResolution as ɵisComponentDefPendingResolution, isEnvironmentProviders as ɵisEnvironmentProviders, isInjectable as ɵisInjectable, isNgModule as ɵisNgModule, isPromise as ɵisPromise, isSubscribable as ɵisSubscribable, noSideEffects as ɵnoSideEffects, patchComponentDefWithScope as ɵpatchComponentDefWithScope, publishDefaultGlobalUtils$1 as ɵpublishDefaultGlobalUtils, publishGlobalUtil as ɵpublishGlobalUtil, registerLocaleData as ɵregisterLocaleData, resetCompiledComponents as ɵresetCompiledComponents, resetJitOptions as ɵresetJitOptions, resolveComponentResources as ɵresolveComponentResources, restoreComponentResolutionQueue as ɵrestoreComponentResolutionQueue, setAllowDuplicateNgModuleIdsForTest as ɵsetAllowDuplicateNgModuleIdsForTest, setAlternateWeakRefImpl as ɵsetAlternateWeakRefImpl, setClassMetadata as ɵsetClassMetadata, setClassMetadataAsync as ɵsetClassMetadataAsync, setCurrentInjector as ɵsetCurrentInjector, setDocument as ɵsetDocument, setInjectorProfilerContext as ɵsetInjectorProfilerContext, setLocaleId as ɵsetLocaleId, ɵsetUnknownElementStrictMode, ɵsetUnknownPropertyStrictMode, store as ɵstore, stringify as ɵstringify, transitiveScopesFor as ɵtransitiveScopesFor, unregisterAllLocaleData as ɵunregisterLocaleData, unwrapSafeValue as ɵunwrapSafeValue, withDomHydration as ɵwithDomHydration, ɵɵCopyDefinitionFeature, FactoryTarget as ɵɵFactoryTarget, ɵɵHostDirectivesFeature, ɵɵInheritDefinitionFeature, ɵɵInputTransformsFeature, ɵɵNgOnChangesFeature, ɵɵProvidersFeature, ɵɵStandaloneFeature, ɵɵadvance, ɵɵattribute, ɵɵattributeInterpolate1, ɵɵattributeInterpolate2, ɵɵattributeInterpolate3, ɵɵattributeInterpolate4, ɵɵattributeInterpolate5, ɵɵattributeInterpolate6, ɵɵattributeInterpolate7, ɵɵattributeInterpolate8, ɵɵattributeInterpolateV, ɵɵclassMap, ɵɵclassMapInterpolate1, ɵɵclassMapInterpolate2, ɵɵclassMapInterpolate3, ɵɵclassMapInterpolate4, ɵɵclassMapInterpolate5, ɵɵclassMapInterpolate6, ɵɵclassMapInterpolate7, ɵɵclassMapInterpolate8, ɵɵclassMapInterpolateV, ɵɵclassProp, ɵɵcomponentInstance, ɵɵconditional, ɵɵcontentQuery, ɵɵdefer, ɵɵdeferOnHover, ɵɵdeferOnIdle, ɵɵdeferOnImmediate, ɵɵdeferOnInteraction, ɵɵdeferOnTimer, ɵɵdeferOnViewport, ɵɵdeferPrefetchOnHover, ɵɵdeferPrefetchOnIdle, ɵɵdeferPrefetchOnImmediate, ɵɵdeferPrefetchOnInteraction, ɵɵdeferPrefetchOnTimer, ɵɵdeferPrefetchOnViewport, ɵɵdeferPrefetchWhen, ɵɵdeferWhen, ɵɵdefineComponent, ɵɵdefineDirective, ɵɵdefineInjectable, ɵɵdefineInjector, ɵɵdefineNgModule, ɵɵdefinePipe, ɵɵdirectiveInject, ɵɵdisableBindings, ɵɵelement, ɵɵelementContainer, ɵɵelementContainerEnd, ɵɵelementContainerStart, ɵɵelementEnd, ɵɵelementStart, ɵɵenableBindings, ɵɵgetComponentDepsFactory, ɵɵgetCurrentView, ɵɵgetInheritedFactory, ɵɵhostProperty, ɵɵi18n, ɵɵi18nApply, ɵɵi18nAttributes, ɵɵi18nEnd, ɵɵi18nExp, ɵɵi18nPostprocess, ɵɵi18nStart, ɵɵinject, ɵɵinjectAttribute, ɵɵinvalidFactory, ɵɵinvalidFactoryDep, ɵɵlistener, ɵɵloadQuery, ɵɵnamespaceHTML, ɵɵnamespaceMathML, ɵɵnamespaceSVG, ɵɵnextContext, ɵɵngDeclareClassMetadata, ɵɵngDeclareComponent, ɵɵngDeclareDirective, ɵɵngDeclareFactory, ɵɵngDeclareInjectable, ɵɵngDeclareInjector, ɵɵngDeclareNgModule, ɵɵngDeclarePipe, ɵɵpipe, ɵɵpipeBind1, ɵɵpipeBind2, ɵɵpipeBind3, ɵɵpipeBind4, ɵɵpipeBindV, ɵɵprojection, ɵɵprojectionDef, ɵɵproperty, ɵɵpropertyInterpolate, ɵɵpropertyInterpolate1, ɵɵpropertyInterpolate2, ɵɵpropertyInterpolate3, ɵɵpropertyInterpolate4, ɵɵpropertyInterpolate5, ɵɵpropertyInterpolate6, ɵɵpropertyInterpolate7, ɵɵpropertyInterpolate8, ɵɵpropertyInterpolateV, ɵɵpureFunction0, ɵɵpureFunction1, ɵɵpureFunction2, ɵɵpureFunction3, ɵɵpureFunction4, ɵɵpureFunction5, ɵɵpureFunction6, ɵɵpureFunction7, ɵɵpureFunction8, ɵɵpureFunctionV, ɵɵqueryRefresh, ɵɵreference, registerNgModuleType as ɵɵregisterNgModuleType, ɵɵrepeater, ɵɵrepeaterCreate, ɵɵrepeaterTrackByIdentity, ɵɵrepeaterTrackByIndex, ɵɵresetView, ɵɵresolveBody, ɵɵresolveDocument, ɵɵresolveWindow, ɵɵrestoreView, ɵɵsanitizeHtml, ɵɵsanitizeResourceUrl, ɵɵsanitizeScript, ɵɵsanitizeStyle, ɵɵsanitizeUrl, ɵɵsanitizeUrlOrResourceUrl, ɵɵsetComponentScope, ɵɵsetNgModuleScope, ɵɵstyleMap, ɵɵstyleMapInterpolate1, ɵɵstyleMapInterpolate2, ɵɵstyleMapInterpolate3, ɵɵstyleMapInterpolate4, ɵɵstyleMapInterpolate5, ɵɵstyleMapInterpolate6, ɵɵstyleMapInterpolate7, ɵɵstyleMapInterpolate8, ɵɵstyleMapInterpolateV, ɵɵstyleProp, ɵɵstylePropInterpolate1, ɵɵstylePropInterpolate2, ɵɵstylePropInterpolate3, ɵɵstylePropInterpolate4, ɵɵstylePropInterpolate5, ɵɵstylePropInterpolate6, ɵɵstylePropInterpolate7, ɵɵstylePropInterpolate8, ɵɵstylePropInterpolateV, ɵɵsyntheticHostListener, ɵɵsyntheticHostProperty, ɵɵtemplate, ɵɵtemplateRefExtractor, ɵɵtext, ɵɵtextInterpolate, ɵɵtextInterpolate1, ɵɵtextInterpolate2, ɵɵtextInterpolate3, ɵɵtextInterpolate4, ɵɵtextInterpolate5, ɵɵtextInterpolate6, ɵɵtextInterpolate7, ɵɵtextInterpolate8, ɵɵtextInterpolateV, ɵɵtrustConstantHtml, ɵɵtrustConstantResourceUrl, ɵɵvalidateIframeAttribute, ɵɵviewQuery };
+export { ANIMATION_MODULE_TYPE, APP_BOOTSTRAP_LISTENER, APP_ID, APP_INITIALIZER, AfterRenderPhase, ApplicationInitStatus, ApplicationModule, ApplicationRef, Attribute, COMPILER_OPTIONS, CSP_NONCE, CUSTOM_ELEMENTS_SCHEMA, ChangeDetectionStrategy, ChangeDetectorRef, Compiler, CompilerFactory, Component, ComponentFactory$1 as ComponentFactory, ComponentFactoryResolver$1 as ComponentFactoryResolver, ComponentRef$1 as ComponentRef, ContentChild, ContentChildren, DEFAULT_CURRENCY_CODE, DebugElement, DebugEventListener, DebugNode, DefaultIterableDiffer, DestroyRef, Directive, ENVIRONMENT_INITIALIZER, ElementRef, EmbeddedViewRef, EnvironmentInjector, ErrorHandler, EventEmitter, Host, HostBinding, HostListener, INJECTOR, Inject, InjectFlags, Injectable, InjectionToken, Injector, Input, IterableDiffers, KeyValueDiffers, LOCALE_ID, MissingTranslationStrategy, ModuleWithComponentFactories, NO_ERRORS_SCHEMA, NgModule, NgModuleFactory$1 as NgModuleFactory, NgModuleRef$1 as NgModuleRef, NgProbeToken, NgZone, Optional, Output, PACKAGE_ROOT_URL, PLATFORM_ID, PLATFORM_INITIALIZER, Pipe, PlatformRef, Query, QueryList, Renderer2, RendererFactory2, RendererStyleFlags2, Sanitizer, SecurityContext, Self, SimpleChange, SkipSelf, TRANSLATIONS, TRANSLATIONS_FORMAT, TemplateRef, Testability, TestabilityRegistry, TransferState, Type, VERSION, Version, ViewChild, ViewChildren, ViewContainerRef, ViewEncapsulation$1 as ViewEncapsulation, ViewRef, afterNextRender, afterRender, asNativeElements, assertInInjectionContext, assertPlatform, booleanAttribute, computed, createComponent, createEnvironmentInjector, createNgModule, createNgModuleRef, createPlatform, createPlatformFactory, defineInjectable, destroyPlatform, effect, enableProdMode, forwardRef, getDebugNode, getModuleFactory, getNgModuleById, getPlatform, importProvidersFrom, inject, isDevMode, isSignal, isStandalone, makeEnvironmentProviders, makeStateKey, mergeApplicationConfig, numberAttribute, platformCore, provideZoneChangeDetection, reflectComponentType, resolveForwardRef, runInInjectionContext, setTestabilityGetter, signal, untracked, ALLOW_MULTIPLE_PLATFORMS as ɵALLOW_MULTIPLE_PLATFORMS, AfterRenderEventManager as ɵAfterRenderEventManager, CONTAINER_HEADER_OFFSET as ɵCONTAINER_HEADER_OFFSET, ComponentFactory$1 as ɵComponentFactory, Console as ɵConsole, DEFAULT_LOCALE_ID as ɵDEFAULT_LOCALE_ID, DEFER_BLOCK_CONFIG as ɵDEFER_BLOCK_CONFIG, DEFER_BLOCK_DEPENDENCY_INTERCEPTOR as ɵDEFER_BLOCK_DEPENDENCY_INTERCEPTOR, DeferBlockBehavior as ɵDeferBlockBehavior, DeferBlockState as ɵDeferBlockState, ENABLED_SSR_FEATURES as ɵENABLED_SSR_FEATURES, EffectScheduler as ɵEffectScheduler, INJECTOR_SCOPE as ɵINJECTOR_SCOPE, IS_HYDRATION_DOM_REUSE_ENABLED as ɵIS_HYDRATION_DOM_REUSE_ENABLED, InitialRenderPendingTasks as ɵInitialRenderPendingTasks, LContext as ɵLContext, LifecycleHooksFeature as ɵLifecycleHooksFeature, LocaleDataIndex as ɵLocaleDataIndex, NG_COMP_DEF as ɵNG_COMP_DEF, NG_DIR_DEF as ɵNG_DIR_DEF, NG_ELEMENT_ID as ɵNG_ELEMENT_ID, NG_INJ_DEF as ɵNG_INJ_DEF, NG_MOD_DEF as ɵNG_MOD_DEF, NG_PIPE_DEF as ɵNG_PIPE_DEF, NG_PROV_DEF as ɵNG_PROV_DEF, NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR as ɵNOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR, NO_CHANGE as ɵNO_CHANGE, NgModuleFactory as ɵNgModuleFactory, NoopNgZone as ɵNoopNgZone, ReflectionCapabilities as ɵReflectionCapabilities, ComponentFactory as ɵRender3ComponentFactory, ComponentRef as ɵRender3ComponentRef, NgModuleRef as ɵRender3NgModuleRef, RuntimeError as ɵRuntimeError, SSR_CONTENT_INTEGRITY_MARKER as ɵSSR_CONTENT_INTEGRITY_MARKER, TESTABILITY as ɵTESTABILITY, TESTABILITY_GETTER as ɵTESTABILITY_GETTER, USE_RUNTIME_DEPS_TRACKER_FOR_JIT as ɵUSE_RUNTIME_DEPS_TRACKER_FOR_JIT, ViewRef$1 as ɵViewRef, XSS_SECURITY_URL as ɵXSS_SECURITY_URL, ZoneAwareQueueingScheduler as ɵZoneAwareQueueingScheduler, _sanitizeHtml as ɵ_sanitizeHtml, _sanitizeUrl as ɵ_sanitizeUrl, allowSanitizationBypassAndThrow as ɵallowSanitizationBypassAndThrow, annotateForHydration as ɵannotateForHydration, bypassSanitizationTrustHtml as ɵbypassSanitizationTrustHtml, bypassSanitizationTrustResourceUrl as ɵbypassSanitizationTrustResourceUrl, bypassSanitizationTrustScript as ɵbypassSanitizationTrustScript, bypassSanitizationTrustStyle as ɵbypassSanitizationTrustStyle, bypassSanitizationTrustUrl as ɵbypassSanitizationTrustUrl, clearResolutionOfComponentResourcesQueue as ɵclearResolutionOfComponentResourcesQueue, compileComponent as ɵcompileComponent, compileDirective as ɵcompileDirective, compileNgModule as ɵcompileNgModule, compileNgModuleDefs as ɵcompileNgModuleDefs, compileNgModuleFactory as ɵcompileNgModuleFactory, compilePipe as ɵcompilePipe, convertToBitFlags as ɵconvertToBitFlags, createInjector as ɵcreateInjector, defaultIterableDiffers as ɵdefaultIterableDiffers, defaultKeyValueDiffers as ɵdefaultKeyValueDiffers, depsTracker as ɵdepsTracker, detectChanges as ɵdetectChanges, devModeEqual as ɵdevModeEqual, findLocaleData as ɵfindLocaleData, flushModuleScopingQueueAsMuchAsPossible as ɵflushModuleScopingQueueAsMuchAsPossible, formatRuntimeError as ɵformatRuntimeError, generateStandaloneInDeclarationsError as ɵgenerateStandaloneInDeclarationsError, getAsyncClassMetadata as ɵgetAsyncClassMetadata, getDebugNode as ɵgetDebugNode, getDeferBlocks as ɵgetDeferBlocks, getDirectives as ɵgetDirectives, getHostElement as ɵgetHostElement, getInjectableDef as ɵgetInjectableDef, getLContext as ɵgetLContext, getLocaleCurrencyCode as ɵgetLocaleCurrencyCode, getLocalePluralCase as ɵgetLocalePluralCase, getSanitizationBypassType as ɵgetSanitizationBypassType, ɵgetUnknownElementStrictMode, ɵgetUnknownPropertyStrictMode, _global as ɵglobal, injectChangeDetectorRef as ɵinjectChangeDetectorRef, internalCreateApplication as ɵinternalCreateApplication, isBoundToModule as ɵisBoundToModule, isComponentDefPendingResolution as ɵisComponentDefPendingResolution, isEnvironmentProviders as ɵisEnvironmentProviders, isInjectable as ɵisInjectable, isNgModule as ɵisNgModule, isPromise as ɵisPromise, isSubscribable as ɵisSubscribable, noSideEffects as ɵnoSideEffects, patchComponentDefWithScope as ɵpatchComponentDefWithScope, publishDefaultGlobalUtils$1 as ɵpublishDefaultGlobalUtils, publishGlobalUtil as ɵpublishGlobalUtil, registerLocaleData as ɵregisterLocaleData, renderDeferBlockState as ɵrenderDeferBlockState, resetCompiledComponents as ɵresetCompiledComponents, resetJitOptions as ɵresetJitOptions, resolveComponentResources as ɵresolveComponentResources, restoreComponentResolutionQueue as ɵrestoreComponentResolutionQueue, setAllowDuplicateNgModuleIdsForTest as ɵsetAllowDuplicateNgModuleIdsForTest, setAlternateWeakRefImpl as ɵsetAlternateWeakRefImpl, setClassMetadata as ɵsetClassMetadata, setClassMetadataAsync as ɵsetClassMetadataAsync, setCurrentInjector as ɵsetCurrentInjector, setDocument as ɵsetDocument, setInjectorProfilerContext as ɵsetInjectorProfilerContext, setLocaleId as ɵsetLocaleId, ɵsetUnknownElementStrictMode, ɵsetUnknownPropertyStrictMode, store as ɵstore, stringify as ɵstringify, transitiveScopesFor as ɵtransitiveScopesFor, triggerResourceLoading as ɵtriggerResourceLoading, unregisterAllLocaleData as ɵunregisterLocaleData, unwrapSafeValue as ɵunwrapSafeValue, withDomHydration as ɵwithDomHydration, ɵɵCopyDefinitionFeature, FactoryTarget as ɵɵFactoryTarget, ɵɵHostDirectivesFeature, ɵɵInheritDefinitionFeature, ɵɵInputTransformsFeature, ɵɵNgOnChangesFeature, ɵɵProvidersFeature, ɵɵStandaloneFeature, ɵɵadvance, ɵɵattribute, ɵɵattributeInterpolate1, ɵɵattributeInterpolate2, ɵɵattributeInterpolate3, ɵɵattributeInterpolate4, ɵɵattributeInterpolate5, ɵɵattributeInterpolate6, ɵɵattributeInterpolate7, ɵɵattributeInterpolate8, ɵɵattributeInterpolateV, ɵɵclassMap, ɵɵclassMapInterpolate1, ɵɵclassMapInterpolate2, ɵɵclassMapInterpolate3, ɵɵclassMapInterpolate4, ɵɵclassMapInterpolate5, ɵɵclassMapInterpolate6, ɵɵclassMapInterpolate7, ɵɵclassMapInterpolate8, ɵɵclassMapInterpolateV, ɵɵclassProp, ɵɵcomponentInstance, ɵɵconditional, ɵɵcontentQuery, ɵɵdefer, ɵɵdeferOnHover, ɵɵdeferOnIdle, ɵɵdeferOnImmediate, ɵɵdeferOnInteraction, ɵɵdeferOnTimer, ɵɵdeferOnViewport, ɵɵdeferPrefetchOnHover, ɵɵdeferPrefetchOnIdle, ɵɵdeferPrefetchOnImmediate, ɵɵdeferPrefetchOnInteraction, ɵɵdeferPrefetchOnTimer, ɵɵdeferPrefetchOnViewport, ɵɵdeferPrefetchWhen, ɵɵdeferWhen, ɵɵdefineComponent, ɵɵdefineDirective, ɵɵdefineInjectable, ɵɵdefineInjector, ɵɵdefineNgModule, ɵɵdefinePipe, ɵɵdirectiveInject, ɵɵdisableBindings, ɵɵelement, ɵɵelementContainer, ɵɵelementContainerEnd, ɵɵelementContainerStart, ɵɵelementEnd, ɵɵelementStart, ɵɵenableBindings, ɵɵgetComponentDepsFactory, ɵɵgetCurrentView, ɵɵgetInheritedFactory, ɵɵhostProperty, ɵɵi18n, ɵɵi18nApply, ɵɵi18nAttributes, ɵɵi18nEnd, ɵɵi18nExp, ɵɵi18nPostprocess, ɵɵi18nStart, ɵɵinject, ɵɵinjectAttribute, ɵɵinvalidFactory, ɵɵinvalidFactoryDep, ɵɵlistener, ɵɵloadQuery, ɵɵnamespaceHTML, ɵɵnamespaceMathML, ɵɵnamespaceSVG, ɵɵnextContext, ɵɵngDeclareClassMetadata, ɵɵngDeclareComponent, ɵɵngDeclareDirective, ɵɵngDeclareFactory, ɵɵngDeclareInjectable, ɵɵngDeclareInjector, ɵɵngDeclareNgModule, ɵɵngDeclarePipe, ɵɵpipe, ɵɵpipeBind1, ɵɵpipeBind2, ɵɵpipeBind3, ɵɵpipeBind4, ɵɵpipeBindV, ɵɵprojection, ɵɵprojectionDef, ɵɵproperty, ɵɵpropertyInterpolate, ɵɵpropertyInterpolate1, ɵɵpropertyInterpolate2, ɵɵpropertyInterpolate3, ɵɵpropertyInterpolate4, ɵɵpropertyInterpolate5, ɵɵpropertyInterpolate6, ɵɵpropertyInterpolate7, ɵɵpropertyInterpolate8, ɵɵpropertyInterpolateV, ɵɵpureFunction0, ɵɵpureFunction1, ɵɵpureFunction2, ɵɵpureFunction3, ɵɵpureFunction4, ɵɵpureFunction5, ɵɵpureFunction6, ɵɵpureFunction7, ɵɵpureFunction8, ɵɵpureFunctionV, ɵɵqueryRefresh, ɵɵreference, registerNgModuleType as ɵɵregisterNgModuleType, ɵɵrepeater, ɵɵrepeaterCreate, ɵɵrepeaterTrackByIdentity, ɵɵrepeaterTrackByIndex, ɵɵresetView, ɵɵresolveBody, ɵɵresolveDocument, ɵɵresolveWindow, ɵɵrestoreView, ɵɵsanitizeHtml, ɵɵsanitizeResourceUrl, ɵɵsanitizeScript, ɵɵsanitizeStyle, ɵɵsanitizeUrl, ɵɵsanitizeUrlOrResourceUrl, ɵɵsetComponentScope, ɵɵsetNgModuleScope, ɵɵstyleMap, ɵɵstyleMapInterpolate1, ɵɵstyleMapInterpolate2, ɵɵstyleMapInterpolate3, ɵɵstyleMapInterpolate4, ɵɵstyleMapInterpolate5, ɵɵstyleMapInterpolate6, ɵɵstyleMapInterpolate7, ɵɵstyleMapInterpolate8, ɵɵstyleMapInterpolateV, ɵɵstyleProp, ɵɵstylePropInterpolate1, ɵɵstylePropInterpolate2, ɵɵstylePropInterpolate3, ɵɵstylePropInterpolate4, ɵɵstylePropInterpolate5, ɵɵstylePropInterpolate6, ɵɵstylePropInterpolate7, ɵɵstylePropInterpolate8, ɵɵstylePropInterpolateV, ɵɵsyntheticHostListener, ɵɵsyntheticHostProperty, ɵɵtemplate, ɵɵtemplateRefExtractor, ɵɵtext, ɵɵtextInterpolate, ɵɵtextInterpolate1, ɵɵtextInterpolate2, ɵɵtextInterpolate3, ɵɵtextInterpolate4, ɵɵtextInterpolate5, ɵɵtextInterpolate6, ɵɵtextInterpolate7, ɵɵtextInterpolate8, ɵɵtextInterpolateV, ɵɵtrustConstantHtml, ɵɵtrustConstantResourceUrl, ɵɵvalidateIframeAttribute, ɵɵviewQuery };
 //# sourceMappingURL=core.mjs.map