@angular/core 16.2.0-next.3 → 16.2.0-rc.0

package/fesm2022/core.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v16.2.0-next.3
+ * @license Angular v16.2.0-rc.0
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -604,6 +604,100 @@ function initNgDevMode() {
     return false;
 }
 
+let _injectorProfilerContext;
+function getInjectorProfilerContext() {
+    !ngDevMode && throwError('getInjectorProfilerContext should never be called in production mode');
+    return _injectorProfilerContext;
+}
+function setInjectorProfilerContext(context) {
+    !ngDevMode && throwError('setInjectorProfilerContext should never be called in production mode');
+    const previous = _injectorProfilerContext;
+    _injectorProfilerContext = context;
+    return previous;
+}
+let injectorProfilerCallback = null;
+/**
+ * Sets the callback function which will be invoked during certain DI events within the
+ * runtime (for example: injecting services, creating injectable instances, configuring providers)
+ *
+ * Warning: this function is *INTERNAL* and should not be relied upon in application's code.
+ * The contract of the function might be changed in any release and/or the function can be removed
+ * completely.
+ *
+ * @param profiler function provided by the caller or null value to disable profiling.
+ */
+const setInjectorProfiler = (injectorProfiler) => {
+    !ngDevMode && throwError('setInjectorProfiler should never be called in production mode');
+    injectorProfilerCallback = injectorProfiler;
+};
+/**
+ * Injector profiler function which emits on DI events executed by the runtime.
+ *
+ * @param event InjectorProfilerEvent corresponding to the DI event being emitted
+ */
+function injectorProfiler(event) {
+    !ngDevMode && throwError('Injector profiler should never be called in production mode');
+    if (injectorProfilerCallback != null /* both `null` and `undefined` */) {
+        injectorProfilerCallback(event);
+    }
+}
+/**
+ * Emits an InjectorProfilerEventType.ProviderConfigured to the injector profiler. The data in the
+ * emitted event includes the raw provider, as well as the token that provider is providing.
+ *
+ * @param provider A provider object
+ */
+function emitProviderConfiguredEvent(provider, isViewProvider = false) {
+    !ngDevMode && throwError('Injector profiler should never be called in production mode');
+    injectorProfiler({
+        type: 2 /* InjectorProfilerEventType.ProviderConfigured */,
+        context: getInjectorProfilerContext(),
+        providerRecord: {
+            token: typeof provider === 'function' ? provider : resolveForwardRef(provider.provide),
+            provider,
+            isViewProvider
+        }
+    });
+}
+/**
+ * Emits an event to the injector profiler with the instance that was created. Note that
+ * the injector associated with this emission can be accessed by using getDebugInjectContext()
+ *
+ * @param instance an object created by an injector
+ */
+function emitInstanceCreatedByInjectorEvent(instance) {
+    !ngDevMode && throwError('Injector profiler should never be called in production mode');
+    injectorProfiler({
+        type: 1 /* InjectorProfilerEventType.InstanceCreatedByInjector */,
+        context: getInjectorProfilerContext(),
+        instance: { value: instance }
+    });
+}
+/**
+ * @param token DI token associated with injected service
+ * @param value the instance of the injected service (i.e the result of `inject(token)`)
+ * @param flags the flags that the token was injected with
+ */
+function emitInjectEvent(token, value, flags) {
+    !ngDevMode && throwError('Injector profiler should never be called in production mode');
+    injectorProfiler({
+        type: 0 /* InjectorProfilerEventType.Inject */,
+        context: getInjectorProfilerContext(),
+        service: { token, value, flags }
+    });
+}
+function runInInjectorProfilerContext(injector, token, callback) {
+    !ngDevMode &&
+        throwError('runInInjectorProfilerContext should never be called in production mode');
+    const prevInjectContext = setInjectorProfilerContext({ injector, token });
+    try {
+        callback();
+    }
+    finally {
+        setInjectorProfilerContext(prevInjectContext);
+    }
+}
+
 const _THROW_IF_NOT_FOUND = {};
 const THROW_IF_NOT_FOUND = _THROW_IF_NOT_FOUND;
 /*
@@ -641,7 +735,9 @@ function injectInjectorOnly(token, flags = InjectFlags.Default) {
         return injectRootLimpMode(token, undefined, flags);
     }
     else {
-        return _currentInjector.get(token, flags & InjectFlags.Optional ? null : undefined, flags);
+        const value = _currentInjector.get(token, flags & InjectFlags.Optional ? null : undefined, flags);
+        ngDevMode && emitInjectEvent(token, value, flags);
+        return value;
     }
 }
 function ɵɵinject(token, flags = InjectFlags.Default) {
@@ -3731,14 +3827,14 @@ function registerPostOrderHooks(tView, tNode) {
  * This is done by storing and maintaining flags in the view: the {@link InitPhaseState},
  * and the index within that phase. They can be seen as a cursor in the following structure:
  * [[onInit1, onInit2], [afterContentInit1], [afterViewInit1, afterViewInit2, afterViewInit3]]
- * They are are stored as flags in LView[FLAGS].
+ * They are stored as flags in LView[FLAGS].
  *
  * 2. Pre-order hooks can be executed in batches, because of the select instruction.
  * To be able to pause and resume their execution, we also need some state about the hook's array
  * that is being processed:
  * - the index of the next hook to be executed
  * - the number of init hooks already found in the processed part of the  array
- * They are are stored as flags in LView[PREORDER_HOOK_FLAGS].
+ * They are stored as flags in LView[PREORDER_HOOK_FLAGS].
  */
 /**
  * Executes pre-order check hooks ( OnChanges, DoChanges) given a view where all the init hooks were
@@ -4498,7 +4594,18 @@ function lookupTokenUsingNodeInjector(tNode, lView, token, flags, notFoundValue)
                 lookupTokenUsingModuleInjector(lView, token, flags, notFoundValue);
         }
         try {
-            const value = bloomHash(flags);
+            let value;
+            if (ngDevMode) {
+                runInInjectorProfilerContext(new NodeInjector(getCurrentTNode(), getLView()), token, () => {
+                    value = bloomHash(flags);
+                    if (value != null) {
+                        emitInstanceCreatedByInjectorEvent(value);
+                    }
+                });
+            }
+            else {
+                value = bloomHash(flags);
+            }
             if (value == null && !(flags & InjectFlags.Optional)) {
                 throwProviderNotFoundError(token);
             }
@@ -4653,12 +4760,23 @@ function getNodeInjectable(lView, tView, index, tNode) {
         }
         const previousIncludeViewProviders = setIncludeViewProviders(factory.canSeeViewProviders);
         factory.resolving = true;
+        let prevInjectContext;
+        if (ngDevMode) {
+            // tData indexes mirror the concrete instances in its corresponding LView.
+            // lView[index] here is either the injectable instace itself or a factory,
+            // therefore tData[index] is the constructor of that injectable or a
+            // definition object that contains the constructor in a `.type` field.
+            const token = tData[index].type || tData[index];
+            const injector = new NodeInjector(tNode, lView);
+            prevInjectContext = setInjectorProfilerContext({ injector, token });
+        }
         const previousInjectImplementation = factory.injectImpl ? setInjectImplementation(factory.injectImpl) : null;
         const success = enterDI(lView, tNode, InjectFlags.Default);
         ngDevMode &&
             assertEqual(success, true, 'Because flags do not contain \`SkipSelf\' we expect this to always succeed.');
         try {
             value = lView[index] = factory.factory(undefined, tData, lView, tNode);
+            ngDevMode && emitInstanceCreatedByInjectorEvent(value);
             // This code path is hit for both directives and providers.
             // For perf reasons, we want to avoid searching for hooks on providers.
             // It does no harm to try (the hooks just won't exist), but the extra
@@ -4671,6 +4789,7 @@ function getNodeInjectable(lView, tView, index, tNode) {
             }
         }
         finally {
+            ngDevMode && setInjectorProfilerContext(prevInjectContext);
             previousInjectImplementation !== null &&
                 setInjectImplementation(previousInjectImplementation);
             setIncludeViewProviders(previousIncludeViewProviders);
@@ -4732,6 +4851,12 @@ function bloomHasToken(bloomHash, injectorIndex, injectorView) {
 function shouldSearchParent(flags, isFirstHostTNode) {
     return !(flags & InjectFlags.Self) && !(flags & InjectFlags.Host && isFirstHostTNode);
 }
+function getNodeInjectorLView(nodeInjector) {
+    return nodeInjector._lView;
+}
+function getNodeInjectorTNode(nodeInjector) {
+    return nodeInjector._tNode;
+}
 class NodeInjector {
     constructor(_tNode, _lView) {
         this._tNode = _tNode;
@@ -4992,10 +5117,10 @@ const emitDistinctChangesOnlyDefaultValue = true;
 /**
  * Base class for query metadata.
  *
- * @see {@link ContentChildren}.
- * @see {@link ContentChild}.
- * @see {@link ViewChildren}.
- * @see {@link ViewChild}.
+ * @see {@link ContentChildren}
+ * @see {@link ContentChild}
+ * @see {@link ViewChildren}
+ * @see {@link ViewChild}
  *
  * @publicApi
  */
@@ -8827,6 +8952,9 @@ function internalImportProvidersFrom(checkForStandaloneCmp, ...sources) {
     const providersOut = [];
     const dedup = new Set(); // already seen types
     let injectorTypesWithProviders;
+    const collectProviders = (provider) => {
+        providersOut.push(provider);
+    };
     deepForEach(sources, source => {
         if ((typeof ngDevMode === 'undefined' || ngDevMode) && checkForStandaloneCmp) {
             const cmpDef = getComponentDef(source);
@@ -8836,14 +8964,14 @@ function internalImportProvidersFrom(checkForStandaloneCmp, ...sources) {
         }
         // Narrow `source` to access the internal type analogue for `ModuleWithProviders`.
         const internalSource = source;
-        if (walkProviderTree(internalSource, providersOut, [], dedup)) {
+        if (walkProviderTree(internalSource, collectProviders, [], dedup)) {
             injectorTypesWithProviders ||= [];
             injectorTypesWithProviders.push(internalSource);
         }
     });
     // Collect all providers from `ModuleWithProviders` types.
     if (injectorTypesWithProviders !== undefined) {
-        processInjectorTypesWithProviders(injectorTypesWithProviders, providersOut);
+        processInjectorTypesWithProviders(injectorTypesWithProviders, collectProviders);
     }
     return providersOut;
 }
@@ -8851,12 +8979,12 @@ function internalImportProvidersFrom(checkForStandaloneCmp, ...sources) {
  * Collects all providers from the list of `ModuleWithProviders` and appends them to the provided
  * array.
  */
-function processInjectorTypesWithProviders(typesWithProviders, providersOut) {
+function processInjectorTypesWithProviders(typesWithProviders, visitor) {
     for (let i = 0; i < typesWithProviders.length; i++) {
         const { ngModule, providers } = typesWithProviders[i];
         deepForEachProvider(providers, provider => {
             ngDevMode && validateProvider(provider, providers || EMPTY_ARRAY, ngModule);
-            providersOut.push(provider);
+            visitor(provider, ngModule);
         });
     }
 }
@@ -8869,7 +8997,7 @@ function processInjectorTypesWithProviders(typesWithProviders, providersOut) {
  * to be processed. This allows us to process providers of injector types after all imports of
  * an injector definition are processed. (following View Engine semantics: see FW-1349)
  */
-function walkProviderTree(container, providersOut, parents, dedup) {
+function walkProviderTree(container, visitor, parents, dedup) {
     container = resolveForwardRef(container);
     if (!container)
         return false;
@@ -8917,7 +9045,7 @@ function walkProviderTree(container, providersOut, parents, dedup) {
         if (cmpDef.dependencies) {
             const deps = typeof cmpDef.dependencies === 'function' ? cmpDef.dependencies() : cmpDef.dependencies;
             for (const dep of deps) {
-                walkProviderTree(dep, providersOut, parents, dedup);
+                walkProviderTree(dep, visitor, parents, dedup);
             }
         }
     }
@@ -8932,7 +9060,7 @@ function walkProviderTree(container, providersOut, parents, dedup) {
             let importTypesWithProviders;
             try {
                 deepForEach(injDef.imports, imported => {
-                    if (walkProviderTree(imported, providersOut, parents, dedup)) {
+                    if (walkProviderTree(imported, visitor, parents, dedup)) {
                         importTypesWithProviders ||= [];
                         // If the processed import is an injector type with providers, we store it in the
                         // list of import types with providers, so that we can process those afterwards.
@@ -8948,7 +9076,7 @@ function walkProviderTree(container, providersOut, parents, dedup) {
             // after all imported modules are processed. This is similar to how View Engine
             // processes/merges module imports in the metadata resolver. See: FW-1349.
             if (importTypesWithProviders !== undefined) {
-                processInjectorTypesWithProviders(importTypesWithProviders, providersOut);
+                processInjectorTypesWithProviders(importTypesWithProviders, visitor);
             }
         }
         if (!isDuplicate) {
@@ -8958,14 +9086,12 @@ function walkProviderTree(container, providersOut, parents, dedup) {
             // Append extra providers to make more info available for consumers (to retrieve an injector
             // type), as well as internally (to calculate an injection scope correctly and eagerly
             // instantiate a `defType` when an injector is created).
-            providersOut.push(
             // Provider to create `defType` using its factory.
-            { provide: defType, useFactory: factory, deps: EMPTY_ARRAY }, 
+            visitor({ provide: defType, useFactory: factory, deps: EMPTY_ARRAY }, defType);
             // Make this `defType` available to an internal logic that calculates injector scope.
-            { provide: INJECTOR_DEF_TYPES, useValue: defType, multi: true }, 
-            // Provider to eagerly instantiate `defType` via `ENVIRONMENT_INITIALIZER`.
-            { provide: ENVIRONMENT_INITIALIZER, useValue: () => ɵɵinject(defType), multi: true } //
-            );
+            visitor({ provide: INJECTOR_DEF_TYPES, useValue: defType, multi: true }, defType);
+            // Provider to eagerly instantiate `defType` via `INJECTOR_INITIALIZER`.
+            visitor({ provide: ENVIRONMENT_INITIALIZER, useValue: () => ɵɵinject(defType), multi: true }, defType);
         }
         // Next, include providers listed on the definition itself.
         const defProviders = injDef.providers;
@@ -8973,7 +9099,7 @@ function walkProviderTree(container, providersOut, parents, dedup) {
             const injectorType = container;
             deepForEachProvider(defProviders, provider => {
                 ngDevMode && validateProvider(provider, defProviders, injectorType);
-                providersOut.push(provider);
+                visitor(provider, injectorType);
             });
         }
     }
@@ -9047,12 +9173,12 @@ const CIRCULAR = {};
 /**
  * A lazily initialized NullInjector.
  */
-let NULL_INJECTOR$1 = undefined;
+let NULL_INJECTOR = undefined;
 function getNullInjector() {
-    if (NULL_INJECTOR$1 === undefined) {
-        NULL_INJECTOR$1 = new NullInjector();
+    if (NULL_INJECTOR === undefined) {
+        NULL_INJECTOR = new NullInjector();
     }
-    return NULL_INJECTOR$1;
+    return NULL_INJECTOR;
 }
 /**
  * An `Injector` that's part of the environment injector hierarchy, which exists outside of the
@@ -9140,12 +9266,17 @@ class R3Injector extends EnvironmentInjector {
         this.assertNotDestroyed();
         const previousInjector = setCurrentInjector(this);
         const previousInjectImplementation = setInjectImplementation(undefined);
+        let prevInjectContext;
+        if (ngDevMode) {
+            prevInjectContext = setInjectorProfilerContext({ injector: this, token: null });
+        }
         try {
             return fn();
         }
         finally {
             setCurrentInjector(previousInjector);
             setInjectImplementation(previousInjectImplementation);
+            ngDevMode && setInjectorProfilerContext(prevInjectContext);
         }
     }
     get(token, notFoundValue = THROW_IF_NOT_FOUND, flags = InjectFlags.Default) {
@@ -9155,6 +9286,10 @@ class R3Injector extends EnvironmentInjector {
         }
         flags = convertToBitFlags(flags);
         // Set the injection context.
+        let prevInjectContext;
+        if (ngDevMode) {
+            prevInjectContext = setInjectorProfilerContext({ injector: this, token: token });
+        }
         const previousInjector = setCurrentInjector(this);
         const previousInjectImplementation = setInjectImplementation(undefined);
         try {
@@ -9212,12 +9347,17 @@ class R3Injector extends EnvironmentInjector {
             // Lastly, restore the previous injection context.
             setInjectImplementation(previousInjectImplementation);
             setCurrentInjector(previousInjector);
+            ngDevMode && setInjectorProfilerContext(prevInjectContext);
         }
     }
     /** @internal */
     resolveInjectorInitializers() {
         const previousInjector = setCurrentInjector(this);
         const previousInjectImplementation = setInjectImplementation(undefined);
+        let prevInjectContext;
+        if (ngDevMode) {
+            prevInjectContext = setInjectorProfilerContext({ injector: this, token: null });
+        }
         try {
             const initializers = this.get(ENVIRONMENT_INITIALIZER.multi, EMPTY_ARRAY, InjectFlags.Self);
             if (ngDevMode && !Array.isArray(initializers)) {
@@ -9233,6 +9373,7 @@ class R3Injector extends EnvironmentInjector {
         finally {
             setCurrentInjector(previousInjector);
             setInjectImplementation(previousInjectImplementation);
+            ngDevMode && setInjectorProfilerContext(prevInjectContext);
         }
     }
     toString() {
@@ -9258,6 +9399,17 @@ class R3Injector extends EnvironmentInjector {
         let token = isTypeProvider(provider) ? provider : resolveForwardRef(provider && provider.provide);
         // Construct a `Record` for the provider.
         const record = providerToRecord(provider);
+        if (ngDevMode) {
+            runInInjectorProfilerContext(this, token, () => {
+                // Emit InjectorProfilerEventType.Create if provider is a value provider because
+                // these are the only providers that do not go through the value hydration logic
+                // where this event would normally be emitted from.
+                if (isValueProvider(provider)) {
+                    emitInstanceCreatedByInjectorEvent(provider.useValue);
+                }
+                emitProviderConfiguredEvent(provider);
+            });
+        }
         if (!isTypeProvider(provider) && provider.multi === true) {
             // If the provider indicates that it's a multi-provider, process it specially.
             // First check whether it's been defined already.
@@ -9290,7 +9442,15 @@ class R3Injector extends EnvironmentInjector {
         }
         else if (record.value === NOT_YET) {
             record.value = CIRCULAR;
-            record.value = record.factory();
+            if (ngDevMode) {
+                runInInjectorProfilerContext(this, token, () => {
+                    record.value = record.factory();
+                    emitInstanceCreatedByInjectorEvent(record.value);
+                });
+            }
+            else {
+                record.value = record.factory();
+            }
         }
         if (typeof record.value === 'object' && record.value && hasOnDestroy(record.value)) {
             this._ngOnDestroyHooks.add(record.value);
@@ -10092,7 +10252,7 @@ class Version {
 /**
  * @publicApi
  */
-const VERSION = new Version('16.2.0-next.3');
+const VERSION = new Version('16.2.0-rc.0');
 
 // This default value is when checking the hierarchy for a token.
 //
@@ -10114,136 +10274,296 @@ const VERSION = new Version('16.2.0-next.3');
 const NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR = {};
 
 /**
- * Marks current view and all ancestors dirty.
+ * Runs the given function in the [context](guide/dependency-injection-context) of the given
+ * `Injector`.
  *
- * Returns the root view because it is found as a byproduct of marking the view tree
- * dirty, and can be used by methods that consume markViewDirty() to easily schedule
- * change detection. Otherwise, such methods would need to traverse up the view tree
- * an additional time to get the root view and schedule a tick on it.
+ * Within the function's stack frame, [`inject`](api/core/inject) can be used to inject dependencies
+ * from the given `Injector`. Note that `inject` is only usable synchronously, and cannot be used in
+ * any asynchronous callbacks or after any `await` points.
  *
- * @param lView The starting LView to mark dirty
- * @returns the root LView
+ * @param injector the injector which will satisfy calls to [`inject`](api/core/inject) while `fn`
+ *     is executing
+ * @param fn the closure to be run in the context of `injector`
+ * @returns the return value of the function, if any
+ * @publicApi
  */
-function markViewDirty(lView) {
-    while (lView) {
-        lView[FLAGS] |= 64 /* LViewFlags.Dirty */;
-        const parent = getLViewParent(lView);
-        // Stop traversing up as soon as you find a root view that wasn't attached to any container
-        if (isRootView(lView) && !parent) {
-            return lView;
-        }
-        // continue otherwise
-        lView = parent;
+function runInInjectionContext(injector, fn) {
+    if (injector instanceof R3Injector) {
+        injector.assertNotDestroyed();
+    }
+    let prevInjectorProfilerContext;
+    if (ngDevMode) {
+        prevInjectorProfilerContext = setInjectorProfilerContext({ injector, token: null });
+    }
+    const prevInjector = setCurrentInjector(injector);
+    const previousInjectImplementation = setInjectImplementation(undefined);
+    try {
+        return fn();
+    }
+    finally {
+        setCurrentInjector(prevInjector);
+        ngDevMode && setInjectorProfilerContext(prevInjectorProfilerContext);
+        setInjectImplementation(previousInjectImplementation);
     }
-    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
- *   }
- * }
+ * Asserts that the current stack frame is within an [injection
+ * context](guide/dependency-injection-context) and has access to `inject`.
  *
- * @NgModule({
- *   providers: [{provide: ErrorHandler, useClass: MyErrorHandler}]
- * })
- * class MyModule {}
- * ```
+ * @param debugFn a reference to the function making the assertion (used for the error message).
  *
  * @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;
+function assertInInjectionContext(debugFn) {
+    // Taking a `Function` instead of a string name here prevents the unminified name of the function
+    // from being retained in the bundle regardless of minification.
+    if (!getInjectImplementation() && !getCurrentInjector()) {
+        throw new RuntimeError(-203 /* RuntimeErrorCode.MISSING_INJECTION_CONTEXT */, ngDevMode &&
+            (debugFn.name +
+                '() can only be used within an injection context such as a constructor, a factory function, a field initializer, or a function used with `runInInjectionContext`'));
     }
 }
 
 /**
- * Internal token that specifies whether DOM reuse logic
- * during hydration is enabled.
+ * A mapping of the @angular/core API surface used in generated expressions to the actual symbols.
+ *
+ * This should be kept up to date with the public exports of @angular/core.
  */
-const IS_HYDRATION_DOM_REUSE_ENABLED = new InjectionToken((typeof ngDevMode === 'undefined' || !!ngDevMode) ? 'IS_HYDRATION_DOM_REUSE_ENABLED' : '');
-// By default (in client rendering mode), we remove all the contents
-// of the host element and render an application after that.
-const PRESERVE_HOST_CONTENT_DEFAULT = false;
+const angularCoreDiEnv = {
+    'ɵɵdefineInjectable': ɵɵdefineInjectable,
+    'ɵɵdefineInjector': ɵɵdefineInjector,
+    'ɵɵinject': ɵɵinject,
+    'ɵɵinvalidFactoryDep': ɵɵinvalidFactoryDep,
+    'resolveForwardRef': resolveForwardRef,
+};
+
 /**
- * Internal token that indicates whether host element content should be
- * retained during the bootstrap.
+ * Compile an Angular injectable according to its `Injectable` metadata, and patch the resulting
+ * injectable def (`ɵprov`) onto the injectable type.
  */
-const PRESERVE_HOST_CONTENT = new InjectionToken((typeof ngDevMode === 'undefined' || !!ngDevMode) ? 'PRESERVE_HOST_CONTENT' : '', {
-    providedIn: 'root',
-    factory: () => PRESERVE_HOST_CONTENT_DEFAULT,
-});
-
-function normalizeDebugBindingName(name) {
-    // Attribute names with `$` (eg `x-y$`) are valid per spec, but unsupported by some browsers
-    name = camelCaseToDashCase(name.replace(/[$@]/g, '_'));
-    return `ng-reflect-${name}`;
-}
-const CAMEL_CASE_REGEXP = /([A-Z])/g;
-function camelCaseToDashCase(input) {
-    return input.replace(CAMEL_CASE_REGEXP, (...m) => '-' + m[1].toLowerCase());
-}
-function normalizeDebugBindingValue(value) {
-    try {
-        // Limit the size of the value as otherwise the DOM just gets polluted.
-        return value != null ? value.toString().slice(0, 30) : value;
+function compileInjectable(type, meta) {
+    let ngInjectableDef = null;
+    let ngFactoryDef = null;
+    // if NG_PROV_DEF is already defined on this class then don't overwrite it
+    if (!type.hasOwnProperty(NG_PROV_DEF)) {
+        Object.defineProperty(type, NG_PROV_DEF, {
+            get: () => {
+                if (ngInjectableDef === null) {
+                    const compiler = getCompilerFacade({ usage: 0 /* JitCompilerUsage.Decorator */, kind: 'injectable', type });
+                    ngInjectableDef = compiler.compileInjectable(angularCoreDiEnv, `ng:///${type.name}/ɵprov.js`, getInjectableMetadata(type, meta));
+                }
+                return ngInjectableDef;
+            },
+        });
     }
-    catch (e) {
-        return '[ERROR] Exception while trying to serialize the value';
+    // if NG_FACTORY_DEF is already defined on this class then don't overwrite it
+    if (!type.hasOwnProperty(NG_FACTORY_DEF)) {
+        Object.defineProperty(type, NG_FACTORY_DEF, {
+            get: () => {
+                if (ngFactoryDef === null) {
+                    const compiler = getCompilerFacade({ usage: 0 /* JitCompilerUsage.Decorator */, kind: 'injectable', type });
+                    ngFactoryDef = compiler.compileFactory(angularCoreDiEnv, `ng:///${type.name}/ɵfac.js`, {
+                        name: type.name,
+                        type,
+                        typeArgumentCount: 0,
+                        deps: reflectDependencies(type),
+                        target: compiler.FactoryTarget.Injectable
+                    });
+                }
+                return ngFactoryDef;
+            },
+            // Leave this configurable so that the factories from directives or pipes can take precedence.
+            configurable: true
+        });
     }
 }
-
-/**
- *
- * @codeGenApi
- */
-function ɵɵresolveWindow(element) {
-    return element.ownerDocument.defaultView;
+const USE_VALUE = getClosureSafeProperty({ provide: String, useValue: getClosureSafeProperty });
+function isUseClassProvider(meta) {
+    return meta.useClass !== undefined;
 }
-/**
- *
- * @codeGenApi
+function isUseValueProvider(meta) {
+    return USE_VALUE in meta;
+}
+function isUseFactoryProvider(meta) {
+    return meta.useFactory !== undefined;
+}
+function isUseExistingProvider(meta) {
+    return meta.useExisting !== undefined;
+}
+function getInjectableMetadata(type, srcMeta) {
+    // Allow the compilation of a class with a `@Injectable()` decorator without parameters
+    const meta = srcMeta || { providedIn: null };
+    const compilerMeta = {
+        name: type.name,
+        type: type,
+        typeArgumentCount: 0,
+        providedIn: meta.providedIn,
+    };
+    if ((isUseClassProvider(meta) || isUseFactoryProvider(meta)) && meta.deps !== undefined) {
+        compilerMeta.deps = convertDependencies(meta.deps);
+    }
+    // Check to see if the user explicitly provided a `useXxxx` property.
+    if (isUseClassProvider(meta)) {
+        compilerMeta.useClass = meta.useClass;
+    }
+    else if (isUseValueProvider(meta)) {
+        compilerMeta.useValue = meta.useValue;
+    }
+    else if (isUseFactoryProvider(meta)) {
+        compilerMeta.useFactory = meta.useFactory;
+    }
+    else if (isUseExistingProvider(meta)) {
+        compilerMeta.useExisting = meta.useExisting;
+    }
+    return compilerMeta;
+}
+
+/**
+ * Injectable decorator and metadata.
+ *
+ * @Annotation
+ * @publicApi
+ */
+const Injectable = makeDecorator('Injectable', undefined, undefined, undefined, (type, meta) => compileInjectable(type, meta));
+
+/**
+ * Create a new `Injector` which is configured using a `defType` of `InjectorType<any>`s.
+ */
+function createInjector(defType, parent = null, additionalProviders = null, name) {
+    const injector = createInjectorWithoutInjectorInstances(defType, parent, additionalProviders, name);
+    injector.resolveInjectorInitializers();
+    return injector;
+}
+/**
+ * Creates a new injector without eagerly resolving its injector types. Can be used in places
+ * where resolving the injector types immediately can lead to an infinite loop. The injector types
+ * should be resolved at a later point by calling `_resolveInjectorDefTypes`.
+ */
+function createInjectorWithoutInjectorInstances(defType, parent = null, additionalProviders = null, name, scopes = new Set()) {
+    const providers = [
+        additionalProviders || EMPTY_ARRAY,
+        importProvidersFrom(defType),
+    ];
+    name = name || (typeof defType === 'object' ? undefined : stringify(defType));
+    return new R3Injector(providers, parent || getNullInjector(), name || null, scopes);
+}
+
+/**
+ * Concrete injectors implement this interface. Injectors are configured
+ * with [providers](guide/glossary#provider) that associate
+ * dependencies of various types with [injection tokens](guide/glossary#di-token).
+ *
+ * @see ["DI Providers"](guide/dependency-injection-providers).
+ * @see {@link StaticProvider}
+ *
+ * @usageNotes
+ *
+ *  The following example creates a service injector instance.
+ *
+ * {@example core/di/ts/provider_spec.ts region='ConstructorProvider'}
+ *
+ * ### Usage example
+ *
+ * {@example core/di/ts/injector_spec.ts region='Injector'}
+ *
+ * `Injector` returns itself when given `Injector` as a token:
+ *
+ * {@example core/di/ts/injector_spec.ts region='injectInjector'}
+ *
+ * @publicApi
+ */
+class Injector {
+    static { this.THROW_IF_NOT_FOUND = THROW_IF_NOT_FOUND; }
+    static { this.NULL = ( /* @__PURE__ */new NullInjector()); }
+    static create(options, parent) {
+        if (Array.isArray(options)) {
+            return createInjector({ name: '' }, parent, options, '');
+        }
+        else {
+            const name = options.name ?? '';
+            return createInjector({ name }, options.parent, options.providers, name);
+        }
+    }
+    /** @nocollapse */
+    static { this.ɵprov = ɵɵdefineInjectable({
+        token: Injector,
+        providedIn: 'any',
+        factory: () => ɵɵinject(INJECTOR),
+    }); }
+    /**
+     * @internal
+     * @nocollapse
+     */
+    static { this.__NG_ELEMENT_ID__ = -1 /* InjectorMarkers.Injector */; }
+}
+
+/**
+ * @module
+ * @description
+ * The `di` module provides dependency injection container services.
+ */
+
+/**
+ * This file should not be necessary because node resolution should just default to `./di/index`!
+ *
+ * However it does not seem to work and it breaks:
+ *  - //packages/animations/browser/test:test_web_chromium-local
+ *  - //packages/compiler-cli/test:extract_i18n
+ *  - //packages/compiler-cli/test:ngc
+ *  - //packages/compiler-cli/test:perform_watch
+ *  - //packages/compiler-cli/test/diagnostics:check_types
+ *  - //packages/compiler-cli/test/transformers:test
+ *  - //packages/compiler/test:test
+ *  - //tools/public_api_guard:core_api
+ *
+ * Remove this file once the above is solved or wait until `ngc` is deleted and then it should be
+ * safe to delete this file.
+ */
+
+/**
+ * `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`
+ * is injected in a component or directive, the callbacks run when that component or
+ * directive is destroyed. Otherwise the callbacks run when a corresponding injector is destroyed.
+ *
+ * @publicApi
+ */
+class DestroyRef {
+    /**
+     * @internal
+     * @nocollapse
+     */
+    static { this.__NG_ELEMENT_ID__ = injectDestroyRef; }
+    /**
+     * @internal
+     * @nocollapse
+     */
+    static { this.__NG_ENV_ID__ = (injector) => injector; }
+}
+class NodeInjectorDestroyRef extends DestroyRef {
+    constructor(_lView) {
+        super();
+        this._lView = _lView;
+    }
+    onDestroy(callback) {
+        storeLViewOnDestroy(this._lView, callback);
+        return () => removeLViewOnDestroy(this._lView, callback);
+    }
+}
+function injectDestroyRef() {
+    return new NodeInjectorDestroyRef(getLView());
+}
+
+/**
+ *
+ * @codeGenApi
+ */
+function ɵɵresolveWindow(element) {
+    return element.ownerDocument.defaultView;
+}
+/**
+ *
+ * @codeGenApi
  */
 function ɵɵresolveDocument(element) {
     return element.ownerDocument;
@@ -10277,8 +10597,335 @@ function maybeUnwrapFn(value) {
     if (value instanceof Function) {
         return value();
     }
-    else {
-        return value;
+    else {
+        return value;
+    }
+}
+/**
+ * Detects whether the code is invoked in a browser.
+ * Later on, this check should be replaced with a tree-shakable
+ * flag (e.g. `!isServer`).
+ */
+function isPlatformBrowser(injector) {
+    return (injector ?? inject(Injector)).get(PLATFORM_ID) === 'browser';
+}
+
+/**
+ * Register a callback to be invoked each time the application
+ * finishes rendering.
+ *
+ * Note that the callback will run
+ * - in the order it was registered
+ * - once per render
+ * - on browser platforms only
+ *
+ * <div class="alert is-important">
+ *
+ * Components are not guaranteed to be [hydrated](guide/hydration) before the callback runs.
+ * You must use caution when directly reading or writing the DOM and layout.
+ *
+ * </div>
+ *
+ * @param callback A callback function to register
+ *
+ * @usageNotes
+ *
+ * Use `afterRender` to read or write the DOM after each render.
+ *
+ * ### Example
+ * ```ts
+ * @Component({
+ *   selector: 'my-cmp',
+ *   template: `<span #content>{{ ... }}</span>`,
+ * })
+ * export class MyComponent {
+ *   @ViewChild('content') contentRef: ElementRef;
+ *
+ *   constructor() {
+ *     afterRender(() => {
+ *       console.log('content height: ' + this.contentRef.nativeElement.scrollHeight);
+ *     });
+ *   }
+ * }
+ * ```
+ *
+ * @developerPreview
+ */
+function afterRender(callback, options) {
+    !options && assertInInjectionContext(afterRender);
+    const injector = options?.injector ?? inject(Injector);
+    if (!isPlatformBrowser(injector)) {
+        return { destroy() { } };
+    }
+    let destroy;
+    const unregisterFn = injector.get(DestroyRef).onDestroy(() => destroy?.());
+    const manager = injector.get(AfterRenderEventManager);
+    const instance = new AfterRenderCallback(callback);
+    destroy = () => {
+        manager.unregister(instance);
+        unregisterFn();
+    };
+    manager.register(instance);
+    return { destroy };
+}
+/**
+ * Register a callback to be invoked the next time the application
+ * finishes rendering.
+ *
+ * Note that the callback will run
+ * - in the order it was registered
+ * - on browser platforms only
+ *
+ * <div class="alert is-important">
+ *
+ * Components are not guaranteed to be [hydrated](guide/hydration) before the callback runs.
+ * You must use caution when directly reading or writing the DOM and layout.
+ *
+ * </div>
+ *
+ * @param callback A callback function to register
+ *
+ * @usageNotes
+ *
+ * Use `afterNextRender` to read or write the DOM once,
+ * for example to initialize a non-Angular library.
+ *
+ * ### Example
+ * ```ts
+ * @Component({
+ *   selector: 'my-chart-cmp',
+ *   template: `<div #chart>{{ ... }}</div>`,
+ * })
+ * export class MyChartCmp {
+ *   @ViewChild('chart') chartRef: ElementRef;
+ *   chart: MyChart|null;
+ *
+ *   constructor() {
+ *     afterNextRender(() => {
+ *       this.chart = new MyChart(this.chartRef.nativeElement);
+ *     });
+ *   }
+ * }
+ * ```
+ *
+ * @developerPreview
+ */
+function afterNextRender(callback, options) {
+    !options && assertInInjectionContext(afterNextRender);
+    const injector = options?.injector ?? inject(Injector);
+    if (!isPlatformBrowser(injector)) {
+        return { destroy() { } };
+    }
+    let destroy;
+    const unregisterFn = injector.get(DestroyRef).onDestroy(() => destroy?.());
+    const manager = injector.get(AfterRenderEventManager);
+    const instance = new AfterRenderCallback(() => {
+        destroy?.();
+        callback();
+    });
+    destroy = () => {
+        manager.unregister(instance);
+        unregisterFn();
+    };
+    manager.register(instance);
+    return { destroy };
+}
+/**
+ * A wrapper around a function to be used as an after render callback.
+ * @private
+ */
+class AfterRenderCallback {
+    constructor(callback) {
+        this.callback = callback;
+    }
+    invoke() {
+        this.callback();
+    }
+}
+/**
+ * Implements `afterRender` and `afterNextRender` callback manager logic.
+ */
+class AfterRenderEventManager {
+    constructor() {
+        this.callbacks = new Set();
+        this.deferredCallbacks = new Set();
+        this.renderDepth = 0;
+        this.runningCallbacks = false;
+    }
+    /**
+     * Mark the beginning of a render operation (i.e. CD cycle).
+     * Throws if called from an `afterRender` callback.
+     */
+    begin() {
+        if (this.runningCallbacks) {
+            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?');
+        }
+        this.renderDepth++;
+    }
+    /**
+     * Mark the end of a render operation. Registered callbacks
+     * are invoked if there are no more pending operations.
+     */
+    end() {
+        this.renderDepth--;
+        if (this.renderDepth === 0) {
+            try {
+                this.runningCallbacks = true;
+                for (const callback of this.callbacks) {
+                    callback.invoke();
+                }
+            }
+            finally {
+                this.runningCallbacks = false;
+                for (const callback of this.deferredCallbacks) {
+                    this.callbacks.add(callback);
+                }
+                this.deferredCallbacks.clear();
+            }
+        }
+    }
+    register(callback) {
+        // If we're currently running callbacks, new callbacks should be deferred
+        // until the next render operation.
+        const target = this.runningCallbacks ? this.deferredCallbacks : this.callbacks;
+        target.add(callback);
+    }
+    unregister(callback) {
+        this.callbacks.delete(callback);
+        this.deferredCallbacks.delete(callback);
+    }
+    ngOnDestroy() {
+        this.callbacks.clear();
+        this.deferredCallbacks.clear();
+    }
+    /** @nocollapse */
+    static { this.ɵprov = ɵɵdefineInjectable({
+        token: AfterRenderEventManager,
+        providedIn: 'root',
+        factory: () => new AfterRenderEventManager(),
+    }); }
+}
+
+/**
+ * Marks current view and all ancestors dirty.
+ *
+ * Returns the root view because it is found as a byproduct of marking the view tree
+ * dirty, and can be used by methods that consume markViewDirty() to easily schedule
+ * change detection. Otherwise, such methods would need to traverse up the view tree
+ * an additional time to get the root view and schedule a tick on it.
+ *
+ * @param lView The starting LView to mark dirty
+ * @returns the root LView
+ */
+function markViewDirty(lView) {
+    while (lView) {
+        lView[FLAGS] |= 64 /* LViewFlags.Dirty */;
+        const parent = getLViewParent(lView);
+        // Stop traversing up as soon as you find a root view that wasn't attached to any container
+        if (isRootView(lView) && !parent) {
+            return lView;
+        }
+        // continue otherwise
+        lView = parent;
+    }
+    return null;
+}
+
+const 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.
+ */
+const IS_HYDRATION_DOM_REUSE_ENABLED = new InjectionToken((typeof ngDevMode === 'undefined' || !!ngDevMode) ? 'IS_HYDRATION_DOM_REUSE_ENABLED' : '');
+// By default (in client rendering mode), we remove all the contents
+// of the host element and render an application after that.
+const PRESERVE_HOST_CONTENT_DEFAULT = false;
+/**
+ * Internal token that indicates whether host element content should be
+ * retained during the bootstrap.
+ */
+const PRESERVE_HOST_CONTENT = new InjectionToken((typeof ngDevMode === 'undefined' || !!ngDevMode) ? 'PRESERVE_HOST_CONTENT' : '', {
+    providedIn: 'root',
+    factory: () => PRESERVE_HOST_CONTENT_DEFAULT,
+});
+
+function normalizeDebugBindingName(name) {
+    // Attribute names with `$` (eg `x-y$`) are valid per spec, but unsupported by some browsers
+    name = camelCaseToDashCase(name.replace(/[$@]/g, '_'));
+    return `ng-reflect-${name}`;
+}
+const CAMEL_CASE_REGEXP = /([A-Z])/g;
+function camelCaseToDashCase(input) {
+    return input.replace(CAMEL_CASE_REGEXP, (...m) => '-' + m[1].toLowerCase());
+}
+function normalizeDebugBindingValue(value) {
+    try {
+        // Limit the size of the value as otherwise the DOM just gets polluted.
+        return value != null ? value.toString().slice(0, 30) : value;
+    }
+    catch (e) {
+        return '[ERROR] Exception while trying to serialize the value';
     }
 }
 
@@ -10511,253 +11158,9 @@ function selectIndexInternal(tView, lView, index, checkNoChangesMode) {
     // We must set the selected index *after* running the hooks, because hooks may have side-effects
     // that cause other template functions to run, thus updating the selected index, which is global
     // state. If we run `setSelectedIndex` *before* we run the hooks, in some cases the selected index
-    // will be altered by the time we leave the `ɵɵadvance` instruction.
-    setSelectedIndex(index);
-}
-
-/**
- * Runs the given function in the [context](guide/dependency-injection-context) of the given
- * `Injector`.
- *
- * Within the function's stack frame, [`inject`](api/core/inject) can be used to inject dependencies
- * from the given `Injector`. Note that `inject` is only usable synchronously, and cannot be used in
- * any asynchronous callbacks or after any `await` points.
- *
- * @param injector the injector which will satisfy calls to [`inject`](api/core/inject) while `fn`
- *     is executing
- * @param fn the closure to be run in the context of `injector`
- * @returns the return value of the function, if any
- * @publicApi
- */
-function runInInjectionContext(injector, fn) {
-    if (injector instanceof R3Injector) {
-        injector.assertNotDestroyed();
-    }
-    const prevInjector = setCurrentInjector(injector);
-    const previousInjectImplementation = setInjectImplementation(undefined);
-    try {
-        return fn();
-    }
-    finally {
-        setCurrentInjector(prevInjector);
-        setInjectImplementation(previousInjectImplementation);
-    }
-}
-/**
- * Asserts that the current stack frame is within an [injection
- * context](guide/dependency-injection-context) and has access to `inject`.
- *
- * @param debugFn a reference to the function making the assertion (used for the error message).
- *
- * @publicApi
- */
-function assertInInjectionContext(debugFn) {
-    // Taking a `Function` instead of a string name here prevents the unminified name of the function
-    // from being retained in the bundle regardless of minification.
-    if (!getInjectImplementation() && !getCurrentInjector()) {
-        throw new RuntimeError(-203 /* RuntimeErrorCode.MISSING_INJECTION_CONTEXT */, ngDevMode &&
-            (debugFn.name +
-                '() can only be used within an injection context such as a constructor, a factory function, a field initializer, or a function used with `runInInjectionContext`'));
-    }
-}
-
-/**
- * A mapping of the @angular/core API surface used in generated expressions to the actual symbols.
- *
- * This should be kept up to date with the public exports of @angular/core.
- */
-const angularCoreDiEnv = {
-    'ɵɵdefineInjectable': ɵɵdefineInjectable,
-    'ɵɵdefineInjector': ɵɵdefineInjector,
-    'ɵɵinject': ɵɵinject,
-    'ɵɵinvalidFactoryDep': ɵɵinvalidFactoryDep,
-    'resolveForwardRef': resolveForwardRef,
-};
-
-/**
- * Compile an Angular injectable according to its `Injectable` metadata, and patch the resulting
- * injectable def (`ɵprov`) onto the injectable type.
- */
-function compileInjectable(type, meta) {
-    let ngInjectableDef = null;
-    let ngFactoryDef = null;
-    // if NG_PROV_DEF is already defined on this class then don't overwrite it
-    if (!type.hasOwnProperty(NG_PROV_DEF)) {
-        Object.defineProperty(type, NG_PROV_DEF, {
-            get: () => {
-                if (ngInjectableDef === null) {
-                    const compiler = getCompilerFacade({ usage: 0 /* JitCompilerUsage.Decorator */, kind: 'injectable', type });
-                    ngInjectableDef = compiler.compileInjectable(angularCoreDiEnv, `ng:///${type.name}/ɵprov.js`, getInjectableMetadata(type, meta));
-                }
-                return ngInjectableDef;
-            },
-        });
-    }
-    // if NG_FACTORY_DEF is already defined on this class then don't overwrite it
-    if (!type.hasOwnProperty(NG_FACTORY_DEF)) {
-        Object.defineProperty(type, NG_FACTORY_DEF, {
-            get: () => {
-                if (ngFactoryDef === null) {
-                    const compiler = getCompilerFacade({ usage: 0 /* JitCompilerUsage.Decorator */, kind: 'injectable', type });
-                    ngFactoryDef = compiler.compileFactory(angularCoreDiEnv, `ng:///${type.name}/ɵfac.js`, {
-                        name: type.name,
-                        type,
-                        typeArgumentCount: 0,
-                        deps: reflectDependencies(type),
-                        target: compiler.FactoryTarget.Injectable
-                    });
-                }
-                return ngFactoryDef;
-            },
-            // Leave this configurable so that the factories from directives or pipes can take precedence.
-            configurable: true
-        });
-    }
-}
-const USE_VALUE = getClosureSafeProperty({ provide: String, useValue: getClosureSafeProperty });
-function isUseClassProvider(meta) {
-    return meta.useClass !== undefined;
-}
-function isUseValueProvider(meta) {
-    return USE_VALUE in meta;
-}
-function isUseFactoryProvider(meta) {
-    return meta.useFactory !== undefined;
-}
-function isUseExistingProvider(meta) {
-    return meta.useExisting !== undefined;
-}
-function getInjectableMetadata(type, srcMeta) {
-    // Allow the compilation of a class with a `@Injectable()` decorator without parameters
-    const meta = srcMeta || { providedIn: null };
-    const compilerMeta = {
-        name: type.name,
-        type: type,
-        typeArgumentCount: 0,
-        providedIn: meta.providedIn,
-    };
-    if ((isUseClassProvider(meta) || isUseFactoryProvider(meta)) && meta.deps !== undefined) {
-        compilerMeta.deps = convertDependencies(meta.deps);
-    }
-    // Check to see if the user explicitly provided a `useXxxx` property.
-    if (isUseClassProvider(meta)) {
-        compilerMeta.useClass = meta.useClass;
-    }
-    else if (isUseValueProvider(meta)) {
-        compilerMeta.useValue = meta.useValue;
-    }
-    else if (isUseFactoryProvider(meta)) {
-        compilerMeta.useFactory = meta.useFactory;
-    }
-    else if (isUseExistingProvider(meta)) {
-        compilerMeta.useExisting = meta.useExisting;
-    }
-    return compilerMeta;
-}
-
-/**
- * Injectable decorator and metadata.
- *
- * @Annotation
- * @publicApi
- */
-const Injectable = makeDecorator('Injectable', undefined, undefined, undefined, (type, meta) => compileInjectable(type, meta));
-
-/**
- * Create a new `Injector` which is configured using a `defType` of `InjectorType<any>`s.
- *
- * @publicApi
- */
-function createInjector(defType, parent = null, additionalProviders = null, name) {
-    const injector = createInjectorWithoutInjectorInstances(defType, parent, additionalProviders, name);
-    injector.resolveInjectorInitializers();
-    return injector;
-}
-/**
- * Creates a new injector without eagerly resolving its injector types. Can be used in places
- * where resolving the injector types immediately can lead to an infinite loop. The injector types
- * should be resolved at a later point by calling `_resolveInjectorDefTypes`.
- */
-function createInjectorWithoutInjectorInstances(defType, parent = null, additionalProviders = null, name, scopes = new Set()) {
-    const providers = [
-        additionalProviders || EMPTY_ARRAY,
-        importProvidersFrom(defType),
-    ];
-    name = name || (typeof defType === 'object' ? undefined : stringify(defType));
-    return new R3Injector(providers, parent || getNullInjector(), name || null, scopes);
-}
-
-/**
- * Concrete injectors implement this interface. Injectors are configured
- * with [providers](guide/glossary#provider) that associate
- * dependencies of various types with [injection tokens](guide/glossary#di-token).
- *
- * @see ["DI Providers"](guide/dependency-injection-providers).
- * @see {@link StaticProvider}
- *
- * @usageNotes
- *
- *  The following example creates a service injector instance.
- *
- * {@example core/di/ts/provider_spec.ts region='ConstructorProvider'}
- *
- * ### Usage example
- *
- * {@example core/di/ts/injector_spec.ts region='Injector'}
- *
- * `Injector` returns itself when given `Injector` as a token:
- *
- * {@example core/di/ts/injector_spec.ts region='injectInjector'}
- *
- * @publicApi
- */
-class Injector {
-    static { this.THROW_IF_NOT_FOUND = THROW_IF_NOT_FOUND; }
-    static { this.NULL = ( /* @__PURE__ */new NullInjector()); }
-    static create(options, parent) {
-        if (Array.isArray(options)) {
-            return createInjector({ name: '' }, parent, options, '');
-        }
-        else {
-            const name = options.name ?? '';
-            return createInjector({ name }, options.parent, options.providers, name);
-        }
-    }
-    /** @nocollapse */
-    static { this.ɵprov = ɵɵdefineInjectable({
-        token: Injector,
-        providedIn: 'any',
-        factory: () => ɵɵinject(INJECTOR),
-    }); }
-    /**
-     * @internal
-     * @nocollapse
-     */
-    static { this.__NG_ELEMENT_ID__ = -1 /* InjectorMarkers.Injector */; }
-}
-
-/**
- * @module
- * @description
- * The `di` module provides dependency injection container services.
- */
-
-/**
- * This file should not be necessary because node resolution should just default to `./di/index`!
- *
- * However it does not seem to work and it breaks:
- *  - //packages/animations/browser/test:test_web_chromium-local
- *  - //packages/compiler-cli/test:extract_i18n
- *  - //packages/compiler-cli/test:ngc
- *  - //packages/compiler-cli/test:perform_watch
- *  - //packages/compiler-cli/test/diagnostics:check_types
- *  - //packages/compiler-cli/test/transformers:test
- *  - //packages/compiler/test:test
- *  - //tools/public_api_guard:core_api
- *
- * Remove this file once the above is solved or wait until `ngc` is deleted and then it should be
- * safe to delete this file.
- */
+    // will be altered by the time we leave the `ɵɵadvance` instruction.
+    setSelectedIndex(index);
+}
 
 function ɵɵdirectiveInject(token, flags = InjectFlags.Default) {
     const lView = getLView();
@@ -10769,7 +11172,9 @@ function ɵɵdirectiveInject(token, flags = InjectFlags.Default) {
         return ɵɵinject(token, flags);
     }
     const tNode = getCurrentTNode();
-    return getOrCreateInjectable(tNode, lView, resolveForwardRef(token), flags);
+    const value = getOrCreateInjectable(tNode, lView, resolveForwardRef(token), flags);
+    ngDevMode && emitInjectEvent(token, value, flags);
+    return value;
 }
 /**
  * Throws an error indicating that a factory function could not be generated by the compiler for a
@@ -12210,40 +12615,6 @@ function renderChildComponents(hostLView, components) {
     }
 }
 
-/**
- * `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`
- * is injected in a component or directive, the callbacks run when that component or
- * directive is destroyed. Otherwise the callbacks run when a corresponding injector is destroyed.
- *
- * @publicApi
- */
-class DestroyRef {
-    /**
-     * @internal
-     * @nocollapse
-     */
-    static { this.__NG_ELEMENT_ID__ = injectDestroyRef; }
-    /**
-     * @internal
-     * @nocollapse
-     */
-    static { this.__NG_ENV_ID__ = (injector) => injector; }
-}
-class NodeInjectorDestroyRef extends DestroyRef {
-    constructor(_lView) {
-        super();
-        this._lView = _lView;
-    }
-    onDestroy(callback) {
-        storeLViewOnDestroy(this._lView, callback);
-        return () => removeLViewOnDestroy(this._lView, callback);
-    }
-}
-function injectDestroyRef() {
-    return new NodeInjectorDestroyRef(getLView());
-}
-
 /**
  * Tracks all effects registered within a given application and runs them via `flush`.
  */
@@ -12412,13 +12783,17 @@ function collectNativeNodes(tView, lView, tNode, result, isProjection = false) {
 }
 
 function detectChangesInternal(tView, lView, context, notifyErrorHandler = true) {
-    const rendererFactory = lView[ENVIRONMENT].rendererFactory;
+    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)
-        rendererFactory.begin();
+    if (!checkNoChangesMode) {
+        rendererFactory.begin?.();
+        afterRenderEventManager?.begin();
+    }
     try {
         refreshView(tView, lView, tView.template, context);
     }
@@ -12429,11 +12804,14 @@ function detectChangesInternal(tView, lView, context, notifyErrorHandler = true)
         throw error;
     }
     finally {
-        if (!checkNoChangesMode && rendererFactory.end)
-            rendererFactory.end();
-        // One final flush of the effects queue to catch any effects created in `ngAfterViewInit` or
-        // other post-order hooks.
-        !checkNoChangesMode && lView[ENVIRONMENT].effectManager?.flush();
+        if (!checkNoChangesMode) {
+            rendererFactory.end?.();
+            // One final flush of the effects queue to catch any effects created in `ngAfterViewInit` or
+            // other post-order hooks.
+            environment.effectManager?.flush();
+            // Invoke all callbacks registered via `after*Render`, if needed.
+            afterRenderEventManager?.end();
+        }
     }
 }
 function checkNoChangesInternal(tView, lView, context, notifyErrorHandler = true) {
@@ -13054,10 +13432,12 @@ class ComponentFactory extends ComponentFactory$1 {
         }
         const sanitizer = rootViewInjector.get(Sanitizer, null);
         const effectManager = rootViewInjector.get(EffectManager, null);
+        const afterRenderEventManager = rootViewInjector.get(AfterRenderEventManager, null);
         const environment = {
             rendererFactory,
             sanitizer,
             effectManager,
+            afterRenderEventManager,
         };
         const hostRenderer = rendererFactory.createRenderer(null, this.componentDef);
         // Determine a tag name used for creating host elements when this component is created
@@ -13175,12 +13555,6 @@ class ComponentRef extends ComponentRef$1 {
         this.hostView.onDestroy(callback);
     }
 }
-// TODO: A hack to not pull in the NullInjector from @angular/core.
-const NULL_INJECTOR = {
-    get: (token, notFoundValue) => {
-        throwProviderNotFoundError(token, 'NullInjector');
-    }
-};
 /** Creates a TNode that can be used to instantiate a root component. */
 function createRootComponentTNode(lView, rNode) {
     const tView = lView[TVIEW];
@@ -21290,6 +21664,18 @@ function ɵɵi18nPostprocess(message, replacements = {}) {
     return i18nPostprocess(message, replacements);
 }
 
+/**
+ * Creates runtime data structures for `{#defer}` blocks.
+ *
+ * @param index The index of the defer block in the data array
+ * @param deferredDepsFn Function that contains dependencies for this defer block
+ *
+ * @codeGenApi
+ */
+function ɵɵdefer(index, deferredDepsFn) {
+    // TODO: implement runtime logic.
+}
+
 /*
  * This file re-exports all symbols contained in this directory.
  *
@@ -21354,9 +21740,15 @@ function resolveProvider(provider, tInjectables, lInjectablesBlueprint, isCompon
     else {
         const tView = getTView();
         const lView = getLView();
-        let token = isTypeProvider(provider) ? provider : resolveForwardRef(provider.provide);
-        let providerFactory = providerToFactory(provider);
         const tNode = getCurrentTNode();
+        let token = isTypeProvider(provider) ? provider : resolveForwardRef(provider.provide);
+        const providerFactory = providerToFactory(provider);
+        if (ngDevMode) {
+            const injector = new NodeInjector(tNode, lView);
+            runInInjectorProfilerContext(injector, token, () => {
+                emitProviderConfiguredEvent(provider, isViewProvider);
+            });
+        }
         const beginIndex = tNode.providerIndexes & 1048575 /* TNodeProviderIndexes.ProvidersStartIndexMask */;
         const endIndex = tNode.directiveStart;
         const cptViewProvidersCount = tNode.providerIndexes >> 20 /* TNodeProviderIndexes.CptViewProvidersCountShift */;
@@ -22576,6 +22968,13 @@ function ɵɵpipe(index, pipeName) {
         pipeDef = tView.data[adjustedIndex];
     }
     const pipeFactory = pipeDef.factory || (pipeDef.factory = getFactoryDef(pipeDef.type, true));
+    let previousInjectorProfilerContext;
+    if (ngDevMode) {
+        previousInjectorProfilerContext = setInjectorProfilerContext({
+            injector: new NodeInjector(getCurrentTNode(), getLView()),
+            token: pipeDef.type
+        });
+    }
     const previousInjectImplementation = setInjectImplementation(ɵɵdirectiveInject);
     try {
         // DI for pipes is supposed to behave like directives when placed on a component
@@ -22590,6 +22989,7 @@ function ɵɵpipe(index, pipeName) {
         // we have to restore the injector implementation in finally, just in case the creation of the
         // pipe throws an error.
         setInjectImplementation(previousInjectImplementation);
+        ngDevMode && setInjectorProfilerContext(previousInjectorProfilerContext);
     }
 }
 /**
@@ -23305,7 +23705,7 @@ const R3ViewContainerRef = class ViewContainerRef extends VE_ViewContainerRef {
         let index;
         // This function supports 2 signatures and we need to handle options correctly for both:
         //   1. When first argument is a Component type. This signature also requires extra
-        //      options to be provided as as object (more ergonomic option).
+        //      options to be provided as object (more ergonomic option).
         //   2. First argument is a Component factory. In this case extra options are represented as
         //      positional arguments. This signature is less ergonomic and will be deprecated.
         if (isComponentFactory) {
@@ -24169,6 +24569,7 @@ const angularCoreEnv = (() => ({
     'ɵɵclassProp': ɵɵclassProp,
     'ɵɵadvance': ɵɵadvance,
     'ɵɵtemplate': ɵɵtemplate,
+    'ɵɵdefer': ɵɵdefer,
     'ɵɵtext': ɵɵtext,
     'ɵɵtextInterpolate': ɵɵtextInterpolate,
     'ɵɵtextInterpolate1': ɵɵtextInterpolate1,
@@ -25867,6 +26268,206 @@ const COMPILER_OPTIONS = new InjectionToken('compilerOptions');
 class CompilerFactory {
 }
 
+/**
+ * These are the data structures that our framework injector profiler will fill with data in order
+ * to support DI debugging APIs.
+ *
+ * resolverToTokenToDependencies: Maps an injector to a Map of tokens to an Array of
+ * dependencies. Injector -> Token -> Dependencies This is used to support the
+ * getDependenciesFromInjectable API, which takes in an injector and a token and returns it's
+ * dependencies.
+ *
+ * resolverToProviders: Maps a DI resolver (an Injector or an LView) to the providers configured
+ * within it This is used to support the getInjectorProviders API, which takes in an injector and
+ * returns the providers that it was configured with.
+ *
+ * standaloneInjectorToComponent: Maps the injector of a standalone component to the standalone
+ * component that it is associated with. Used in the getInjectorProviders API, specificially in the
+ * discovery of import paths for each provider. This is necessary because the imports array of a
+ * standalone component is processed and configured in its standalone injector, but exists within
+ * the component's definition. Because getInjectorProviders takes in an injector, if that injector
+ * is the injector of a standalone component, we need to be able to discover the place where the
+ * imports array is located (the component) in order to flatten the imports array within it to
+ * discover all of it's providers.
+ *
+ *
+ * All of these data structures are instantiated with WeakMaps. This will ensure that the presence
+ * of any object in the keys of these maps does not prevent the garbage collector from collecting
+ * those objects. Because of this property of WeakMaps, these data structures will never be the
+ * source of a memory leak.
+ *
+ * An example of this advantage: When components are destroyed, we don't need to do
+ * any additional work to remove that component from our mappings.
+ *
+ */
+class DIDebugData {
+    constructor() {
+        this.resolverToTokenToDependencies = new WeakMap();
+        this.resolverToProviders = new WeakMap();
+        this.standaloneInjectorToComponent = new WeakMap();
+    }
+    reset() {
+        this.resolverToTokenToDependencies =
+            new WeakMap();
+        this.resolverToProviders = new WeakMap();
+        this.standaloneInjectorToComponent = new WeakMap();
+    }
+}
+let frameworkDIDebugData = new DIDebugData();
+function getFrameworkDIDebugData() {
+    return frameworkDIDebugData;
+}
+/**
+ * Initalize default handling of injector events. This handling parses events
+ * as they are emitted and constructs the data structures necessary to support
+ * some of debug APIs.
+ *
+ * See handleInjectEvent, handleCreateEvent and handleProviderConfiguredEvent
+ * for descriptions of each handler
+ *
+ * Supported APIs:
+ *               - getDependenciesFromInjectable
+ *               - getInjectorProviders
+ */
+function setupFrameworkInjectorProfiler() {
+    frameworkDIDebugData.reset();
+    setInjectorProfiler((injectorProfilerEvent) => handleInjectorProfilerEvent(injectorProfilerEvent));
+}
+function handleInjectorProfilerEvent(injectorProfilerEvent) {
+    const { context, type } = injectorProfilerEvent;
+    if (type === 0 /* InjectorProfilerEventType.Inject */) {
+        handleInjectEvent(context, injectorProfilerEvent.service);
+    }
+    else if (type === 1 /* InjectorProfilerEventType.InstanceCreatedByInjector */) {
+        handleInstanceCreatedByInjectorEvent(context, injectorProfilerEvent.instance);
+    }
+    else if (type === 2 /* InjectorProfilerEventType.ProviderConfigured */) {
+        handleProviderConfiguredEvent(context, injectorProfilerEvent.providerRecord);
+    }
+}
+/**
+ *
+ * Stores the injected service in frameworkDIDebugData.resolverToTokenToDependencies
+ * based on it's injector and token.
+ *
+ * @param context InjectorProfilerContext the injection context that this event occurred in.
+ * @param data InjectedService the service associated with this inject event.
+ *
+ */
+function handleInjectEvent(context, data) {
+    const diResolver = getDIResolver(context.injector);
+    if (diResolver === null) {
+        throwError('An Inject event must be run within an injection context.');
+    }
+    const diResolverToInstantiatedToken = frameworkDIDebugData.resolverToTokenToDependencies;
+    if (!diResolverToInstantiatedToken.has(diResolver)) {
+        diResolverToInstantiatedToken.set(diResolver, new WeakMap());
+    }
+    // if token is a primitive type, ignore this event. We do this because we cannot keep track of
+    // non-primitive tokens in WeakMaps since they are not garbage collectable.
+    if (!canBeHeldWeakly(context.token)) {
+        return;
+    }
+    const instantiatedTokenToDependencies = diResolverToInstantiatedToken.get(diResolver);
+    if (!instantiatedTokenToDependencies.has(context.token)) {
+        instantiatedTokenToDependencies.set(context.token, []);
+    }
+    const { token, value, flags } = data;
+    instantiatedTokenToDependencies.get(context.token).push({ token, value, flags });
+}
+/**
+ *
+ * If the created instance is an instance of a standalone component, maps the injector to that
+ * standalone component in frameworkDIDebugData.standaloneInjectorToComponent
+ *
+ * @param context InjectorProfilerContext the injection context that this event occurred in.
+ * @param data InjectorCreatedInstance an object containing the instance that was just created
+ *
+ */
+function handleInstanceCreatedByInjectorEvent(context, data) {
+    const { value } = data;
+    if (getDIResolver(context.injector) === null) {
+        throwError('An InjectorCreatedInstance event must be run within an injection context.');
+    }
+    // if our value is an instance of a standalone component, map the injector of that standalone
+    // component to the component class. Otherwise, this event is a noop.
+    let standaloneComponent = undefined;
+    if (typeof value === 'object') {
+        standaloneComponent = value?.constructor;
+    }
+    if (standaloneComponent === undefined || !isStandaloneComponent(standaloneComponent)) {
+        return;
+    }
+    const environmentInjector = context.injector.get(EnvironmentInjector, null, { optional: true });
+    // Standalone components should have an environment injector. If one cannot be
+    // found we may be in a test case for low level functionality that did not explictly
+    // setup this injector. In those cases, we simply ignore this event.
+    if (environmentInjector === null) {
+        return;
+    }
+    const { standaloneInjectorToComponent } = frameworkDIDebugData;
+    // If our injector has already been mapped, as is the case
+    // when a standalone component imports another standalone component,
+    // we consider the original component (the component doing the importing)
+    // as the component connected to our injector.
+    if (standaloneInjectorToComponent.has(environmentInjector)) {
+        return;
+    }
+    // If our injector hasn't been mapped, then we map it to the standalone component
+    standaloneInjectorToComponent.set(environmentInjector, standaloneComponent);
+}
+function isStandaloneComponent(value) {
+    const def = getComponentDef(value);
+    return !!def?.standalone;
+}
+/**
+ *
+ * Stores the emitted ProviderRecords from the InjectorProfilerEventType.ProviderConfigured
+ * event in frameworkDIDebugData.resolverToProviders
+ *
+ * @param context InjectorProfilerContext the injection context that this event occurred in.
+ * @param data ProviderRecord an object containing the instance that was just created
+ *
+ */
+function handleProviderConfiguredEvent(context, data) {
+    const { resolverToProviders } = frameworkDIDebugData;
+    const diResolver = getDIResolver(context?.injector);
+    if (diResolver === null) {
+        throwError('A ProviderConfigured event must be run within an injection context.');
+    }
+    if (!resolverToProviders.has(diResolver)) {
+        resolverToProviders.set(diResolver, []);
+    }
+    resolverToProviders.get(diResolver).push(data);
+}
+function getDIResolver(injector) {
+    let diResolver = null;
+    if (injector === undefined) {
+        return diResolver;
+    }
+    // We use the LView as the diResolver for NodeInjectors because they
+    // do not persist anywhere in the framework. They are simply wrappers around an LView and a TNode
+    // that do persist. Because of this, we rely on the LView of the NodeInjector in order to use
+    // as a concrete key to represent this injector. If we get the same LView back later, we know
+    // we're looking at the same injector.
+    if (injector instanceof NodeInjector) {
+        diResolver = getNodeInjectorLView(injector);
+    }
+    // Other injectors can be used a keys for a map because their instances
+    // persist
+    else {
+        diResolver = injector;
+    }
+    return diResolver;
+}
+// inspired by
+// https://tc39.es/ecma262/multipage/executable-code-and-execution-contexts.html#sec-canbeheldweakly
+function canBeHeldWeakly(value) {
+    // we check for value !== null here because typeof null === 'object
+    return value !== null &&
+        (typeof value === 'object' || typeof value === 'function' || typeof value === 'symbol');
+}
+
 /**
  * Marks a component for check (in case of OnPush components) and synchronously
  * performs change detection on the application this component belongs to.
@@ -25882,6 +26483,447 @@ function applyChanges(component) {
     getRootComponents(component).forEach(rootComponent => detectChanges(rootComponent));
 }
 
+/**
+ * Discovers the dependencies of an injectable instance. Provides DI information about each
+ * dependency that the injectable was instantiated with, including where they were provided from.
+ *
+ * @param injector An injector instance
+ * @param token a DI token that was constructed by the given injector instance
+ * @returns an object that contains the created instance of token as well as all of the dependencies
+ * that it was instantiated with OR undefined if the token was not created within the given
+ * injector.
+ */
+function getDependenciesFromInjectable(injector, token) {
+    // First we check to see if the token given maps to an actual instance in the injector given.
+    // We use `self: true` because we only want to look at the injector we were given.
+    // We use `optional: true` because it's possible that the token we were given was never
+    // constructed by the injector we were given.
+    const instance = injector.get(token, null, { self: true, optional: true });
+    if (instance === null) {
+        throw new Error(`Unable to determine instance of ${token} in given injector`);
+    }
+    let diResolver = injector;
+    if (injector instanceof NodeInjector) {
+        diResolver = getNodeInjectorLView(injector);
+    }
+    const { resolverToTokenToDependencies } = getFrameworkDIDebugData();
+    let dependencies = resolverToTokenToDependencies.get(diResolver)?.get?.(token) ?? [];
+    const resolutionPath = getInjectorResolutionPath(injector);
+    dependencies = dependencies.map(dep => {
+        const flags = dep.flags;
+        dep.flags = {
+            optional: (8 /* InternalInjectFlags.Optional */ & flags) === 8 /* InternalInjectFlags.Optional */,
+            host: (1 /* InternalInjectFlags.Host */ & flags) === 1 /* InternalInjectFlags.Host */,
+            self: (2 /* InternalInjectFlags.Self */ & flags) === 2 /* InternalInjectFlags.Self */,
+            skipSelf: (4 /* InternalInjectFlags.SkipSelf */ & flags) === 4 /* InternalInjectFlags.SkipSelf */,
+        };
+        for (let i = 0; i < resolutionPath.length; i++) {
+            const injectorToCheck = resolutionPath[i];
+            // if skipSelf is true we skip the first injector
+            if (i === 0 && dep.flags.skipSelf) {
+                continue;
+            }
+            // host only applies to NodeInjectors
+            if (dep.flags.host && injectorToCheck instanceof EnvironmentInjector) {
+                break;
+            }
+            const instance = injectorToCheck.get(dep.token, null, { self: true, optional: true });
+            if (instance !== null) {
+                // if host flag is true we double check that we can get the service from the first element
+                // in the resolution path by using the host flag. This is done to make sure that we've found
+                // the correct providing injector, and not a node injector that is connected to our path via
+                // a router outlet.
+                if (dep.flags.host) {
+                    const firstInjector = resolutionPath[0];
+                    const lookupFromFirstInjector = firstInjector.get(dep.token, null, { ...dep.flags, optional: true });
+                    if (lookupFromFirstInjector !== null) {
+                        dep.providedIn = injectorToCheck;
+                    }
+                    break;
+                }
+                dep.providedIn = injectorToCheck;
+                break;
+            }
+            // if self is true we stop after the first injector
+            if (i === 0 && dep.flags.self) {
+                break;
+            }
+        }
+        return dep;
+    });
+    return { instance, dependencies };
+}
+/**
+ * Gets the class associated with an injector that contains a provider `imports` array in it's
+ * definition
+ *
+ * For Module Injectors this returns the NgModule constructor.
+ *
+ * For Standalone injectors this returns the standalone component constructor.
+ *
+ * @param injector Injector an injector instance
+ * @returns the constructor where the `imports` array that configures this injector is located
+ */
+function getProviderImportsContainer(injector) {
+    const { standaloneInjectorToComponent } = getFrameworkDIDebugData();
+    // standalone components configure providers through a component def, so we have to
+    // use the standalone component associated with this injector if Injector represents
+    // a standalone components EnvironmentInjector
+    if (standaloneInjectorToComponent.has(injector)) {
+        return standaloneInjectorToComponent.get(injector);
+    }
+    // Module injectors configure providers through their NgModule def, so we use the
+    // injector to lookup its NgModuleRef and through that grab its instance
+    const defTypeRef = injector.get(NgModuleRef$1, null, { self: true, optional: true });
+    // If we can't find an associated imports container, return null.
+    // This could be the case if this function is called with an R3Injector that does not represent
+    // a standalone component or NgModule.
+    if (defTypeRef === null) {
+        return null;
+    }
+    return defTypeRef.instance.constructor;
+}
+/**
+ * Gets the providers configured on a NodeInjector
+ *
+ * @param injector A NodeInjector instance
+ * @returns ProviderRecord[] an array of objects representing the providers configured on this
+ *     injector
+ */
+function getNodeInjectorProviders(injector) {
+    const diResolver = getNodeInjectorLView(injector);
+    const { resolverToProviders } = getFrameworkDIDebugData();
+    return resolverToProviders.get(diResolver) ?? [];
+}
+/**
+ * Gets a mapping of providers configured on an injector to their import paths
+ *
+ * ModuleA -> imports ModuleB
+ * ModuleB -> imports ModuleC
+ * ModuleB -> provides MyServiceA
+ * ModuleC -> provides MyServiceB
+ *
+ * getProviderImportPaths(ModuleA)
+ * > Map(2) {
+ *   MyServiceA => [ModuleA, ModuleB]
+ *   MyServiceB => [ModuleA, ModuleB, ModuleC]
+ *  }
+ *
+ * @param providerImportsContainer constructor of class that contains an `imports` array in it's
+ *     definition
+ * @returns A Map object that maps providers to an array of constructors representing it's import
+ *     path
+ *
+ */
+function getProviderImportPaths(providerImportsContainer) {
+    const providerToPath = new Map();
+    const visitedContainers = new Set();
+    const visitor = walkProviderTreeToDiscoverImportPaths(providerToPath, visitedContainers);
+    walkProviderTree(providerImportsContainer, visitor, [], new Set());
+    return providerToPath;
+}
+/**
+ *
+ * Higher order function that returns a visitor for WalkProviderTree
+ *
+ * Takes in a Map and Set to keep track of the providers and containers
+ * visited, so that we can discover the import paths of these providers
+ * during the traversal.
+ *
+ * This visitor takes advantage of the fact that walkProviderTree performs a
+ * postorder traversal of the provider tree for the passed in container. Because postorder
+ * traversal recursively processes subtrees from leaf nodes until the traversal reaches the root,
+ * we write a visitor that constructs provider import paths in reverse.
+ *
+ *
+ * We use the visitedContainers set defined outside this visitor
+ * because we want to run some logic only once for
+ * each container in the tree. That logic can be described as:
+ *
+ *
+ * 1. for each discovered_provider and discovered_path in the incomplete provider paths we've
+ * already discovered
+ * 2. get the first container in discovered_path
+ * 3. if that first container is in the imports array of the container we're visiting
+ *    Then the container we're visiting is also in the import path of discovered_provider, so we
+ *    unshift discovered_path with the container we're currently visiting
+ *
+ *
+ * Example Run:
+ * ```
+ *                 ┌──────────┐
+ *                 │containerA│
+ *      ┌─imports-─┤          ├──imports─┐
+ *      │          │  provA   │          │
+ *      │          │  provB   │          │
+ *      │          └──────────┘          │
+ *      │                                │
+ *     ┌▼─────────┐             ┌────────▼─┐
+ *     │containerB│             │containerC│
+ *     │          │             │          │
+ *     │  provD   │             │  provF   │
+ *     │  provE   │             │  provG   │
+ *     └──────────┘             └──────────┘
+ * ```
+ *
+ * Each step of the traversal,
+ *
+ * ```
+ * visitor(provD, containerB)
+ * providerToPath === Map { provD => [containerB] }
+ * visitedContainers === Set { containerB }
+ *
+ * visitor(provE, containerB)
+ * providerToPath === Map { provD => [containerB], provE => [containerB] }
+ * visitedContainers === Set { containerB }
+ *
+ * visitor(provF, containerC)
+ * providerToPath === Map { provD => [containerB], provE => [containerB], provF => [containerC] }
+ * visitedContainers === Set { containerB, containerC }
+ *
+ * visitor(provG, containerC)
+ * providerToPath === Map {
+ *   provD => [containerB], provE => [containerB], provF => [containerC], provG => [containerC]
+ * }
+ * visitedContainers === Set { containerB, containerC }
+ *
+ * visitor(provA, containerA)
+ * providerToPath === Map {
+ *   provD => [containerA, containerB],
+ *   provE => [containerA, containerB],
+ *   provF => [containerA, containerC],
+ *   provG => [containerA, containerC],
+ *   provA => [containerA]
+ * }
+ * visitedContainers === Set { containerB, containerC, containerA }
+ *
+ * visitor(provB, containerA)
+ * providerToPath === Map {
+ *   provD => [containerA, containerB],
+ *   provE => [containerA, containerB],
+ *   provF => [containerA, containerC],
+ *   provG => [containerA, containerC],
+ *   provA => [containerA]
+ *   provB => [containerA]
+ * }
+ * visitedContainers === Set { containerB, containerC, containerA }
+ * ```
+ *
+ * @param providerToPath Map map of providers to paths that this function fills
+ * @param visitedContainers Set a set to keep track of the containers we've already visited
+ * @return function(provider SingleProvider, container: Type<unknown> | InjectorType<unknown>) =>
+ *     void
+ */
+function walkProviderTreeToDiscoverImportPaths(providerToPath, visitedContainers) {
+    return (provider, container) => {
+        // If the provider is not already in the providerToPath map,
+        // add an entry with the provider as the key and an array containing the current container as
+        // the value
+        if (!providerToPath.has(provider)) {
+            providerToPath.set(provider, [container]);
+        }
+        // This block will run exactly once for each container in the import tree.
+        // This is where we run the logic to check the imports array of the current
+        // container to see if it's the next container in the path for our currently
+        // discovered providers.
+        if (!visitedContainers.has(container)) {
+            // Iterate through the providers we've already seen
+            for (const prov of providerToPath.keys()) {
+                const existingImportPath = providerToPath.get(prov);
+                let containerDef = getInjectorDef(container);
+                if (!containerDef) {
+                    const ngModule = container.ngModule;
+                    containerDef = getInjectorDef(ngModule);
+                }
+                if (!containerDef) {
+                    return;
+                }
+                const lastContainerAddedToPath = existingImportPath[0];
+                let isNextStepInPath = false;
+                deepForEach(containerDef.imports, (moduleImport) => {
+                    if (isNextStepInPath) {
+                        return;
+                    }
+                    isNextStepInPath = moduleImport.ngModule === lastContainerAddedToPath ||
+                        moduleImport === lastContainerAddedToPath;
+                    if (isNextStepInPath) {
+                        providerToPath.get(prov)?.unshift(container);
+                    }
+                });
+            }
+        }
+        visitedContainers.add(container);
+    };
+}
+/**
+ * Gets the providers configured on an EnvironmentInjector
+ *
+ * @param injector EnvironmentInjector
+ * @returns an array of objects representing the providers of the given injector
+ */
+function getEnvironmentInjectorProviders(injector) {
+    const providerImportsContainer = getProviderImportsContainer(injector);
+    if (providerImportsContainer === null) {
+        throwError('Could not determine where injector providers were configured.');
+    }
+    const providerToPath = getProviderImportPaths(providerImportsContainer);
+    const providerRecords = getFrameworkDIDebugData().resolverToProviders.get(injector) ?? [];
+    return providerRecords.map(providerRecord => {
+        let importPath = providerToPath.get(providerRecord.provider) ?? [providerImportsContainer];
+        const def = getComponentDef(providerImportsContainer);
+        const isStandaloneComponent = !!def?.standalone;
+        // We prepend the component constructor in the standalone case
+        // because walkProviderTree does not visit this constructor during it's traversal
+        if (isStandaloneComponent) {
+            importPath = [providerImportsContainer, ...providerToPath.get(providerRecord.provider) ?? []];
+        }
+        return { ...providerRecord, importPath };
+    });
+}
+/**
+ * Gets the providers configured on an injector.
+ *
+ * @param injector the injector to lookup the providers of
+ * @returns ProviderRecord[] an array of objects representing the providers of the given injector
+ */
+function getInjectorProviders(injector) {
+    if (injector instanceof NodeInjector) {
+        return getNodeInjectorProviders(injector);
+    }
+    else if (injector instanceof EnvironmentInjector) {
+        return getEnvironmentInjectorProviders(injector);
+    }
+    throwError('getInjectorProviders only supports NodeInjector and EnvironmentInjector');
+}
+function getInjectorResolutionPath(injector) {
+    const resolutionPath = [injector];
+    getInjectorResolutionPathHelper(injector, resolutionPath);
+    return resolutionPath;
+}
+function getInjectorResolutionPathHelper(injector, resolutionPath) {
+    const parent = getInjectorParent(injector);
+    // if getInjectorParent can't find a parent, then we've either reached the end
+    // of the path, or we need to move from the Element Injector tree to the
+    // module injector tree using the first injector in our path as the connection point.
+    if (parent === null) {
+        if (injector instanceof NodeInjector) {
+            const firstInjector = resolutionPath[0];
+            if (firstInjector instanceof NodeInjector) {
+                const moduleInjector = getModuleInjectorOfNodeInjector(firstInjector);
+                if (moduleInjector === null) {
+                    throwError('NodeInjector must have some connection to the module injector tree');
+                }
+                resolutionPath.push(moduleInjector);
+                getInjectorResolutionPathHelper(moduleInjector, resolutionPath);
+            }
+            return resolutionPath;
+        }
+    }
+    else {
+        resolutionPath.push(parent);
+        getInjectorResolutionPathHelper(parent, resolutionPath);
+    }
+    return resolutionPath;
+}
+/**
+ * Gets the parent of an injector.
+ *
+ * This function is not able to make the jump from the Element Injector Tree to the Module
+ * injector tree. This is because the "parent" (the next step in the reoslution path)
+ * of a root NodeInjector is dependent on which NodeInjector ancestor initiated
+ * the DI lookup. See getInjectorResolutionPath for a function that can make this jump.
+ *
+ * In the below diagram:
+ * ```ts
+ * getInjectorParent(NodeInjectorB)
+ *  > NodeInjectorA
+ * getInjectorParent(NodeInjectorA) // or getInjectorParent(getInjectorParent(NodeInjectorB))
+ *  > null // cannot jump to ModuleInjector tree
+ * ```
+ *
+ * ```
+ *                ┌───────┐                ┌───────────────────┐
+ *    ┌───────────┤ModuleA├───Injector────►│EnvironmentInjector│
+ *    │           └───┬───┘                └───────────────────┘
+ *    │               │
+ *    │           bootstraps
+ *    │               │
+ *    │               │
+ *    │          ┌────▼─────┐                 ┌─────────────┐
+ * declares      │ComponentA├────Injector────►│NodeInjectorA│
+ *    │          └────┬─────┘                 └─────▲───────┘
+ *    │               │                             │
+ *    │            renders                        parent
+ *    │               │                             │
+ *    │          ┌────▼─────┐                 ┌─────┴───────┐
+ *    └─────────►│ComponentB├────Injector────►│NodeInjectorB│
+ *               └──────────┘                 └─────────────┘
+ *```
+ *
+ * @param injector an Injector to get the parent of
+ * @returns Injector the parent of the given injector
+ */
+function getInjectorParent(injector) {
+    if (injector instanceof R3Injector) {
+        return injector.parent;
+    }
+    let tNode;
+    let lView;
+    if (injector instanceof NodeInjector) {
+        tNode = getNodeInjectorTNode(injector);
+        lView = getNodeInjectorLView(injector);
+    }
+    else if (injector instanceof NullInjector) {
+        return null;
+    }
+    else {
+        throwError('getInjectorParent only support injectors of type R3Injector, NodeInjector, NullInjector');
+    }
+    const parentLocation = getParentInjectorLocation(tNode, lView);
+    if (hasParentInjector(parentLocation)) {
+        const parentInjectorIndex = getParentInjectorIndex(parentLocation);
+        const parentLView = getParentInjectorView(parentLocation, lView);
+        const parentTView = parentLView[TVIEW];
+        const parentTNode = parentTView.data[parentInjectorIndex + 8 /* NodeInjectorOffset.TNODE */];
+        return new NodeInjector(parentTNode, parentLView);
+    }
+    else {
+        const chainedInjector = lView[INJECTOR$1];
+        // Case where chainedInjector.injector is an OutletInjector and chainedInjector.injector.parent
+        // is a NodeInjector.
+        // todo(aleksanderbodurri): ideally nothing in packages/core should deal
+        // directly with router concerns. Refactor this so that we can make the jump from
+        // NodeInjector -> OutletInjector -> NodeInjector
+        // without explictly relying on types contracts from packages/router
+        const injectorParent = chainedInjector.injector?.parent;
+        if (injectorParent instanceof NodeInjector) {
+            return injectorParent;
+        }
+    }
+    return null;
+}
+/**
+ * Gets the module injector of a NodeInjector.
+ *
+ * @param injector NodeInjector to get module injector of
+ * @returns Injector representing module injector of the given NodeInjector
+ */
+function getModuleInjectorOfNodeInjector(injector) {
+    let lView;
+    if (injector instanceof NodeInjector) {
+        lView = getNodeInjectorLView(injector);
+    }
+    else {
+        throwError('getModuleInjectorOfNodeInjector must be called with a NodeInjector');
+    }
+    const chainedInjector = lView[INJECTOR$1];
+    const moduleInjector = chainedInjector.parentInjector;
+    if (!moduleInjector) {
+        throwError('NodeInjector must have some connection to the module injector tree');
+    }
+    return moduleInjector;
+}
+
 /**
  * This file introduces series of globally accessible debug tools
  * to allow for the Angular debugging story to function.
@@ -25907,6 +26949,10 @@ let _published = false;
 function publishDefaultGlobalUtils$1() {
     if (!_published) {
         _published = true;
+        setupFrameworkInjectorProfiler();
+        publishGlobalUtil('ɵgetDependenciesFromInjectable', getDependenciesFromInjectable);
+        publishGlobalUtil('ɵgetInjectorProviders', getInjectorProviders);
+        publishGlobalUtil('ɵgetInjectorResolutionPath', getInjectorResolutionPath);
         /**
          * 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
@@ -29993,14 +31039,6 @@ function enableHydrationRuntimeSupport() {
         enableApplyRootElementTransformImpl();
     }
 }
-/**
- * Detects whether the code is invoked in a browser.
- * Later on, this check should be replaced with a tree-shakable
- * flag (e.g. `!isServer`).
- */
-function isBrowser() {
-    return inject(PLATFORM_ID) === 'browser';
-}
 /**
  * Outputs a message with hydration stats into a console.
  */
@@ -30049,7 +31087,7 @@ function withDomHydration() {
             provide: IS_HYDRATION_DOM_REUSE_ENABLED,
             useFactory: () => {
                 let isEnabled = true;
-                if (isBrowser()) {
+                if (isPlatformBrowser()) {
                     // On the client, verify that the server response contains
                     // hydration annotations. Otherwise, keep hydration disabled.
                     const transferState = inject(TransferState, { optional: true });
@@ -30079,7 +31117,7 @@ function withDomHydration() {
                 // on the client. Moving forward, the `isBrowser` check should
                 // be replaced with a tree-shakable alternative (e.g. `isServer`
                 // flag).
-                if (isBrowser() && inject(IS_HYDRATION_DOM_REUSE_ENABLED)) {
+                if (isPlatformBrowser() && inject(IS_HYDRATION_DOM_REUSE_ENABLED)) {
                     enableHydrationRuntimeSupport();
                 }
             },
@@ -30092,13 +31130,13 @@ function withDomHydration() {
                 // environment and when hydration is configured properly.
                 // On a server, an application is rendered from scratch,
                 // so the host content needs to be empty.
-                return isBrowser() && inject(IS_HYDRATION_DOM_REUSE_ENABLED);
+                return isPlatformBrowser() && inject(IS_HYDRATION_DOM_REUSE_ENABLED);
             }
         },
         {
             provide: APP_BOOTSTRAP_LISTENER,
             useFactory: () => {
-                if (isBrowser() && inject(IS_HYDRATION_DOM_REUSE_ENABLED)) {
+                if (isPlatformBrowser() && inject(IS_HYDRATION_DOM_REUSE_ENABLED)) {
                     const appRef = inject(ApplicationRef);
                     const injector = inject(Injector);
                     return () => {
@@ -30134,6 +31172,11 @@ function logWarningOnStableTimedout(time, console) {
 /**
  * Transforms a value (typically a string) to a boolean.
  * Intended to be used as a transform function of an input.
+ *
+ *  @usageNotes
+ *  ```typescript
+ *  @Input({ transform: booleanAttribute }) status!: boolean;
+ *  ```
  * @param value Value to be transformed.
  *
  * @publicApi
@@ -30147,6 +31190,11 @@ function booleanAttribute(value) {
  * @param value Value to be transformed.
  * @param fallbackValue Value to use if the provided value can't be parsed as a number.
  *
+ *  @usageNotes
+ *  ```typescript
+ *  @Input({ transform: numberAttribute }) id!: number;
+ *  ```
+ *
  * @publicApi
  */
 function numberAttribute(value, fallbackValue = NaN) {
@@ -30439,5 +31487,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, 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, ComponentFactory$1 as ɵComponentFactory, Console as ɵConsole, DEFAULT_LOCALE_ID as ɵDEFAULT_LOCALE_ID, 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, TESTABILITY as ɵTESTABILITY, TESTABILITY_GETTER as ɵTESTABILITY_GETTER, ViewRef$1 as ɵViewRef, XSS_SECURITY_URL as ɵXSS_SECURITY_URL, _sanitizeHtml as ɵ_sanitizeHtml, _sanitizeUrl as ɵ_sanitizeUrl, allowSanitizationBypassAndThrow as ɵallowSanitizationBypassAndThrow, annotateForHydration as ɵannotateForHydration, bypassSanitizationTrustHtml as ɵbypassSanitizationTrustHtml, bypassSanitizationTrustResourceUrl as ɵbypassSanitizationTrustResourceUrl, bypassSanitizationTrustScript as ɵbypassSanitizationTrustScript, bypassSanitizationTrustStyle as ɵbypassSanitizationTrustStyle, bypassSanitizationTrustUrl as ɵbypassSanitizationTrustUrl, clearResolutionOfComponentResourcesQueue as ɵclearResolutionOfComponentResourcesQueue, compileComponent as ɵcompileComponent, compileDirective as ɵcompileDirective, compileNgModule as ɵcompileNgModule, compileNgModuleDefs as ɵcompileNgModuleDefs, compileNgModuleFactory as ɵcompileNgModuleFactory, compilePipe as ɵcompilePipe, convertToBitFlags as ɵconvertToBitFlags, createInjector as ɵcreateInjector, defaultIterableDiffers as ɵdefaultIterableDiffers, defaultKeyValueDiffers as ɵdefaultKeyValueDiffers, detectChanges as ɵdetectChanges, devModeEqual as ɵdevModeEqual, findLocaleData as ɵfindLocaleData, flushModuleScopingQueueAsMuchAsPossible as ɵflushModuleScopingQueueAsMuchAsPossible, formatRuntimeError as ɵformatRuntimeError, getDebugNode as ɵgetDebugNode, getDirectives as ɵgetDirectives, getHostElement as ɵgetHostElement, getInjectableDef as ɵgetInjectableDef, getLContext as ɵgetLContext, getLocaleCurrencyCode as ɵgetLocaleCurrencyCode, getLocalePluralCase as ɵgetLocalePluralCase, getSanitizationBypassType as ɵgetSanitizationBypassType, ɵgetUnknownElementStrictMode, ɵgetUnknownPropertyStrictMode, _global as ɵglobal, injectChangeDetectorRef as ɵinjectChangeDetectorRef, internalCreateApplication as ɵinternalCreateApplication, isBoundToModule as ɵisBoundToModule, isEnvironmentProviders as ɵisEnvironmentProviders, isInjectable as ɵisInjectable, isNgModule as ɵisNgModule, isPromise as ɵisPromise, isSubscribable as ɵisSubscribable, 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, setAllowDuplicateNgModuleIdsForTest as ɵsetAllowDuplicateNgModuleIdsForTest, setAlternateWeakRefImpl as ɵsetAlternateWeakRefImpl, setClassMetadata as ɵsetClassMetadata, setCurrentInjector as ɵsetCurrentInjector, setDocument as ɵsetDocument, setLocaleId as ɵsetLocaleId, ɵsetUnknownElementStrictMode, ɵsetUnknownPropertyStrictMode, store as ɵstore, stringify as ɵstringify, transitiveScopesFor as ɵtransitiveScopesFor, 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, ɵɵcontentQuery, ɵɵdefineComponent, ɵɵdefineDirective, ɵɵdefineInjectable, ɵɵdefineInjector, ɵɵdefineNgModule, ɵɵdefinePipe, ɵɵdirectiveInject, ɵɵdisableBindings, ɵɵelement, ɵɵelementContainer, ɵɵelementContainerEnd, ɵɵelementContainerStart, ɵɵelementEnd, ɵɵelementStart, ɵɵenableBindings, ɵɵgetCurrentView, ɵɵgetInheritedFactory, ɵɵhostProperty, ɵɵi18n, ɵɵi18nApply, ɵɵi18nAttributes, ɵɵi18nEnd, ɵɵi18nExp, ɵɵi18nPostprocess, ɵɵi18nStart, ɵɵinject, ɵɵinjectAttribute, ɵɵinvalidFactory, ɵɵinvalidFactoryDep, ɵɵlistener, ɵɵloadQuery, ɵɵnamespaceHTML, ɵɵnamespaceMathML, ɵɵnamespaceSVG, ɵɵnextContext, ɵɵngDeclareClassMetadata, ɵɵngDeclareComponent, ɵɵngDeclareDirective, ɵɵngDeclareFactory, ɵɵngDeclareInjectable, ɵɵngDeclareInjector, ɵɵngDeclareNgModule, ɵɵngDeclarePipe, ɵɵpipe, ɵɵpipeBind1, ɵɵpipeBind2, ɵɵpipeBind3, ɵɵpipeBind4, ɵɵpipeBindV, ɵɵprojection, ɵɵprojectionDef, ɵɵproperty, ɵɵpropertyInterpolate, ɵɵpropertyInterpolate1, ɵɵpropertyInterpolate2, ɵɵpropertyInterpolate3, ɵɵpropertyInterpolate4, ɵɵpropertyInterpolate5, ɵɵpropertyInterpolate6, ɵɵpropertyInterpolate7, ɵɵpropertyInterpolate8, ɵɵpropertyInterpolateV, ɵɵpureFunction0, ɵɵpureFunction1, ɵɵpureFunction2, ɵɵpureFunction3, ɵɵpureFunction4, ɵɵpureFunction5, ɵɵpureFunction6, ɵɵpureFunction7, ɵɵpureFunction8, ɵɵpureFunctionV, ɵɵqueryRefresh, ɵɵreference, registerNgModuleType as ɵɵregisterNgModuleType, ɵɵresetView, ɵɵresolveBody, ɵɵresolveDocument, ɵɵresolveWindow, ɵɵrestoreView, ɵɵsanitizeHtml, ɵɵsanitizeResourceUrl, ɵɵsanitizeScript, ɵɵsanitizeStyle, ɵɵsanitizeUrl, ɵɵsanitizeUrlOrResourceUrl, ɵɵsetComponentScope, ɵɵsetNgModuleScope, ɵɵstyleMap, ɵɵstyleMapInterpolate1, ɵɵstyleMapInterpolate2, ɵɵstyleMapInterpolate3, ɵɵstyleMapInterpolate4, ɵɵstyleMapInterpolate5, ɵɵstyleMapInterpolate6, ɵɵstyleMapInterpolate7, ɵɵstyleMapInterpolate8, ɵɵstyleMapInterpolateV, ɵɵstyleProp, ɵɵstylePropInterpolate1, ɵɵstylePropInterpolate2, ɵɵstylePropInterpolate3, ɵɵstylePropInterpolate4, ɵɵstylePropInterpolate5, ɵɵstylePropInterpolate6, ɵɵstylePropInterpolate7, ɵɵstylePropInterpolate8, ɵɵstylePropInterpolateV, ɵɵsyntheticHostListener, ɵɵsyntheticHostProperty, ɵɵtemplate, ɵɵtemplateRefExtractor, ɵɵtext, ɵɵtextInterpolate, ɵɵtextInterpolate1, ɵɵtextInterpolate2, ɵɵtextInterpolate3, ɵɵtextInterpolate4, ɵɵtextInterpolate5, ɵɵtextInterpolate6, ɵɵtextInterpolate7, ɵɵtextInterpolate8, ɵɵtextInterpolateV, ɵɵtrustConstantHtml, ɵɵtrustConstantResourceUrl, ɵɵvalidateIframeAttribute, ɵɵviewQuery };
+export { ANIMATION_MODULE_TYPE, APP_BOOTSTRAP_LISTENER, APP_ID, APP_INITIALIZER, ApplicationInitStatus, ApplicationModule, ApplicationRef, Attribute, COMPILER_OPTIONS, CSP_NONCE, CUSTOM_ELEMENTS_SCHEMA, ChangeDetectionStrategy, ChangeDetectorRef, Compiler, CompilerFactory, Component, ComponentFactory$1 as ComponentFactory, ComponentFactoryResolver$1 as ComponentFactoryResolver, ComponentRef$1 as ComponentRef, ContentChild, ContentChildren, DEFAULT_CURRENCY_CODE, DebugElement, DebugEventListener, DebugNode, DefaultIterableDiffer, DestroyRef, Directive, ENVIRONMENT_INITIALIZER, ElementRef, EmbeddedViewRef, EnvironmentInjector, ErrorHandler, EventEmitter, Host, HostBinding, HostListener, INJECTOR, Inject, InjectFlags, Injectable, InjectionToken, Injector, Input, IterableDiffers, KeyValueDiffers, LOCALE_ID, MissingTranslationStrategy, ModuleWithComponentFactories, NO_ERRORS_SCHEMA, NgModule, NgModuleFactory$1 as NgModuleFactory, NgModuleRef$1 as NgModuleRef, NgProbeToken, NgZone, Optional, Output, PACKAGE_ROOT_URL, PLATFORM_ID, PLATFORM_INITIALIZER, Pipe, PlatformRef, Query, QueryList, 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, 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, TESTABILITY as ɵTESTABILITY, TESTABILITY_GETTER as ɵTESTABILITY_GETTER, ViewRef$1 as ɵViewRef, XSS_SECURITY_URL as ɵXSS_SECURITY_URL, _sanitizeHtml as ɵ_sanitizeHtml, _sanitizeUrl as ɵ_sanitizeUrl, allowSanitizationBypassAndThrow as ɵallowSanitizationBypassAndThrow, annotateForHydration as ɵannotateForHydration, bypassSanitizationTrustHtml as ɵbypassSanitizationTrustHtml, bypassSanitizationTrustResourceUrl as ɵbypassSanitizationTrustResourceUrl, bypassSanitizationTrustScript as ɵbypassSanitizationTrustScript, bypassSanitizationTrustStyle as ɵbypassSanitizationTrustStyle, bypassSanitizationTrustUrl as ɵbypassSanitizationTrustUrl, clearResolutionOfComponentResourcesQueue as ɵclearResolutionOfComponentResourcesQueue, compileComponent as ɵcompileComponent, compileDirective as ɵcompileDirective, compileNgModule as ɵcompileNgModule, compileNgModuleDefs as ɵcompileNgModuleDefs, compileNgModuleFactory as ɵcompileNgModuleFactory, compilePipe as ɵcompilePipe, convertToBitFlags as ɵconvertToBitFlags, createInjector as ɵcreateInjector, defaultIterableDiffers as ɵdefaultIterableDiffers, defaultKeyValueDiffers as ɵdefaultKeyValueDiffers, detectChanges as ɵdetectChanges, devModeEqual as ɵdevModeEqual, findLocaleData as ɵfindLocaleData, flushModuleScopingQueueAsMuchAsPossible as ɵflushModuleScopingQueueAsMuchAsPossible, formatRuntimeError as ɵformatRuntimeError, getDebugNode as ɵgetDebugNode, getDirectives as ɵgetDirectives, getHostElement as ɵgetHostElement, getInjectableDef as ɵgetInjectableDef, getLContext as ɵgetLContext, getLocaleCurrencyCode as ɵgetLocaleCurrencyCode, getLocalePluralCase as ɵgetLocalePluralCase, getSanitizationBypassType as ɵgetSanitizationBypassType, ɵgetUnknownElementStrictMode, ɵgetUnknownPropertyStrictMode, _global as ɵglobal, injectChangeDetectorRef as ɵinjectChangeDetectorRef, internalCreateApplication as ɵinternalCreateApplication, isBoundToModule as ɵisBoundToModule, isEnvironmentProviders as ɵisEnvironmentProviders, isInjectable as ɵisInjectable, isNgModule as ɵisNgModule, isPromise as ɵisPromise, isSubscribable as ɵisSubscribable, 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, setAllowDuplicateNgModuleIdsForTest as ɵsetAllowDuplicateNgModuleIdsForTest, setAlternateWeakRefImpl as ɵsetAlternateWeakRefImpl, setClassMetadata as ɵsetClassMetadata, 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, ɵɵcontentQuery, ɵɵdefer, ɵɵdefineComponent, ɵɵdefineDirective, ɵɵdefineInjectable, ɵɵdefineInjector, ɵɵdefineNgModule, ɵɵdefinePipe, ɵɵdirectiveInject, ɵɵdisableBindings, ɵɵelement, ɵɵelementContainer, ɵɵelementContainerEnd, ɵɵelementContainerStart, ɵɵelementEnd, ɵɵelementStart, ɵɵenableBindings, ɵɵgetCurrentView, ɵɵgetInheritedFactory, ɵɵhostProperty, ɵɵi18n, ɵɵi18nApply, ɵɵi18nAttributes, ɵɵi18nEnd, ɵɵi18nExp, ɵɵi18nPostprocess, ɵɵi18nStart, ɵɵinject, ɵɵinjectAttribute, ɵɵinvalidFactory, ɵɵinvalidFactoryDep, ɵɵlistener, ɵɵloadQuery, ɵɵnamespaceHTML, ɵɵnamespaceMathML, ɵɵnamespaceSVG, ɵɵnextContext, ɵɵngDeclareClassMetadata, ɵɵngDeclareComponent, ɵɵngDeclareDirective, ɵɵngDeclareFactory, ɵɵngDeclareInjectable, ɵɵngDeclareInjector, ɵɵngDeclareNgModule, ɵɵngDeclarePipe, ɵɵpipe, ɵɵpipeBind1, ɵɵpipeBind2, ɵɵpipeBind3, ɵɵpipeBind4, ɵɵpipeBindV, ɵɵprojection, ɵɵprojectionDef, ɵɵproperty, ɵɵpropertyInterpolate, ɵɵpropertyInterpolate1, ɵɵpropertyInterpolate2, ɵɵpropertyInterpolate3, ɵɵpropertyInterpolate4, ɵɵpropertyInterpolate5, ɵɵpropertyInterpolate6, ɵɵpropertyInterpolate7, ɵɵpropertyInterpolate8, ɵɵpropertyInterpolateV, ɵɵpureFunction0, ɵɵpureFunction1, ɵɵpureFunction2, ɵɵpureFunction3, ɵɵpureFunction4, ɵɵpureFunction5, ɵɵpureFunction6, ɵɵpureFunction7, ɵɵpureFunction8, ɵɵpureFunctionV, ɵɵqueryRefresh, ɵɵreference, registerNgModuleType as ɵɵregisterNgModuleType, ɵɵresetView, ɵɵresolveBody, ɵɵresolveDocument, ɵɵresolveWindow, ɵɵrestoreView, ɵɵsanitizeHtml, ɵɵsanitizeResourceUrl, ɵɵsanitizeScript, ɵɵsanitizeStyle, ɵɵsanitizeUrl, ɵɵsanitizeUrlOrResourceUrl, ɵɵsetComponentScope, ɵɵsetNgModuleScope, ɵɵstyleMap, ɵɵstyleMapInterpolate1, ɵɵstyleMapInterpolate2, ɵɵstyleMapInterpolate3, ɵɵstyleMapInterpolate4, ɵɵstyleMapInterpolate5, ɵɵstyleMapInterpolate6, ɵɵstyleMapInterpolate7, ɵɵstyleMapInterpolate8, ɵɵstyleMapInterpolateV, ɵɵstyleProp, ɵɵstylePropInterpolate1, ɵɵstylePropInterpolate2, ɵɵstylePropInterpolate3, ɵɵstylePropInterpolate4, ɵɵstylePropInterpolate5, ɵɵstylePropInterpolate6, ɵɵstylePropInterpolate7, ɵɵstylePropInterpolate8, ɵɵstylePropInterpolateV, ɵɵsyntheticHostListener, ɵɵsyntheticHostProperty, ɵɵtemplate, ɵɵtemplateRefExtractor, ɵɵtext, ɵɵtextInterpolate, ɵɵtextInterpolate1, ɵɵtextInterpolate2, ɵɵtextInterpolate3, ɵɵtextInterpolate4, ɵɵtextInterpolate5, ɵɵtextInterpolate6, ɵɵtextInterpolate7, ɵɵtextInterpolate8, ɵɵtextInterpolateV, ɵɵtrustConstantHtml, ɵɵtrustConstantResourceUrl, ɵɵvalidateIframeAttribute, ɵɵviewQuery };
 //# sourceMappingURL=core.mjs.map