@angular/core 19.1.5 → 19.2.0-next.0

package/fesm2022/core.mjs

@@ -1,10 +1,10 @@
 /**
- * @license Angular v19.1.5
+ * @license Angular v19.2.0-next.0
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */
 
-import { SIGNAL_NODE as SIGNAL_NODE$1, signalSetFn as signalSetFn$1, producerAccessed as producerAccessed$1, SIGNAL as SIGNAL$1, getActiveConsumer as getActiveConsumer$1, setActiveConsumer as setActiveConsumer$1, createSignal as createSignal$1, signalUpdateFn as signalUpdateFn$1, consumerDestroy as consumerDestroy$1, REACTIVE_NODE as REACTIVE_NODE$1, consumerBeforeComputation as consumerBeforeComputation$1, consumerAfterComputation as consumerAfterComputation$1, consumerPollProducersForChange as consumerPollProducersForChange$1, createComputed as createComputed$1, setThrowInvalidWriteToSignalError as setThrowInvalidWriteToSignalError$1, createLinkedSignal as createLinkedSignal$1, linkedSignalSetFn as linkedSignalSetFn$1, linkedSignalUpdateFn as linkedSignalUpdateFn$1, createWatch as createWatch$1, isInNotificationPhase as isInNotificationPhase$1 } from '@angular/core/primitives/signals';
+import { SIGNAL_NODE as SIGNAL_NODE$1, signalSetFn as signalSetFn$1, producerAccessed as producerAccessed$1, SIGNAL as SIGNAL$1, getActiveConsumer as getActiveConsumer$1, setActiveConsumer as setActiveConsumer$1, createSignal as createSignal$1, signalUpdateFn as signalUpdateFn$1, consumerDestroy as consumerDestroy$1, REACTIVE_NODE as REACTIVE_NODE$1, consumerBeforeComputation as consumerBeforeComputation$1, consumerAfterComputation as consumerAfterComputation$1, consumerPollProducersForChange as consumerPollProducersForChange$1, createComputed as createComputed$1, setThrowInvalidWriteToSignalError as setThrowInvalidWriteToSignalError$1, producerUpdateValueVersion as producerUpdateValueVersion$1, producerMarkClean as producerMarkClean$1, defaultEquals as defaultEquals$1, createWatch as createWatch$1, isInNotificationPhase as isInNotificationPhase$1 } from '@angular/core/primitives/signals';
 export { SIGNAL as ɵSIGNAL } from '@angular/core/primitives/signals';
 import { BehaviorSubject, Subject, Subscription } from 'rxjs';
 import { Attribute as Attribute$1, clearAppScopedEarlyEventContract, EventContract, EventContractContainer, getAppScopedQueuedEventInfos, EventDispatcher, registerDispatcher, isEarlyEventType, isCaptureEventType, EventPhase } from '@angular/core/primitives/event-dispatch';
@@ -2963,7 +2963,6 @@ function isComponentDef(def) {
     return !!def.template;
 }
 function isRootView(target) {
-    // Determines whether a given LView is marked as a root view.
     return (target[FLAGS] & 512 /* LViewFlags.IsRoot */) !== 0;
 }
 function isProjectionTNode(tNode) {
@@ -3067,7 +3066,7 @@ function assertProjectionSlots(lView, errMessage) {
 function assertParentView(lView, errMessage) {
     assertDefined(lView, errMessage || "Component views should always have a parent view (component's host view)");
 }
-function assertNoDuplicateDirectives$1(directives) {
+function assertNoDuplicateDirectives(directives) {
     // The array needs at least two elements in order to have duplicates.
     if (directives.length < 2) {
         return;
@@ -3244,7 +3243,7 @@ const setProfiler = (profiler) => {
  *  execution context
  * @returns
  */
-const profiler = function (event, instance, hookOrListener) {
+const profiler = function (event, instance = null, hookOrListener) {
     if (profilerCallback != null /* both `null` and `undefined` */) {
         profilerCallback(event, instance, hookOrListener);
     }
@@ -4060,7 +4059,7 @@ function ɵɵnamespaceHTML() {
 function namespaceHTMLInternal() {
     instructionState.lFrame.currentNamespace = null;
 }
-function getNamespace() {
+function getNamespace$1() {
     return instructionState.lFrame.currentNamespace;
 }
 let _wasLastNodeCreated = true;
@@ -5618,7 +5617,7 @@ function lookupTokenUsingEmbeddedInjector(tNode, lView, token, flags, notFoundVa
     while (currentTNode !== null &&
         currentLView !== null &&
         currentLView[FLAGS] & 2048 /* LViewFlags.HasEmbeddedViewInjector */ &&
-        !isRootView(currentLView)) {
+        !(currentLView[FLAGS] & 512 /* LViewFlags.IsRoot */)) {
         ngDevMode && assertTNodeForLView(currentTNode, currentLView);
         // Note that this lookup on the node injector is using the `Self` flag, because
         // we don't want the node injector to look at any parent injectors since we
@@ -7800,7 +7799,8 @@ function getDirectivesAtNodeIndex(nodeIndex, lView) {
 }
 function getComponentAtNodeIndex(nodeIndex, lView) {
     const tNode = lView[TVIEW].data[nodeIndex];
-    return isComponentHost(tNode) ? lView[tNode.directiveStart + tNode.componentOffset] : null;
+    const { directiveStart, componentOffset } = tNode;
+    return componentOffset > -1 ? lView[directiveStart + componentOffset] : null;
 }
 /**
  * Returns a map of local references (local reference name => element or directive instance) that
@@ -7829,7 +7829,7 @@ function discoverLocalRefs(lView, nodeIndex) {
 function getRootView(componentOrLView) {
     ngDevMode && assertDefined(componentOrLView, 'component');
     let lView = isLView(componentOrLView) ? componentOrLView : readPatchedLView(componentOrLView);
-    while (lView && !isRootView(lView)) {
+    while (lView && !(lView[FLAGS] & 512 /* LViewFlags.IsRoot */)) {
         lView = getLViewParent(lView);
     }
     ngDevMode && assertLView(lView);
@@ -7947,7 +7947,7 @@ function getOwningComponent(elementOrDir) {
     while (lView[TVIEW].type === 2 /* TViewType.Embedded */ && (parent = getLViewParent(lView))) {
         lView = parent;
     }
-    return isRootView(lView) ? null : lView[CONTEXT];
+    return lView[FLAGS] & 512 /* LViewFlags.IsRoot */ ? null : lView[CONTEXT];
 }
 /**
  * Retrieves all root components associated with a DOM element, directive or component instance.
@@ -8756,6 +8756,10 @@ class AfterRenderImpl {
      * might be scheduled.
      */
     execute() {
+        const hasSequencesToExecute = this.sequences.size > 0;
+        if (hasSequencesToExecute) {
+            profiler(16 /* ProfilerEvent.AfterRenderHooksStart */);
+        }
         this.executing = true;
         for (const phase of AFTER_RENDER_PHASES) {
             for (const sequence of this.sequences) {
@@ -8763,7 +8767,11 @@ class AfterRenderImpl {
                     continue;
                 }
                 try {
-                    sequence.pipelinedValue = this.ngZone.runOutsideAngular(() => this.maybeTrace(() => sequence.hooks[phase](sequence.pipelinedValue), sequence.snapshot));
+                    sequence.pipelinedValue = this.ngZone.runOutsideAngular(() => this.maybeTrace(() => {
+                        const hookFn = sequence.hooks[phase];
+                        const value = hookFn(sequence.pipelinedValue);
+                        return value;
+                    }, sequence.snapshot));
                 }
                 catch (err) {
                     sequence.erroredOrDestroyed = true;
@@ -8789,6 +8797,9 @@ class AfterRenderImpl {
             this.scheduler.notify(8 /* NotificationSource.DeferredRenderHook */);
         }
         this.deferredRegistrations.clear();
+        if (hasSequencesToExecute) {
+            profiler(17 /* ProfilerEvent.AfterRenderHooksEnd */);
+        }
     }
     register(sequence) {
         if (!this.executing) {
@@ -11637,6 +11648,14 @@ function getExpressionChangedErrorDetails(lView, bindingIndex, oldValue, newValu
     return { propName: undefined, oldValue, newValue };
 }
 
+/** Flags describing an input for a directive. */
+var InputFlags;
+(function (InputFlags) {
+    InputFlags[InputFlags["None"] = 0] = "None";
+    InputFlags[InputFlags["SignalBased"] = 1] = "SignalBased";
+    InputFlags[InputFlags["HasDecoratorInputTransform"] = 2] = "HasDecoratorInputTransform";
+})(InputFlags || (InputFlags = {}));
+
 /**
  * Returns an index of `classToSearch` in `className` taking token boundaries into account.
  *
@@ -12068,15 +12087,131 @@ function extractAttrsAndClassesFromSelector(selector) {
         }
         i++;
     }
-    if (classes.length) {
-        attrs.push(1 /* AttributeMarker.Classes */, ...classes);
-    }
-    return attrs;
+    return { attrs, classes };
 }
 
 /** A special value which designates that a value has not changed. */
 const NO_CHANGE = typeof ngDevMode === 'undefined' || ngDevMode ? { __brand__: 'NO_CHANGE' } : {};
 
+/**
+ * Advances to an element for later binding instructions.
+ *
+ * Used in conjunction with instructions like {@link property} to act on elements with specified
+ * indices, for example those created with {@link element} or {@link elementStart}.
+ *
+ * ```ts
+ * (rf: RenderFlags, ctx: any) => {
+ *   if (rf & 1) {
+ *     text(0, 'Hello');
+ *     text(1, 'Goodbye')
+ *     element(2, 'div');
+ *   }
+ *   if (rf & 2) {
+ *     advance(2); // Advance twice to the <div>.
+ *     property('title', 'test');
+ *   }
+ *  }
+ * ```
+ * @param delta Number of elements to advance forwards by.
+ *
+ * @codeGenApi
+ */
+function ɵɵadvance(delta = 1) {
+    ngDevMode && assertGreaterThan(delta, 0, 'Can only advance forward');
+    selectIndexInternal(getTView(), getLView(), getSelectedIndex() + delta, !!ngDevMode && isInCheckNoChangesMode());
+}
+function selectIndexInternal(tView, lView, index, checkNoChangesMode) {
+    ngDevMode && assertIndexInDeclRange(lView[TVIEW], index);
+    // Flush the initial hooks for elements in the view that have been added up to this point.
+    // PERF WARNING: do NOT extract this to a separate function without running benchmarks
+    if (!checkNoChangesMode) {
+        const hooksInitPhaseCompleted = (lView[FLAGS] & 3 /* LViewFlags.InitPhaseStateMask */) === 3 /* InitPhaseState.InitPhaseCompleted */;
+        if (hooksInitPhaseCompleted) {
+            const preOrderCheckHooks = tView.preOrderCheckHooks;
+            if (preOrderCheckHooks !== null) {
+                executeCheckHooks(lView, preOrderCheckHooks, index);
+            }
+        }
+        else {
+            const preOrderHooks = tView.preOrderHooks;
+            if (preOrderHooks !== null) {
+                executeInitAndCheckHooks(lView, preOrderHooks, 0 /* InitPhaseState.OnInitHooksToBeRun */, index);
+            }
+        }
+    }
+    // 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);
+}
+
+function ɵɵdirectiveInject(token, flags = InjectFlags.Default) {
+    const lView = getLView();
+    // Fall back to inject() if view hasn't been created. This situation can happen in tests
+    // if inject utilities are used before bootstrapping.
+    if (lView === null) {
+        // Verify that we will not get into infinite loop.
+        ngDevMode && assertInjectImplementationNotEqual(ɵɵdirectiveInject);
+        return ɵɵinject(token, flags);
+    }
+    const tNode = getCurrentTNode();
+    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
+ * particular class.
+ *
+ * This instruction allows the actual error message to be optimized away when ngDevMode is turned
+ * off, saving bytes of generated code while still providing a good experience in dev mode.
+ *
+ * The name of the class is not mentioned here, but will be in the generated factory function name
+ * and thus in the stack trace.
+ *
+ * @codeGenApi
+ */
+function ɵɵinvalidFactory() {
+    const msg = ngDevMode
+        ? `This constructor was not compatible with Dependency Injection.`
+        : 'invalid';
+    throw new Error(msg);
+}
+
+function writeToDirectiveInput(def, instance, publicName, privateName, flags, value) {
+    const prevConsumer = setActiveConsumer$1(null);
+    try {
+        // If we know we are dealing with a signal input, we cache its reference
+        // in a tree-shakable way. The input signal node can then be used for
+        // value transform execution or actual value updates without introducing
+        // additional megamorphic accesses for accessing the instance field.
+        let inputSignalNode = null;
+        if ((flags & InputFlags.SignalBased) !== 0) {
+            const field = instance[privateName];
+            inputSignalNode = field[SIGNAL$1];
+        }
+        // If there is a signal node and a transform, run it before potentially
+        // delegating to features like `NgOnChanges`.
+        if (inputSignalNode !== null && inputSignalNode.transformFn !== undefined) {
+            value = inputSignalNode.transformFn(value);
+        }
+        // If there is a decorator input transform, run it.
+        if ((flags & InputFlags.HasDecoratorInputTransform) !== 0) {
+            value = def.inputTransforms[privateName].call(instance, value);
+        }
+        if (def.setInput !== null) {
+            def.setInput(instance, inputSignalNode, value, publicName, privateName);
+        }
+        else {
+            applyValueToInputField(instance, inputSignalNode, privateName, value);
+        }
+    }
+    finally {
+        setActiveConsumer$1(prevConsumer);
+    }
+}
+
 function createTextNode(renderer, value) {
     ngDevMode && ngDevMode.rendererCreateTextNode++;
     ngDevMode && ngDevMode.rendererSetText++;
@@ -12193,100 +12328,6 @@ function setupStaticAttributes(renderer, element, tNode) {
     }
 }
 
-/**
- * Advances to an element for later binding instructions.
- *
- * Used in conjunction with instructions like {@link property} to act on elements with specified
- * indices, for example those created with {@link element} or {@link elementStart}.
- *
- * ```ts
- * (rf: RenderFlags, ctx: any) => {
- *   if (rf & 1) {
- *     text(0, 'Hello');
- *     text(1, 'Goodbye')
- *     element(2, 'div');
- *   }
- *   if (rf & 2) {
- *     advance(2); // Advance twice to the <div>.
- *     property('title', 'test');
- *   }
- *  }
- * ```
- * @param delta Number of elements to advance forwards by.
- *
- * @codeGenApi
- */
-function ɵɵadvance(delta = 1) {
-    ngDevMode && assertGreaterThan(delta, 0, 'Can only advance forward');
-    selectIndexInternal(getTView(), getLView(), getSelectedIndex() + delta, !!ngDevMode && isInCheckNoChangesMode());
-}
-function selectIndexInternal(tView, lView, index, checkNoChangesMode) {
-    ngDevMode && assertIndexInDeclRange(lView[TVIEW], index);
-    // Flush the initial hooks for elements in the view that have been added up to this point.
-    // PERF WARNING: do NOT extract this to a separate function without running benchmarks
-    if (!checkNoChangesMode) {
-        const hooksInitPhaseCompleted = (lView[FLAGS] & 3 /* LViewFlags.InitPhaseStateMask */) === 3 /* InitPhaseState.InitPhaseCompleted */;
-        if (hooksInitPhaseCompleted) {
-            const preOrderCheckHooks = tView.preOrderCheckHooks;
-            if (preOrderCheckHooks !== null) {
-                executeCheckHooks(lView, preOrderCheckHooks, index);
-            }
-        }
-        else {
-            const preOrderHooks = tView.preOrderHooks;
-            if (preOrderHooks !== null) {
-                executeInitAndCheckHooks(lView, preOrderHooks, 0 /* InitPhaseState.OnInitHooksToBeRun */, index);
-            }
-        }
-    }
-    // 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);
-}
-
-/** Flags describing an input for a directive. */
-var InputFlags;
-(function (InputFlags) {
-    InputFlags[InputFlags["None"] = 0] = "None";
-    InputFlags[InputFlags["SignalBased"] = 1] = "SignalBased";
-    InputFlags[InputFlags["HasDecoratorInputTransform"] = 2] = "HasDecoratorInputTransform";
-})(InputFlags || (InputFlags = {}));
-
-function writeToDirectiveInput(def, instance, publicName, privateName, flags, value) {
-    const prevConsumer = setActiveConsumer$1(null);
-    try {
-        // If we know we are dealing with a signal input, we cache its reference
-        // in a tree-shakable way. The input signal node can then be used for
-        // value transform execution or actual value updates without introducing
-        // additional megamorphic accesses for accessing the instance field.
-        let inputSignalNode = null;
-        if ((flags & InputFlags.SignalBased) !== 0) {
-            const field = instance[privateName];
-            inputSignalNode = field[SIGNAL$1];
-        }
-        // If there is a signal node and a transform, run it before potentially
-        // delegating to features like `NgOnChanges`.
-        if (inputSignalNode !== null && inputSignalNode.transformFn !== undefined) {
-            value = inputSignalNode.transformFn(value);
-        }
-        // If there is a decorator input transform, run it.
-        if ((flags & InputFlags.HasDecoratorInputTransform) !== 0) {
-            value = def.inputTransforms[privateName].call(instance, value);
-        }
-        if (def.setInput !== null) {
-            def.setInput(instance, inputSignalNode, value, publicName, privateName);
-        }
-        else {
-            applyValueToInputField(instance, inputSignalNode, privateName, value);
-        }
-    }
-    finally {
-        setActiveConsumer$1(prevConsumer);
-    }
-}
-
 function createLView(parentLView, tView, context, flags, host, tHostNode, environment, renderer, injector, embeddedViewInjector, hydrationInfo) {
     const lView = tView.blueprint.slice();
     lView[HOST] = host;
@@ -12320,6 +12361,34 @@ function createLView(parentLView, tView, context, flags, host, tHostNode, enviro
         tView.type == 2 /* TViewType.Embedded */ ? parentLView[DECLARATION_COMPONENT_VIEW] : lView;
     return lView;
 }
+/**
+ * When elements are created dynamically after a view blueprint is created (e.g. through
+ * i18nApply()), we need to adjust the blueprint for future
+ * template passes.
+ *
+ * @param tView `TView` associated with `LView`
+ * @param lView The `LView` containing the blueprint to adjust
+ * @param numSlotsToAlloc The number of slots to alloc in the LView, should be >0
+ * @param initialValue Initial value to store in blueprint
+ */
+function allocExpando(tView, lView, numSlotsToAlloc, initialValue) {
+    if (numSlotsToAlloc === 0)
+        return -1;
+    if (ngDevMode) {
+        assertFirstCreatePass(tView);
+        assertSame(tView, lView[TVIEW], '`LView` must be associated with `TView`!');
+        assertEqual(tView.data.length, lView.length, 'Expecting LView to be same size as TView');
+        assertEqual(tView.data.length, tView.blueprint.length, 'Expecting Blueprint to be same size as TView');
+        assertFirstUpdatePass(tView);
+    }
+    const allocIdx = lView.length;
+    for (let i = 0; i < numSlotsToAlloc; i++) {
+        lView.push(initialValue);
+        tView.blueprint.push(initialValue);
+        tView.data.push(null);
+    }
+    return allocIdx;
+}
 function executeTemplate(tView, lView, templateFn, rf, context) {
     const prevSelectedIndex = getSelectedIndex();
     const isUpdatePhase = rf & 2 /* RenderFlags.Update */;
@@ -12347,17 +12416,10 @@ function executeTemplate(tView, lView, templateFn, rf, context) {
 /**
  * Creates directive instances.
  */
-function createDirectivesInstancesInInstruction(tView, lView, tNode) {
+function createDirectivesInstances(tView, lView, tNode) {
     if (!getBindingsEnabled())
         return;
-    attachPatchData(getNativeByTNode(tNode, lView), lView);
-    createDirectivesInstances(tView, lView, tNode);
-}
-/**
- * Creates directive instances.
- */
-function createDirectivesInstances(tView, lView, tNode) {
-    instantiateAllDirectives(tView, lView, tNode);
+    instantiateAllDirectives(tView, lView, tNode, getNativeByTNode(tNode, lView));
     if ((tNode.flags & 64 /* TNodeFlags.hasHostBindings */) === 64 /* TNodeFlags.hasHostBindings */) {
         invokeDirectivesHostBindings(tView, lView, tNode);
     }
@@ -12532,6 +12594,106 @@ function applyRootElementTransformImpl(rootElement) {
 function enableApplyRootElementTransformImpl() {
     _applyRootElementTransformImpl = applyRootElementTransformImpl;
 }
+function captureNodeBindings(mode, aliasMap, directiveIndex, bindingsResult, hostDirectiveAliasMap) {
+    for (let publicName in aliasMap) {
+        if (!aliasMap.hasOwnProperty(publicName)) {
+            continue;
+        }
+        const value = aliasMap[publicName];
+        if (value === undefined) {
+            continue;
+        }
+        bindingsResult ??= {};
+        let internalName;
+        let inputFlags = InputFlags.None;
+        // For inputs, the value might be an array capturing additional
+        // input flags.
+        if (Array.isArray(value)) {
+            internalName = value[0];
+            inputFlags = value[1];
+        }
+        else {
+            internalName = value;
+        }
+        // If there are no host directive mappings, we want to remap using the alias map from the
+        // definition itself. If there is an alias map, it has two functions:
+        // 1. It serves as an allowlist of bindings that are exposed by the host directives. Only the
+        // ones inside the host directive map will be exposed on the host.
+        // 2. The public name of the property is aliased using the host directive alias map, rather
+        // than the alias map from the definition.
+        let finalPublicName = publicName;
+        if (hostDirectiveAliasMap !== null) {
+            // If there is no mapping, it's not part of the allowlist and this input/output
+            // is not captured and should be ignored.
+            if (!hostDirectiveAliasMap.hasOwnProperty(publicName)) {
+                continue;
+            }
+            finalPublicName = hostDirectiveAliasMap[publicName];
+        }
+        if (mode === 0 /* CaptureNodeBindingMode.Inputs */) {
+            addPropertyBinding(bindingsResult, directiveIndex, finalPublicName, internalName, inputFlags);
+        }
+        else {
+            addPropertyBinding(bindingsResult, directiveIndex, finalPublicName, internalName);
+        }
+    }
+    return bindingsResult;
+}
+function addPropertyBinding(bindings, directiveIndex, publicName, internalName, inputFlags) {
+    let values;
+    if (bindings.hasOwnProperty(publicName)) {
+        (values = bindings[publicName]).push(directiveIndex, internalName);
+    }
+    else {
+        values = bindings[publicName] = [directiveIndex, internalName];
+    }
+    if (inputFlags !== undefined) {
+        values.push(inputFlags);
+    }
+}
+/**
+ * Initializes data structures required to work with directive inputs and outputs.
+ * Initialization is done for all directives matched on a given TNode.
+ */
+function initializeInputAndOutputAliases(tView, tNode, hostDirectiveDefinitionMap) {
+    ngDevMode && assertFirstCreatePass(tView);
+    const start = tNode.directiveStart;
+    const end = tNode.directiveEnd;
+    const tViewData = tView.data;
+    const tNodeAttrs = tNode.attrs;
+    const inputsFromAttrs = [];
+    let inputsStore = null;
+    let outputsStore = null;
+    for (let directiveIndex = start; directiveIndex < end; directiveIndex++) {
+        const directiveDef = tViewData[directiveIndex];
+        const aliasData = hostDirectiveDefinitionMap
+            ? hostDirectiveDefinitionMap.get(directiveDef)
+            : null;
+        const aliasedInputs = aliasData ? aliasData.inputs : null;
+        const aliasedOutputs = aliasData ? aliasData.outputs : null;
+        inputsStore = captureNodeBindings(0 /* CaptureNodeBindingMode.Inputs */, directiveDef.inputs, directiveIndex, inputsStore, aliasedInputs);
+        outputsStore = captureNodeBindings(1 /* CaptureNodeBindingMode.Outputs */, directiveDef.outputs, directiveIndex, outputsStore, aliasedOutputs);
+        // Do not use unbound attributes as inputs to structural directives, since structural
+        // directive inputs can only be set using microsyntax (e.g. `<div *dir="exp">`).
+        // TODO(FW-1930): microsyntax expressions may also contain unbound/static attributes, which
+        // should be set for inline templates.
+        const initialInputs = inputsStore !== null && tNodeAttrs !== null && !isInlineTemplate(tNode)
+            ? generateInitialInputs(inputsStore, directiveIndex, tNodeAttrs)
+            : null;
+        inputsFromAttrs.push(initialInputs);
+    }
+    if (inputsStore !== null) {
+        if (inputsStore.hasOwnProperty('class')) {
+            tNode.flags |= 8 /* TNodeFlags.hasClassInput */;
+        }
+        if (inputsStore.hasOwnProperty('style')) {
+            tNode.flags |= 16 /* TNodeFlags.hasStyleInput */;
+        }
+    }
+    tNode.initialInputs = inputsFromAttrs;
+    tNode.inputs = inputsStore;
+    tNode.outputs = outputsStore;
+}
 /**
  * Mapping between attributes names that don't correspond to their element property names.
  *
@@ -12632,21 +12794,149 @@ function setNgReflectProperties(lView, element, type, dataValue, value) {
         }
     }
 }
+/**
+ * Resolve the matched directives on a node.
+ */
+function resolveDirectives(tView, lView, tNode, localRefs) {
+    // Please make sure to have explicit type for `exportsMap`. Inferred type triggers bug in
+    // tsickle.
+    ngDevMode && assertFirstCreatePass(tView);
+    if (getBindingsEnabled()) {
+        const exportsMap = localRefs === null ? null : { '': -1 };
+        const matchResult = findDirectiveDefMatches(tView, tNode);
+        let directiveDefs;
+        let hostDirectiveDefs;
+        if (matchResult === null) {
+            directiveDefs = hostDirectiveDefs = null;
+        }
+        else {
+            [directiveDefs, hostDirectiveDefs] = matchResult;
+        }
+        if (directiveDefs !== null) {
+            initializeDirectives(tView, lView, tNode, directiveDefs, exportsMap, hostDirectiveDefs);
+        }
+        if (exportsMap)
+            cacheMatchingLocalNames(tNode, localRefs, exportsMap);
+    }
+    // Merge the template attrs last so that they have the highest priority.
+    tNode.mergedAttrs = mergeHostAttrs(tNode.mergedAttrs, tNode.attrs);
+}
+/** Initializes the data structures necessary for a list of directives to be instantiated. */
+function initializeDirectives(tView, lView, tNode, directives, exportsMap, hostDirectiveDefs) {
+    ngDevMode && assertFirstCreatePass(tView);
+    // Publishes the directive types to DI so they can be injected. Needs to
+    // happen in a separate pass before the TNode flags have been initialized.
+    for (let i = 0; i < directives.length; i++) {
+        diPublicInInjector(getOrCreateNodeInjectorForNode(tNode, lView), tView, directives[i].type);
+    }
+    initTNodeFlags(tNode, tView.data.length, directives.length);
+    // When the same token is provided by several directives on the same node, some rules apply in
+    // the viewEngine:
+    // - viewProviders have priority over providers
+    // - the last directive in NgModule.declarations has priority over the previous one
+    // So to match these rules, the order in which providers are added in the arrays is very
+    // important.
+    for (let i = 0; i < directives.length; i++) {
+        const def = directives[i];
+        if (def.providersResolver)
+            def.providersResolver(def);
+    }
+    let preOrderHooksFound = false;
+    let preOrderCheckHooksFound = false;
+    let directiveIdx = allocExpando(tView, lView, directives.length, null);
+    ngDevMode &&
+        assertSame(directiveIdx, tNode.directiveStart, 'TNode.directiveStart should point to just allocated space');
+    for (let i = 0; i < directives.length; i++) {
+        const def = directives[i];
+        // Merge the attrs in the order of matches. This assumes that the first directive is the
+        // component itself, so that the component has the least priority.
+        tNode.mergedAttrs = mergeHostAttrs(tNode.mergedAttrs, def.hostAttrs);
+        configureViewWithDirective(tView, tNode, lView, directiveIdx, def);
+        saveNameToExportMap(directiveIdx, def, exportsMap);
+        if (def.contentQueries !== null)
+            tNode.flags |= 4 /* TNodeFlags.hasContentQuery */;
+        if (def.hostBindings !== null || def.hostAttrs !== null || def.hostVars !== 0)
+            tNode.flags |= 64 /* TNodeFlags.hasHostBindings */;
+        const lifeCycleHooks = def.type.prototype;
+        // Only push a node index into the preOrderHooks array if this is the first
+        // pre-order hook found on this node.
+        if (!preOrderHooksFound &&
+            (lifeCycleHooks.ngOnChanges || lifeCycleHooks.ngOnInit || lifeCycleHooks.ngDoCheck)) {
+            // We will push the actual hook function into this array later during dir instantiation.
+            // We cannot do it now because we must ensure hooks are registered in the same
+            // order that directives are created (i.e. injection order).
+            (tView.preOrderHooks ??= []).push(tNode.index);
+            preOrderHooksFound = true;
+        }
+        if (!preOrderCheckHooksFound && (lifeCycleHooks.ngOnChanges || lifeCycleHooks.ngDoCheck)) {
+            (tView.preOrderCheckHooks ??= []).push(tNode.index);
+            preOrderCheckHooksFound = true;
+        }
+        directiveIdx++;
+    }
+    initializeInputAndOutputAliases(tView, tNode, hostDirectiveDefs);
+}
+/**
+ * Add `hostBindings` to the `TView.hostBindingOpCodes`.
+ *
+ * @param tView `TView` to which the `hostBindings` should be added.
+ * @param tNode `TNode` the element which contains the directive
+ * @param directiveIdx Directive index in view.
+ * @param directiveVarsIdx Where will the directive's vars be stored
+ * @param def `ComponentDef`/`DirectiveDef`, which contains the `hostVars`/`hostBindings` to add.
+ */
+function registerHostBindingOpCodes(tView, tNode, directiveIdx, directiveVarsIdx, def) {
+    ngDevMode && assertFirstCreatePass(tView);
+    const hostBindings = def.hostBindings;
+    if (hostBindings) {
+        let hostBindingOpCodes = tView.hostBindingOpCodes;
+        if (hostBindingOpCodes === null) {
+            hostBindingOpCodes = tView.hostBindingOpCodes = [];
+        }
+        const elementIndx = ~tNode.index;
+        if (lastSelectedElementIdx(hostBindingOpCodes) != elementIndx) {
+            // Conditionally add select element so that we are more efficient in execution.
+            // NOTE: this is strictly not necessary and it trades code size for runtime perf.
+            // (We could just always add it.)
+            hostBindingOpCodes.push(elementIndx);
+        }
+        hostBindingOpCodes.push(directiveIdx, directiveVarsIdx, hostBindings);
+    }
+}
+/**
+ * Returns the last selected element index in the `HostBindingOpCodes`
+ *
+ * For perf reasons we don't need to update the selected element index in `HostBindingOpCodes` only
+ * if it changes. This method returns the last index (or '0' if not found.)
+ *
+ * Selected element index are only the ones which are negative.
+ */
+function lastSelectedElementIdx(hostBindingOpCodes) {
+    let i = hostBindingOpCodes.length;
+    while (i > 0) {
+        const value = hostBindingOpCodes[--i];
+        if (typeof value === 'number' && value < 0) {
+            return value;
+        }
+    }
+    return 0;
+}
 /**
  * Instantiate all the directives that were previously resolved on the current node.
  */
-function instantiateAllDirectives(tView, lView, tNode) {
+function instantiateAllDirectives(tView, lView, tNode, native) {
     const start = tNode.directiveStart;
     const end = tNode.directiveEnd;
     // The component view needs to be created before creating the node injector
     // since it is used to inject some special symbols like `ChangeDetectorRef`.
     if (isComponentHost(tNode)) {
         ngDevMode && assertTNodeType(tNode, 3 /* TNodeType.AnyRNode */);
-        createComponentLView(lView, tNode, tView.data[start + tNode.componentOffset]);
+        addComponentLogic(lView, tNode, tView.data[start + tNode.componentOffset]);
     }
     if (!tView.firstCreatePass) {
         getOrCreateNodeInjectorForNode(tNode, lView);
     }
+    attachPatchData(native, lView);
     const initialInputs = tNode.initialInputs;
     for (let i = start; i < end; i++) {
         const def = tView.data[i];
@@ -12702,28 +12992,140 @@ function findDirectiveDefMatches(tView, tNode) {
     ngDevMode && assertTNodeType(tNode, 3 /* TNodeType.AnyRNode */ | 12 /* TNodeType.AnyContainer */);
     const registry = tView.directiveRegistry;
     let matches = null;
+    let hostDirectiveDefs = null;
     if (registry) {
         for (let i = 0; i < registry.length; i++) {
             const def = registry[i];
             if (isNodeMatchingSelectorList(tNode, def.selectors, /* isProjectionMode */ false)) {
-                matches ??= [];
+                matches || (matches = []);
                 if (isComponentDef(def)) {
                     if (ngDevMode) {
                         assertTNodeType(tNode, 2 /* TNodeType.Element */, `"${tNode.value}" tags cannot be used as component hosts. ` +
                             `Please use a different tag to activate the ${stringify(def.type)} component.`);
-                        if (matches.length && isComponentDef(matches[0])) {
+                        if (isComponentHost(tNode)) {
                             throwMultipleComponentError(tNode, matches.find(isComponentDef).type, def.type);
                         }
                     }
-                    matches.unshift(def);
+                    // Components are inserted at the front of the matches array so that their lifecycle
+                    // hooks run before any directive lifecycle hooks. This appears to be for ViewEngine
+                    // compatibility. This logic doesn't make sense with host directives, because it
+                    // would allow the host directives to undo any overrides the host may have made.
+                    // To handle this case, the host directives of components are inserted at the beginning
+                    // of the array, followed by the component. As such, the insertion order is as follows:
+                    // 1. Host directives belonging to the selector-matched component.
+                    // 2. Selector-matched component.
+                    // 3. Host directives belonging to selector-matched directives.
+                    // 4. Selector-matched directives.
+                    if (def.findHostDirectiveDefs !== null) {
+                        const hostDirectiveMatches = [];
+                        hostDirectiveDefs = hostDirectiveDefs || new Map();
+                        def.findHostDirectiveDefs(def, hostDirectiveMatches, hostDirectiveDefs);
+                        // Add all host directives declared on this component, followed by the component itself.
+                        // Host directives should execute first so the host has a chance to override changes
+                        // to the DOM made by them.
+                        matches.unshift(...hostDirectiveMatches, def);
+                        // Component is offset starting from the beginning of the host directives array.
+                        const componentOffset = hostDirectiveMatches.length;
+                        markAsComponentHost(tView, tNode, componentOffset);
+                    }
+                    else {
+                        // No host directives on this component, just add the
+                        // component def to the beginning of the matches.
+                        matches.unshift(def);
+                        markAsComponentHost(tView, tNode, 0);
+                    }
                 }
                 else {
+                    // Append any host directives to the matches first.
+                    hostDirectiveDefs = hostDirectiveDefs || new Map();
+                    def.findHostDirectiveDefs?.(def, matches, hostDirectiveDefs);
                     matches.push(def);
                 }
             }
         }
     }
-    return matches;
+    ngDevMode && matches !== null && assertNoDuplicateDirectives(matches);
+    return matches === null ? null : [matches, hostDirectiveDefs];
+}
+/**
+ * Marks a given TNode as a component's host. This consists of:
+ * - setting the component offset on the TNode.
+ * - storing index of component's host element so it will be queued for view refresh during CD.
+ */
+function markAsComponentHost(tView, hostTNode, componentOffset) {
+    ngDevMode && assertFirstCreatePass(tView);
+    ngDevMode && assertGreaterThan(componentOffset, -1, 'componentOffset must be great than -1');
+    hostTNode.componentOffset = componentOffset;
+    (tView.components ??= []).push(hostTNode.index);
+}
+/** Caches local names and their matching directive indices for query and template lookups. */
+function cacheMatchingLocalNames(tNode, localRefs, exportsMap) {
+    if (localRefs) {
+        const localNames = (tNode.localNames = []);
+        // Local names must be stored in tNode in the same order that localRefs are defined
+        // in the template to ensure the data is loaded in the same slots as their refs
+        // in the template (for template queries).
+        for (let i = 0; i < localRefs.length; i += 2) {
+            const index = exportsMap[localRefs[i + 1]];
+            if (index == null)
+                throw new RuntimeError(-301 /* RuntimeErrorCode.EXPORT_NOT_FOUND */, ngDevMode && `Export of name '${localRefs[i + 1]}' not found!`);
+            localNames.push(localRefs[i], index);
+        }
+    }
+}
+/**
+ * Builds up an export map as directives are created, so local refs can be quickly mapped
+ * to their directive instances.
+ */
+function saveNameToExportMap(directiveIdx, def, exportsMap) {
+    if (exportsMap) {
+        if (def.exportAs) {
+            for (let i = 0; i < def.exportAs.length; i++) {
+                exportsMap[def.exportAs[i]] = directiveIdx;
+            }
+        }
+        if (isComponentDef(def))
+            exportsMap[''] = directiveIdx;
+    }
+}
+/**
+ * Initializes the flags on the current node, setting all indices to the initial index,
+ * the directive count to 0, and adding the isComponent flag.
+ * @param index the initial index
+ */
+function initTNodeFlags(tNode, index, numberOfDirectives) {
+    ngDevMode &&
+        assertNotEqual(numberOfDirectives, tNode.directiveEnd - tNode.directiveStart, 'Reached the max number of directives');
+    tNode.flags |= 1 /* TNodeFlags.isDirectiveHost */;
+    // When the first directive is created on a node, save the index
+    tNode.directiveStart = index;
+    tNode.directiveEnd = index + numberOfDirectives;
+    tNode.providerIndexes = index;
+}
+/**
+ * Setup directive for instantiation.
+ *
+ * We need to create a `NodeInjectorFactory` which is then inserted in both the `Blueprint` as well
+ * as `LView`. `TView` gets the `DirectiveDef`.
+ *
+ * @param tView `TView`
+ * @param tNode `TNode`
+ * @param lView `LView`
+ * @param directiveIndex Index where the directive will be stored in the Expando.
+ * @param def `DirectiveDef`
+ */
+function configureViewWithDirective(tView, tNode, lView, directiveIndex, def) {
+    ngDevMode &&
+        assertGreaterThanOrEqual(directiveIndex, HEADER_OFFSET, 'Must be in Expando section');
+    tView.data[directiveIndex] = def;
+    const directiveFactory = def.factory || (def.factory = getFactoryDef(def.type, true));
+    // Even though `directiveFactory` will already be using `ɵɵdirectiveInject` in its generated code,
+    // we also want to support `inject()` directly from the directive constructor context so we set
+    // `ɵɵdirectiveInject` as the inject implementation here too.
+    const nodeInjectorFactory = new NodeInjectorFactory(directiveFactory, isComponentDef(def), ɵɵdirectiveInject);
+    tView.blueprint[directiveIndex] = nodeInjectorFactory;
+    lView[directiveIndex] = nodeInjectorFactory;
+    registerHostBindingOpCodes(tView, tNode, directiveIndex, allocExpando(tView, lView, def.hostVars, NO_CHANGE), def);
 }
 /**
  * Gets the initial set of LView flags based on the component definition that the LView represents.
@@ -12739,7 +13141,7 @@ function getInitialLViewFlagsFromDef(def) {
     }
     return flags;
 }
-function createComponentLView(lView, hostTNode, def) {
+function addComponentLogic(lView, hostTNode, def) {
     const native = getNativeByTNode(hostTNode, lView);
     const tView = getOrCreateComponentTView(def);
     // Only component views should be added to the view tree directly. Embedded views are
@@ -12748,7 +13150,7 @@ function createComponentLView(lView, hostTNode, def) {
     const componentView = addToEndOfViewTree(lView, createLView(lView, tView, null, getInitialLViewFlagsFromDef(def), native, hostTNode, null, rendererFactory.createRenderer(native, def), null, null, null));
     // Component view will always be created before any injected LContainers,
     // so this is a regular element, wrap it with the component view
-    return (lView[hostTNode.index] = componentView);
+    lView[hostTNode.index] = componentView;
 }
 function elementAttributeInternal(tNode, lView, name, value, sanitizer, namespace) {
     if (ngDevMode) {
@@ -12796,6 +13198,58 @@ function setInputsFromAttrs(lView, directiveIndex, instance, def, tNode, initial
         }
     }
 }
+/**
+ * Generates initialInputData for a node and stores it in the template's static storage
+ * so subsequent template invocations don't have to recalculate it.
+ *
+ * initialInputData is an array containing values that need to be set as input properties
+ * for directives on this node, but only once on creation. We need this array to support
+ * the case where you set an @Input property of a directive using attribute-like syntax.
+ * e.g. if you have a `name` @Input, you can set it once like this:
+ *
+ * <my-component name="Bess"></my-component>
+ *
+ * @param inputs Input alias map that was generated from the directive def inputs.
+ * @param directiveIndex Index of the directive that is currently being processed.
+ * @param attrs Static attrs on this node.
+ */
+function generateInitialInputs(inputs, directiveIndex, attrs) {
+    let inputsToStore = null;
+    let i = 0;
+    while (i < attrs.length) {
+        const attrName = attrs[i];
+        if (attrName === 0 /* AttributeMarker.NamespaceURI */) {
+            // We do not allow inputs on namespaced attributes.
+            i += 4;
+            continue;
+        }
+        else if (attrName === 5 /* AttributeMarker.ProjectAs */) {
+            // Skip over the `ngProjectAs` value.
+            i += 2;
+            continue;
+        }
+        // If we hit any other attribute markers, we're done anyway. None of those are valid inputs.
+        if (typeof attrName === 'number')
+            break;
+        if (inputs.hasOwnProperty(attrName)) {
+            if (inputsToStore === null)
+                inputsToStore = [];
+            // Find the input's public name from the input store. Note that we can be found easier
+            // through the directive def, but we want to do it using the inputs store so that it can
+            // account for host directive aliases.
+            const inputConfig = inputs[attrName];
+            for (let j = 0; j < inputConfig.length; j += 3) {
+                if (inputConfig[j] === directiveIndex) {
+                    inputsToStore.push(attrName, inputConfig[j + 1], inputConfig[j + 2], attrs[i + 1]);
+                    // A directive can't have multiple inputs with the same name so we can break here.
+                    break;
+                }
+            }
+        }
+        i += 2;
+    }
+    return inputsToStore;
+}
 //////////////////////////
 //// ViewContainer & View
 //////////////////////////
@@ -12946,7 +13400,9 @@ function renderComponent(hostLView, componentHostIdx) {
     if (hostRNode !== null && componentView[HYDRATION] === null) {
         componentView[HYDRATION] = retrieveHydrationInfo(hostRNode, componentView[INJECTOR]);
     }
+    profiler(18 /* ProfilerEvent.ComponentStart */);
     renderView(componentTView, componentView, componentView[CONTEXT]);
+    profiler(19 /* ProfilerEvent.ComponentEnd */, componentView[CONTEXT]);
 }
 /**
  * Syncs an LView instance with its blueprint if they have gotten out of sync.
@@ -13092,15 +13548,6 @@ function ensureIcuContainerVisitorLoaded(loader) {
     }
 }
 
-/**
- * Checks whether a TNode is considered detached, i.e. not present in the
- * translated i18n template. We should not attempt hydration for such nodes
- * and instead, use a regular "creation mode".
- */
-function isDetachedByI18n(tNode) {
-    return (tNode.flags & 32 /* TNodeFlags.isDetached */) === 32 /* TNodeFlags.isDetached */;
-}
-
 /**
  * NOTE: for performance reasons, the possible actions are inlined within the function instead of
  * being passed as an argument.
@@ -13577,9 +14024,10 @@ function getClosestRElement(tView, tNode, lView) {
     }
     else {
         ngDevMode && assertTNodeType(parentTNode, 3 /* TNodeType.AnyRNode */ | 4 /* TNodeType.Container */);
-        if (isComponentHost(parentTNode)) {
+        const { componentOffset } = parentTNode;
+        if (componentOffset > -1) {
             ngDevMode && assertTNodeForLView(parentTNode, lView);
-            const { encapsulation } = tView.data[parentTNode.directiveStart + parentTNode.componentOffset];
+            const { encapsulation } = tView.data[parentTNode.directiveStart + componentOffset];
             // We've got a parent which is an element in the current view. We just need to verify if the
             // parent element is not a component. Component's content nodes are not inserted immediately
             // because they will be projected, and so doing insert at this point would be wasteful.
@@ -13770,7 +14218,7 @@ function applyNodes(renderer, action, tNode, lView, parentRElement, beforeNode,
                 tNode.flags |= 2 /* TNodeFlags.isProjected */;
             }
         }
-        if (!isDetachedByI18n(tNode)) {
+        if ((tNode.flags & 32 /* TNodeFlags.isDetached */) !== 32 /* TNodeFlags.isDetached */) {
             if (tNodeType & 8 /* TNodeType.ElementContainer */) {
                 applyNodes(renderer, action, tNode.child, lView, parentRElement, beforeNode, false);
                 applyToElementOrContainer(action, renderer, parentRElement, rawSlotValue, beforeNode);
@@ -14487,8 +14935,10 @@ function markTransplantedViewsForRefresh(lView) {
  */
 function detectChangesInComponent(hostLView, componentHostIdx, mode) {
     ngDevMode && assertEqual(isCreationMode(hostLView), false, 'Should be run in update mode');
+    profiler(18 /* ProfilerEvent.ComponentStart */);
     const componentView = getComponentLViewByIndex(componentHostIdx, hostLView);
     detectChangesInViewIfAttached(componentView, mode);
+    profiler(19 /* ProfilerEvent.ComponentEnd */, componentView[CONTEXT]);
 }
 /**
  * Visits a view as part of change detection traversal.
@@ -17330,492 +17780,6 @@ function computeStaticStyling(tNode, attrs, writeToHost) {
     writeToHost ? (tNode.classes = classes) : (tNode.classesWithoutHost = classes);
 }
 
-function ɵɵdirectiveInject(token, flags = InjectFlags.Default) {
-    const lView = getLView();
-    // Fall back to inject() if view hasn't been created. This situation can happen in tests
-    // if inject utilities are used before bootstrapping.
-    if (lView === null) {
-        // Verify that we will not get into infinite loop.
-        ngDevMode && assertInjectImplementationNotEqual(ɵɵdirectiveInject);
-        return ɵɵinject(token, flags);
-    }
-    const tNode = getCurrentTNode();
-    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
- * particular class.
- *
- * This instruction allows the actual error message to be optimized away when ngDevMode is turned
- * off, saving bytes of generated code while still providing a good experience in dev mode.
- *
- * The name of the class is not mentioned here, but will be in the generated factory function name
- * and thus in the stack trace.
- *
- * @codeGenApi
- */
-function ɵɵinvalidFactory() {
-    const msg = ngDevMode
-        ? `This constructor was not compatible with Dependency Injection.`
-        : 'invalid';
-    throw new Error(msg);
-}
-
-/**
- * When elements are created dynamically after a view blueprint is created (e.g. through
- * i18nApply()), we need to adjust the blueprint for future template passes.
- *
- * @param tView `TView` associated with `LView`
- * @param lView The `LView` containing the blueprint to adjust
- * @param numSlotsToAlloc The number of slots to alloc in the LView, should be >0
- * @param initialValue Initial value to store in blueprint
- */
-function allocExpando(tView, lView, numSlotsToAlloc, initialValue) {
-    if (numSlotsToAlloc === 0)
-        return -1;
-    if (ngDevMode) {
-        assertFirstCreatePass(tView);
-        assertSame(tView, lView[TVIEW], '`LView` must be associated with `TView`!');
-        assertEqual(tView.data.length, lView.length, 'Expecting LView to be same size as TView');
-        assertEqual(tView.data.length, tView.blueprint.length, 'Expecting Blueprint to be same size as TView');
-        assertFirstUpdatePass(tView);
-    }
-    const allocIdx = lView.length;
-    for (let i = 0; i < numSlotsToAlloc; i++) {
-        lView.push(initialValue);
-        tView.blueprint.push(initialValue);
-        tView.data.push(null);
-    }
-    return allocIdx;
-}
-
-/**
- * Resolve the matched directives on a node.
- */
-function resolveDirectives(tView, lView, tNode, localRefs, directiveMatcher) {
-    // Please make sure to have explicit type for `exportsMap`. Inferred type triggers bug in
-    // tsickle.
-    ngDevMode && assertFirstCreatePass(tView);
-    const exportsMap = localRefs === null ? null : { '': -1 };
-    const matchedDirectiveDefs = directiveMatcher(tView, tNode);
-    if (matchedDirectiveDefs !== null) {
-        const [directiveDefs, hostDirectiveDefs] = resolveHostDirectives(tView, tNode, matchedDirectiveDefs);
-        initializeDirectives(tView, lView, tNode, directiveDefs, exportsMap, hostDirectiveDefs);
-    }
-    if (exportsMap !== null && localRefs !== null) {
-        cacheMatchingLocalNames(tNode, localRefs, exportsMap);
-    }
-}
-/** Caches local names and their matching directive indices for query and template lookups. */
-function cacheMatchingLocalNames(tNode, localRefs, exportsMap) {
-    const localNames = (tNode.localNames = []);
-    // Local names must be stored in tNode in the same order that localRefs are defined
-    // in the template to ensure the data is loaded in the same slots as their refs
-    // in the template (for template queries).
-    for (let i = 0; i < localRefs.length; i += 2) {
-        const index = exportsMap[localRefs[i + 1]];
-        if (index == null)
-            throw new RuntimeError(-301 /* RuntimeErrorCode.EXPORT_NOT_FOUND */, ngDevMode && `Export of name '${localRefs[i + 1]}' not found!`);
-        localNames.push(localRefs[i], index);
-    }
-}
-function resolveHostDirectives(tView, tNode, matches) {
-    const allDirectiveDefs = [];
-    let hostDirectiveDefs = null;
-    for (const def of matches) {
-        if (def.findHostDirectiveDefs !== null) {
-            // TODO(pk): probably could return matches instead of taking in an array to fill in?
-            hostDirectiveDefs ??= new Map();
-            // Components are inserted at the front of the matches array so that their lifecycle
-            // hooks run before any directive lifecycle hooks. This appears to be for ViewEngine
-            // compatibility. This logic doesn't make sense with host directives, because it
-            // would allow the host directives to undo any overrides the host may have made.
-            // To handle this case, the host directives of components are inserted at the beginning
-            // of the array, followed by the component. As such, the insertion order is as follows:
-            // 1. Host directives belonging to the selector-matched component.
-            // 2. Selector-matched component.
-            // 3. Host directives belonging to selector-matched directives.
-            // 4. Selector-matched directives.
-            def.findHostDirectiveDefs(def, allDirectiveDefs, hostDirectiveDefs);
-        }
-        if (isComponentDef(def)) {
-            allDirectiveDefs.push(def);
-            markAsComponentHost(tView, tNode, allDirectiveDefs.length - 1);
-        }
-    }
-    if (isComponentHost(tNode)) {
-        allDirectiveDefs.push(...matches.slice(1));
-    }
-    else {
-        allDirectiveDefs.push(...matches);
-    }
-    if (ngDevMode) {
-        assertNoDuplicateDirectives(allDirectiveDefs);
-    }
-    return [allDirectiveDefs, hostDirectiveDefs];
-}
-/**
- * Marks a given TNode as a component's host. This consists of:
- * - setting the component offset on the TNode.
- * - storing index of component's host element so it will be queued for view refresh during CD.
- */
-function markAsComponentHost(tView, hostTNode, componentOffset) {
-    ngDevMode && assertFirstCreatePass(tView);
-    ngDevMode && assertGreaterThan(componentOffset, -1, 'componentOffset must be great than -1');
-    hostTNode.componentOffset = componentOffset;
-    (tView.components ??= []).push(hostTNode.index);
-}
-/** Initializes the data structures necessary for a list of directives to be instantiated. */
-function initializeDirectives(tView, lView, tNode, directives, exportsMap, hostDirectiveDefs) {
-    ngDevMode && assertFirstCreatePass(tView);
-    // Publishes the directive types to DI so they can be injected. Needs to
-    // happen in a separate pass before the TNode flags have been initialized.
-    for (let i = 0; i < directives.length; i++) {
-        diPublicInInjector(getOrCreateNodeInjectorForNode(tNode, lView), tView, directives[i].type);
-    }
-    initTNodeFlags(tNode, tView.data.length, directives.length);
-    // When the same token is provided by several directives on the same node, some rules apply in
-    // the viewEngine:
-    // - viewProviders have priority over providers
-    // - the last directive in NgModule.declarations has priority over the previous one
-    // So to match these rules, the order in which providers are added in the arrays is very
-    // important.
-    for (let i = 0; i < directives.length; i++) {
-        const def = directives[i];
-        if (def.providersResolver)
-            def.providersResolver(def);
-    }
-    let preOrderHooksFound = false;
-    let preOrderCheckHooksFound = false;
-    let directiveIdx = allocExpando(tView, lView, directives.length, null);
-    ngDevMode &&
-        assertSame(directiveIdx, tNode.directiveStart, 'TNode.directiveStart should point to just allocated space');
-    for (let i = 0; i < directives.length; i++) {
-        const def = directives[i];
-        // Merge the attrs in the order of matches. This assumes that the first directive is the
-        // component itself, so that the component has the least priority.
-        tNode.mergedAttrs = mergeHostAttrs(tNode.mergedAttrs, def.hostAttrs);
-        configureViewWithDirective(tView, tNode, lView, directiveIdx, def);
-        saveNameToExportMap(directiveIdx, def, exportsMap);
-        if (def.contentQueries !== null)
-            tNode.flags |= 4 /* TNodeFlags.hasContentQuery */;
-        if (def.hostBindings !== null || def.hostAttrs !== null || def.hostVars !== 0)
-            tNode.flags |= 64 /* TNodeFlags.hasHostBindings */;
-        const lifeCycleHooks = def.type.prototype;
-        // Only push a node index into the preOrderHooks array if this is the first
-        // pre-order hook found on this node.
-        if (!preOrderHooksFound &&
-            (lifeCycleHooks.ngOnChanges || lifeCycleHooks.ngOnInit || lifeCycleHooks.ngDoCheck)) {
-            // We will push the actual hook function into this array later during dir instantiation.
-            // We cannot do it now because we must ensure hooks are registered in the same
-            // order that directives are created (i.e. injection order).
-            (tView.preOrderHooks ??= []).push(tNode.index);
-            preOrderHooksFound = true;
-        }
-        if (!preOrderCheckHooksFound && (lifeCycleHooks.ngOnChanges || lifeCycleHooks.ngDoCheck)) {
-            (tView.preOrderCheckHooks ??= []).push(tNode.index);
-            preOrderCheckHooksFound = true;
-        }
-        directiveIdx++;
-    }
-    initializeInputAndOutputAliases(tView, tNode, hostDirectiveDefs);
-}
-/**
- * Initializes data structures required to work with directive inputs and outputs.
- * Initialization is done for all directives matched on a given TNode.
- */
-function initializeInputAndOutputAliases(tView, tNode, hostDirectiveDefinitionMap) {
-    ngDevMode && assertFirstCreatePass(tView);
-    const start = tNode.directiveStart;
-    const end = tNode.directiveEnd;
-    const tViewData = tView.data;
-    const tNodeAttrs = tNode.attrs;
-    const inputsFromAttrs = [];
-    let inputsStore = null;
-    let outputsStore = null;
-    for (let directiveIndex = start; directiveIndex < end; directiveIndex++) {
-        const directiveDef = tViewData[directiveIndex];
-        const aliasData = hostDirectiveDefinitionMap
-            ? hostDirectiveDefinitionMap.get(directiveDef)
-            : null;
-        const aliasedInputs = aliasData ? aliasData.inputs : null;
-        const aliasedOutputs = aliasData ? aliasData.outputs : null;
-        inputsStore = captureNodeBindings(0 /* CaptureNodeBindingMode.Inputs */, directiveDef.inputs, directiveIndex, inputsStore, aliasedInputs);
-        outputsStore = captureNodeBindings(1 /* CaptureNodeBindingMode.Outputs */, directiveDef.outputs, directiveIndex, outputsStore, aliasedOutputs);
-        // Do not use unbound attributes as inputs to structural directives, since structural
-        // directive inputs can only be set using microsyntax (e.g. `<div *dir="exp">`).
-        const initialInputs = inputsStore !== null && tNodeAttrs !== null && !isInlineTemplate(tNode)
-            ? generateInitialInputs(inputsStore, directiveIndex, tNodeAttrs)
-            : null;
-        inputsFromAttrs.push(initialInputs);
-    }
-    if (inputsStore !== null) {
-        if (inputsStore.hasOwnProperty('class')) {
-            tNode.flags |= 8 /* TNodeFlags.hasClassInput */;
-        }
-        if (inputsStore.hasOwnProperty('style')) {
-            tNode.flags |= 16 /* TNodeFlags.hasStyleInput */;
-        }
-    }
-    tNode.initialInputs = inputsFromAttrs;
-    tNode.inputs = inputsStore;
-    tNode.outputs = outputsStore;
-}
-function captureNodeBindings(mode, aliasMap, directiveIndex, bindingsResult, hostDirectiveAliasMap) {
-    for (let publicName in aliasMap) {
-        if (!aliasMap.hasOwnProperty(publicName)) {
-            continue;
-        }
-        const value = aliasMap[publicName];
-        if (value === undefined) {
-            continue;
-        }
-        bindingsResult ??= {};
-        let internalName;
-        let inputFlags = InputFlags.None;
-        // For inputs, the value might be an array capturing additional
-        // input flags.
-        if (Array.isArray(value)) {
-            internalName = value[0];
-            inputFlags = value[1];
-        }
-        else {
-            internalName = value;
-        }
-        // If there are no host directive mappings, we want to remap using the alias map from the
-        // definition itself. If there is an alias map, it has two functions:
-        // 1. It serves as an allowlist of bindings that are exposed by the host directives. Only the
-        // ones inside the host directive map will be exposed on the host.
-        // 2. The public name of the property is aliased using the host directive alias map, rather
-        // than the alias map from the definition.
-        let finalPublicName = publicName;
-        if (hostDirectiveAliasMap !== null) {
-            // If there is no mapping, it's not part of the allowlist and this input/output
-            // is not captured and should be ignored.
-            if (!hostDirectiveAliasMap.hasOwnProperty(publicName)) {
-                continue;
-            }
-            finalPublicName = hostDirectiveAliasMap[publicName];
-        }
-        if (mode === 0 /* CaptureNodeBindingMode.Inputs */) {
-            addPropertyBinding(bindingsResult, directiveIndex, finalPublicName, internalName, inputFlags);
-        }
-        else {
-            addPropertyBinding(bindingsResult, directiveIndex, finalPublicName, internalName);
-        }
-    }
-    return bindingsResult;
-}
-function addPropertyBinding(bindings, directiveIndex, publicName, internalName, inputFlags) {
-    let values;
-    if (bindings.hasOwnProperty(publicName)) {
-        (values = bindings[publicName]).push(directiveIndex, internalName);
-    }
-    else {
-        values = bindings[publicName] = [directiveIndex, internalName];
-    }
-    if (inputFlags !== undefined) {
-        values.push(inputFlags);
-    }
-}
-/**
- * Generates initialInputData for a node and stores it in the template's static storage
- * so subsequent template invocations don't have to recalculate it.
- *
- * initialInputData is an array containing values that need to be set as input properties
- * for directives on this node, but only once on creation. We need this array to support
- * the case where you set an @Input property of a directive using attribute-like syntax.
- * e.g. if you have a `name` @Input, you can set it once like this:
- *
- * <my-component name="Bess"></my-component>
- *
- * @param inputs Input alias map that was generated from the directive def inputs.
- * @param directiveIndex Index of the directive that is currently being processed.
- * @param attrs Static attrs on this node.
- */
-function generateInitialInputs(inputs, directiveIndex, attrs) {
-    let inputsToStore = null;
-    let i = 0;
-    while (i < attrs.length) {
-        const attrName = attrs[i];
-        if (attrName === 0 /* AttributeMarker.NamespaceURI */) {
-            // We do not allow inputs on namespaced attributes.
-            i += 4;
-            continue;
-        }
-        else if (attrName === 5 /* AttributeMarker.ProjectAs */) {
-            // Skip over the `ngProjectAs` value.
-            i += 2;
-            continue;
-        }
-        // If we hit any other attribute markers, we're done anyway. None of those are valid inputs.
-        if (typeof attrName === 'number')
-            break;
-        if (inputs.hasOwnProperty(attrName)) {
-            if (inputsToStore === null)
-                inputsToStore = [];
-            // Find the input's public name from the input store. Note that we can be found easier
-            // through the directive def, but we want to do it using the inputs store so that it can
-            // account for host directive aliases.
-            const inputConfig = inputs[attrName];
-            for (let j = 0; j < inputConfig.length; j += 3) {
-                if (inputConfig[j] === directiveIndex) {
-                    inputsToStore.push(attrName, inputConfig[j + 1], inputConfig[j + 2], attrs[i + 1]);
-                    // A directive can't have multiple inputs with the same name so we can break here.
-                    break;
-                }
-            }
-        }
-        i += 2;
-    }
-    return inputsToStore;
-}
-/**
- * Setup directive for instantiation.
- *
- * We need to create a `NodeInjectorFactory` which is then inserted in both the `Blueprint` as well
- * as `LView`. `TView` gets the `DirectiveDef`.
- *
- * @param tView `TView`
- * @param tNode `TNode`
- * @param lView `LView`
- * @param directiveIndex Index where the directive will be stored in the Expando.
- * @param def `DirectiveDef`
- */
-function configureViewWithDirective(tView, tNode, lView, directiveIndex, def) {
-    ngDevMode &&
-        assertGreaterThanOrEqual(directiveIndex, HEADER_OFFSET, 'Must be in Expando section');
-    tView.data[directiveIndex] = def;
-    const directiveFactory = def.factory || (def.factory = getFactoryDef(def.type, true));
-    // Even though `directiveFactory` will already be using `ɵɵdirectiveInject` in its generated code,
-    // we also want to support `inject()` directly from the directive constructor context so we set
-    // `ɵɵdirectiveInject` as the inject implementation here too.
-    const nodeInjectorFactory = new NodeInjectorFactory(directiveFactory, isComponentDef(def), ɵɵdirectiveInject);
-    tView.blueprint[directiveIndex] = nodeInjectorFactory;
-    lView[directiveIndex] = nodeInjectorFactory;
-    registerHostBindingOpCodes(tView, tNode, directiveIndex, allocExpando(tView, lView, def.hostVars, NO_CHANGE), def);
-}
-/**
- * Add `hostBindings` to the `TView.hostBindingOpCodes`.
- *
- * @param tView `TView` to which the `hostBindings` should be added.
- * @param tNode `TNode` the element which contains the directive
- * @param directiveIdx Directive index in view.
- * @param directiveVarsIdx Where will the directive's vars be stored
- * @param def `ComponentDef`/`DirectiveDef`, which contains the `hostVars`/`hostBindings` to add.
- */
-function registerHostBindingOpCodes(tView, tNode, directiveIdx, directiveVarsIdx, def) {
-    ngDevMode && assertFirstCreatePass(tView);
-    const hostBindings = def.hostBindings;
-    if (hostBindings) {
-        let hostBindingOpCodes = tView.hostBindingOpCodes;
-        if (hostBindingOpCodes === null) {
-            hostBindingOpCodes = tView.hostBindingOpCodes = [];
-        }
-        const elementIndx = ~tNode.index;
-        if (lastSelectedElementIdx(hostBindingOpCodes) != elementIndx) {
-            // Conditionally add select element so that we are more efficient in execution.
-            // NOTE: this is strictly not necessary and it trades code size for runtime perf.
-            // (We could just always add it.)
-            hostBindingOpCodes.push(elementIndx);
-        }
-        hostBindingOpCodes.push(directiveIdx, directiveVarsIdx, hostBindings);
-    }
-}
-/**
- * Returns the last selected element index in the `HostBindingOpCodes`
- *
- * For perf reasons we don't need to update the selected element index in `HostBindingOpCodes` only
- * if it changes. This method returns the last index (or '0' if not found.)
- *
- * Selected element index are only the ones which are negative.
- */
-function lastSelectedElementIdx(hostBindingOpCodes) {
-    let i = hostBindingOpCodes.length;
-    while (i > 0) {
-        const value = hostBindingOpCodes[--i];
-        if (typeof value === 'number' && value < 0) {
-            return value;
-        }
-    }
-    return 0;
-}
-/**
- * Builds up an export map as directives are created, so local refs can be quickly mapped
- * to their directive instances.
- */
-function saveNameToExportMap(directiveIdx, def, exportsMap) {
-    if (exportsMap) {
-        if (def.exportAs) {
-            for (let i = 0; i < def.exportAs.length; i++) {
-                exportsMap[def.exportAs[i]] = directiveIdx;
-            }
-        }
-        if (isComponentDef(def))
-            exportsMap[''] = directiveIdx;
-    }
-}
-/**
- * Initializes the flags on the current node, setting all indices to the initial index,
- * the directive count to 0, and adding the isComponent flag.
- * @param index the initial index
- */
-function initTNodeFlags(tNode, index, numberOfDirectives) {
-    ngDevMode &&
-        assertNotEqual(numberOfDirectives, tNode.directiveEnd - tNode.directiveStart, 'Reached the max number of directives');
-    tNode.flags |= 1 /* TNodeFlags.isDirectiveHost */;
-    // When the first directive is created on a node, save the index
-    tNode.directiveStart = index;
-    tNode.directiveEnd = index + numberOfDirectives;
-    tNode.providerIndexes = index;
-}
-function assertNoDuplicateDirectives(directives) {
-    // The array needs at least two elements in order to have duplicates.
-    if (directives.length < 2) {
-        return;
-    }
-    const seenDirectives = new Set();
-    for (const current of directives) {
-        if (seenDirectives.has(current)) {
-            throw new RuntimeError(309 /* RuntimeErrorCode.DUPLICATE_DIRECTIVE */, `Directive ${current.type.name} matches multiple times on the same element. ` +
-                `Directives can only match an element once.`);
-        }
-        seenDirectives.add(current);
-    }
-}
-
-function elementStartFirstCreatePass(index, tView, lView, name, directiveMatcher, bindingsEnabled, attrsIndex, localRefsIndex) {
-    ngDevMode && assertFirstCreatePass(tView);
-    ngDevMode && ngDevMode.firstCreatePass++;
-    const tViewConsts = tView.consts;
-    const attrs = getConstant(tViewConsts, attrsIndex);
-    const tNode = getOrCreateTNode(tView, index, 2 /* TNodeType.Element */, name, attrs);
-    if (bindingsEnabled) {
-        resolveDirectives(tView, lView, tNode, getConstant(tViewConsts, localRefsIndex), directiveMatcher);
-    }
-    // Merge the template attrs last so that they have the highest priority.
-    tNode.mergedAttrs = mergeHostAttrs(tNode.mergedAttrs, tNode.attrs);
-    if (tNode.attrs !== null) {
-        computeStaticStyling(tNode, tNode.attrs, false);
-    }
-    if (tNode.mergedAttrs !== null) {
-        computeStaticStyling(tNode, tNode.mergedAttrs, true);
-    }
-    if (tView.queries !== null) {
-        tView.queries.elementStart(tView, tNode);
-    }
-    return tNode;
-}
-function elementEndFirstCreatePass(tView, tNode) {
-    ngDevMode && assertFirstCreatePass(tView);
-    registerPostOrderHooks(tView, tNode);
-    if (isContentQueryHost(tNode)) {
-        tView.queries.elementEnd(tNode);
-    }
-}
-
 class ComponentFactoryResolver extends ComponentFactoryResolver$1 {
     ngModule;
     /**
@@ -17860,51 +17824,18 @@ function toRefArray(map, isInputMap) {
     }
     return array;
 }
-function verifyNotAnOrphanComponent(componentDef) {
-    // TODO(pk): create assert that verifies ngDevMode
-    if ((typeof ngJitMode === 'undefined' || ngJitMode) &&
-        componentDef.debugInfo?.forbidOrphanRendering) {
-        if (depsTracker.isOrphanComponent(componentDef.type)) {
-            throw new RuntimeError(981 /* RuntimeErrorCode.RUNTIME_DEPS_ORPHAN_COMPONENT */, `Orphan component found! Trying to render the component ${debugStringifyTypeForError(componentDef.type)} without first loading the NgModule that declares it. It is recommended to make this component standalone in order to avoid this error. If this is not possible now, import the component's NgModule in the appropriate NgModule, or the standalone component in which you are trying to render this component. If this is a lazy import, load the NgModule lazily as well and use its module injector.`);
-        }
-    }
-}
-function createRootViewInjector(componentDef, environmentInjector, injector) {
-    let realEnvironmentInjector = environmentInjector instanceof EnvironmentInjector
-        ? environmentInjector
-        : environmentInjector?.injector;
-    if (realEnvironmentInjector && componentDef.getStandaloneInjector !== null) {
-        realEnvironmentInjector =
-            componentDef.getStandaloneInjector(realEnvironmentInjector) || realEnvironmentInjector;
-    }
-    const rootViewInjector = realEnvironmentInjector
-        ? new ChainedInjector(injector, realEnvironmentInjector)
-        : injector;
-    return rootViewInjector;
-}
-function createRootLViewEnvironment(rootLViewInjector) {
-    const rendererFactory = rootLViewInjector.get(RendererFactory2, null);
-    if (rendererFactory === null) {
-        throw new RuntimeError(407 /* RuntimeErrorCode.RENDERER_NOT_FOUND */, ngDevMode &&
-            'Angular was not able to inject a renderer (RendererFactory2). ' +
-                'Likely this is due to a broken DI hierarchy. ' +
-                'Make sure that any injector used to create this component has a correct parent.');
-    }
-    const sanitizer = rootLViewInjector.get(Sanitizer, null);
-    const changeDetectionScheduler = rootLViewInjector.get(ChangeDetectionScheduler, null);
-    return {
-        rendererFactory,
-        sanitizer,
-        changeDetectionScheduler,
-    };
+function getNamespace(elementName) {
+    const name = elementName.toLowerCase();
+    return name === 'svg' ? SVG_NAMESPACE : name === 'math' ? MATH_ML_NAMESPACE : null;
 }
-function createHostElement(componentDef, render) {
-    // Determine a tag name used for creating host elements when this component is created
-    // dynamically. Default to 'div' if this component did not specify any tag name in its
-    // selector.
-    const tagName = (componentDef.selectors[0][0] || 'div').toLowerCase();
-    const namespace = tagName === 'svg' ? SVG_NAMESPACE : tagName === 'math' ? MATH_ML_NAMESPACE : null;
-    return createElementNode(render, tagName, namespace);
+// TODO(pk): change the extractAttrsAndClassesFromSelector so it returns TAttributes already?
+function getRootTAttributesFromSelector(selector) {
+    const { attrs, classes } = extractAttrsAndClassesFromSelector(selector);
+    const tAtts = attrs;
+    if (classes.length) {
+        tAtts.push(1 /* AttributeMarker.Classes */, ...classes);
+    }
+    return tAtts;
 }
 /**
  * ComponentFactory interface implementation.
@@ -17942,55 +17873,119 @@ class ComponentFactory extends ComponentFactory$1 {
         this.ngModule = ngModule;
         this.componentType = componentDef.type;
         this.selector = stringifyCSSSelectorList(componentDef.selectors);
-        this.ngContentSelectors = componentDef.ngContentSelectors ?? [];
+        this.ngContentSelectors = componentDef.ngContentSelectors
+            ? componentDef.ngContentSelectors
+            : [];
         this.isBoundToModule = !!ngModule;
     }
     create(injector, projectableNodes, rootSelectorOrNode, environmentInjector) {
+        profiler(22 /* ProfilerEvent.DynamicComponentStart */);
         const prevConsumer = setActiveConsumer$1(null);
         try {
-            const cmpDef = this.componentDef;
-            ngDevMode && verifyNotAnOrphanComponent(cmpDef);
-            const tAttributes = rootSelectorOrNode
-                ? ['ng-version', '19.1.5']
-                : // Extract attributes and classes from the first selector only to match VE behavior.
-                    extractAttrsAndClassesFromSelector(this.componentDef.selectors[0]);
+            // Check if the component is orphan
+            if (ngDevMode &&
+                (typeof ngJitMode === 'undefined' || ngJitMode) &&
+                this.componentDef.debugInfo?.forbidOrphanRendering) {
+                if (depsTracker.isOrphanComponent(this.componentType)) {
+                    throw new RuntimeError(981 /* RuntimeErrorCode.RUNTIME_DEPS_ORPHAN_COMPONENT */, `Orphan component found! Trying to render the component ${debugStringifyTypeForError(this.componentType)} without first loading the NgModule that declares it. It is recommended to make this component standalone in order to avoid this error. If this is not possible now, import the component's NgModule in the appropriate NgModule, or the standalone component in which you are trying to render this component. If this is a lazy import, load the NgModule lazily as well and use its module injector.`);
+                }
+            }
+            environmentInjector = environmentInjector || this.ngModule;
+            let realEnvironmentInjector = environmentInjector instanceof EnvironmentInjector
+                ? environmentInjector
+                : environmentInjector?.injector;
+            if (realEnvironmentInjector && this.componentDef.getStandaloneInjector !== null) {
+                realEnvironmentInjector =
+                    this.componentDef.getStandaloneInjector(realEnvironmentInjector) ||
+                        realEnvironmentInjector;
+            }
+            const rootViewInjector = realEnvironmentInjector
+                ? new ChainedInjector(injector, realEnvironmentInjector)
+                : injector;
+            const rendererFactory = rootViewInjector.get(RendererFactory2, null);
+            if (rendererFactory === null) {
+                throw new RuntimeError(407 /* RuntimeErrorCode.RENDERER_NOT_FOUND */, ngDevMode &&
+                    'Angular was not able to inject a renderer (RendererFactory2). ' +
+                        'Likely this is due to a broken DI hierarchy. ' +
+                        'Make sure that any injector used to create this component has a correct parent.');
+            }
+            const sanitizer = rootViewInjector.get(Sanitizer, null);
+            const changeDetectionScheduler = rootViewInjector.get(ChangeDetectionScheduler, null);
+            const environment = {
+                rendererFactory,
+                sanitizer,
+                changeDetectionScheduler,
+            };
+            const hostRenderer = rendererFactory.createRenderer(null, this.componentDef);
+            // Determine a tag name used for creating host elements when this component is created
+            // dynamically. Default to 'div' if this component did not specify any tag name in its
+            // selector.
+            const elementName = this.componentDef.selectors[0][0] || 'div';
+            const hostRNode = rootSelectorOrNode
+                ? locateHostElement(hostRenderer, rootSelectorOrNode, this.componentDef.encapsulation, rootViewInjector)
+                : createElementNode(hostRenderer, elementName, getNamespace(elementName));
+            let rootFlags = 512 /* LViewFlags.IsRoot */;
+            if (this.componentDef.signals) {
+                rootFlags |= 4096 /* LViewFlags.SignalView */;
+            }
+            else if (!this.componentDef.onPush) {
+                rootFlags |= 16 /* LViewFlags.CheckAlways */;
+            }
+            let hydrationInfo = null;
+            if (hostRNode !== null) {
+                hydrationInfo = retrieveHydrationInfo(hostRNode, rootViewInjector, true /* isRootView */);
+            }
             // Create the root view. Uses empty TView and ContentTemplate.
-            const rootTView = createTView(0 /* TViewType.Root */, null, null, 1, 0, null, null, null, null, [tAttributes], null);
-            const rootViewInjector = createRootViewInjector(cmpDef, environmentInjector || this.ngModule, injector);
-            const environment = createRootLViewEnvironment(rootViewInjector);
-            const hostRenderer = environment.rendererFactory.createRenderer(null, cmpDef);
-            const hostElement = rootSelectorOrNode
-                ? locateHostElement(hostRenderer, rootSelectorOrNode, cmpDef.encapsulation, rootViewInjector)
-                : createHostElement(cmpDef, hostRenderer);
-            const rootLView = createLView(null, rootTView, null, 512 /* LViewFlags.IsRoot */ | getInitialLViewFlagsFromDef(cmpDef), null, null, environment, hostRenderer, rootViewInjector, null, retrieveHydrationInfo(hostElement, rootViewInjector, true /* isRootView */));
-            rootLView[HEADER_OFFSET] = hostElement;
+            const rootTView = createTView(0 /* TViewType.Root */, null, null, 1, 0, null, null, null, null, null, null);
+            const rootLView = createLView(null, rootTView, null, rootFlags, null, null, environment, hostRenderer, rootViewInjector, null, hydrationInfo);
+            rootLView[HEADER_OFFSET] = hostRNode;
             // rootView is the parent when bootstrapping
             // TODO(misko): it looks like we are entering view here but we don't really need to as
             // `renderView` does that. However as the code is written it is needed because
             // `createRootComponentView` and `createRootComponent` both read global state. Fixing those
             // issues would allow us to drop this.
             enterView(rootLView);
+            let component;
             let componentView = null;
             try {
-                const hostTNode = elementStartFirstCreatePass(HEADER_OFFSET, rootTView, rootLView, '#host', () => [this.componentDef], true, 0);
-                // ---- element instruction
+                const rootComponentDef = this.componentDef;
+                let rootDirectives;
+                let hostDirectiveDefs = null;
+                if (rootComponentDef.findHostDirectiveDefs) {
+                    rootDirectives = [];
+                    hostDirectiveDefs = new Map();
+                    rootComponentDef.findHostDirectiveDefs(rootComponentDef, rootDirectives, hostDirectiveDefs);
+                    rootDirectives.push(rootComponentDef);
+                    ngDevMode && assertNoDuplicateDirectives(rootDirectives);
+                }
+                else {
+                    rootDirectives = [rootComponentDef];
+                }
+                // If host dom element is created (instead of being provided as part of the dynamic component creation), also apply attributes and classes extracted from component selector.
+                const tAttributes = rootSelectorOrNode
+                    ? ['ng-version', '19.2.0-next.0']
+                    : // Extract attributes and classes from the first selector only to match VE behavior.
+                        getRootTAttributesFromSelector(this.componentDef.selectors[0]);
+                // TODO: this logic is shared with the element instruction first create pass
+                const hostTNode = getOrCreateTNode(rootTView, HEADER_OFFSET, 2 /* TNodeType.Element */, '#host', tAttributes);
+                for (const def of rootDirectives) {
+                    hostTNode.mergedAttrs = mergeHostAttrs(hostTNode.mergedAttrs, def.hostAttrs);
+                }
+                hostTNode.mergedAttrs = mergeHostAttrs(hostTNode.mergedAttrs, tAttributes);
+                computeStaticStyling(hostTNode, hostTNode.mergedAttrs, true);
                 // TODO(crisbeto): in practice `hostRNode` should always be defined, but there are some
                 // tests where the renderer is mocked out and `undefined` is returned. We should update the
                 // tests so that this check can be removed.
-                if (hostElement) {
-                    setupStaticAttributes(hostRenderer, hostElement, hostTNode);
-                    attachPatchData(hostElement, rootLView);
+                if (hostRNode) {
+                    setupStaticAttributes(hostRenderer, hostRNode, hostTNode);
                 }
-                // TODO(pk): this logic is similar to the instruction code where a node can have directives
-                createDirectivesInstances(rootTView, rootLView, hostTNode);
-                executeContentQueries(rootTView, hostTNode, rootLView);
-                elementEndFirstCreatePass(rootTView, hostTNode);
+                componentView = createRootComponentView(hostTNode, hostRNode, rootComponentDef, rootDirectives, rootLView, environment);
                 if (projectableNodes !== undefined) {
                     projectNodes(hostTNode, this.ngContentSelectors, projectableNodes);
                 }
-                componentView = getComponentLViewByIndex(hostTNode.index, rootLView);
-                // TODO(pk): why do we need this logic?
-                rootLView[CONTEXT] = componentView[CONTEXT];
+                // TODO: should LifecycleHooksFeature and other host features be generated by the compiler
+                // and executed here? Angular 5 reference: https://stackblitz.com/edit/lifecycle-hooks-vcref
+                component = createRootComponent(componentView, rootComponentDef, rootDirectives, hostDirectiveDefs, rootLView, [LifecycleHooksFeature]);
                 renderView(rootTView, rootLView, null);
             }
             catch (e) {
@@ -18003,9 +17998,11 @@ class ComponentFactory extends ComponentFactory$1 {
                 throw e;
             }
             finally {
+                profiler(23 /* ProfilerEvent.DynamicComponentEnd */);
                 leaveView();
             }
-            return new ComponentRef(this.componentType, rootLView);
+            const hostTNode = getTNode(rootTView, HEADER_OFFSET);
+            return new ComponentRef(this.componentType, component, createElementRef(hostTNode, rootLView), rootLView, hostTNode);
         }
         finally {
             setActiveConsumer$1(prevConsumer);
@@ -18021,20 +18018,20 @@ class ComponentFactory extends ComponentFactory$1 {
  *
  */
 class ComponentRef extends ComponentRef$1 {
+    location;
     _rootLView;
+    _tNode;
     instance;
     hostView;
     changeDetectorRef;
     componentType;
-    location;
     previousInputValues = null;
-    _tNode;
-    constructor(componentType, _rootLView) {
+    constructor(componentType, instance, location, _rootLView, _tNode) {
         super();
+        this.location = location;
         this._rootLView = _rootLView;
-        this._tNode = getTNode(_rootLView[TVIEW], HEADER_OFFSET);
-        this.location = createElementRef(this._tNode, _rootLView);
-        this.instance = getComponentLViewByIndex(this._tNode.index, _rootLView)[CONTEXT];
+        this._tNode = _tNode;
+        this.instance = instance;
         this.hostView = this.changeDetectorRef = new ViewRef$1(_rootLView, undefined /* _cdRefInjectingView */, false /* notifyErrorHandler */);
         this.componentType = componentType;
     }
@@ -18074,6 +18071,70 @@ class ComponentRef extends ComponentRef$1 {
         this.hostView.onDestroy(callback);
     }
 }
+/**
+ * Creates the root component view and the root component node.
+ *
+ * @param hostRNode Render host element.
+ * @param rootComponentDef ComponentDef
+ * @param rootView The parent view where the host node is stored
+ * @param rendererFactory Factory to be used for creating child renderers.
+ * @param hostRenderer The current renderer
+ * @param sanitizer The sanitizer, if provided
+ *
+ * @returns Component view created
+ */
+function createRootComponentView(tNode, hostRNode, rootComponentDef, rootDirectives, rootView, environment) {
+    const tView = rootView[TVIEW];
+    // Hydration info is on the host element and needs to be retrieved
+    // and passed to the component LView.
+    let hydrationInfo = null;
+    if (hostRNode !== null) {
+        hydrationInfo = retrieveHydrationInfo(hostRNode, rootView[INJECTOR]);
+    }
+    const viewRenderer = environment.rendererFactory.createRenderer(hostRNode, rootComponentDef);
+    const componentView = createLView(rootView, getOrCreateComponentTView(rootComponentDef), null, getInitialLViewFlagsFromDef(rootComponentDef), rootView[tNode.index], tNode, environment, viewRenderer, null, null, hydrationInfo);
+    if (tView.firstCreatePass) {
+        markAsComponentHost(tView, tNode, rootDirectives.length - 1);
+    }
+    addToEndOfViewTree(rootView, componentView);
+    // Store component view at node index, with node as the HOST
+    return (rootView[tNode.index] = componentView);
+}
+/**
+ * Creates a root component and sets it up with features and host bindings.Shared by
+ * renderComponent() and ViewContainerRef.createComponent().
+ */
+function createRootComponent(componentView, rootComponentDef, rootDirectives, hostDirectiveDefs, rootLView, hostFeatures) {
+    const rootTNode = getCurrentTNode();
+    ngDevMode && assertDefined(rootTNode, 'tNode should have been already created');
+    const tView = rootLView[TVIEW];
+    const native = getNativeByTNode(rootTNode, rootLView);
+    initializeDirectives(tView, rootLView, rootTNode, rootDirectives, null, hostDirectiveDefs);
+    for (let i = 0; i < rootDirectives.length; i++) {
+        const directiveIndex = rootTNode.directiveStart + i;
+        const directiveInstance = getNodeInjectable(rootLView, tView, directiveIndex, rootTNode);
+        attachPatchData(directiveInstance, rootLView);
+    }
+    invokeDirectivesHostBindings(tView, rootLView, rootTNode);
+    if (native) {
+        attachPatchData(native, rootLView);
+    }
+    // We're guaranteed for the `componentOffset` to be positive here
+    // since a root component always matches a component def.
+    ngDevMode &&
+        assertGreaterThan(rootTNode.componentOffset, -1, 'componentOffset must be great than -1');
+    const component = getNodeInjectable(rootLView, tView, rootTNode.directiveStart + rootTNode.componentOffset, rootTNode);
+    componentView[CONTEXT] = rootLView[CONTEXT] = component;
+    if (hostFeatures !== null) {
+        for (const feature of hostFeatures) {
+            feature(component, rootComponentDef);
+        }
+    }
+    // We want to generate an empty QueryList for root content queries for backwards
+    // compatibility with ViewEngine.
+    executeContentQueries(tView, rootTNode, rootLView);
+    return component;
+}
 /** Projects the `projectableNodes` that were specified when creating a root component. */
 function projectNodes(tNode, ngContentSelectors, projectableNodes) {
     const projection = (tNode.projection = []);
@@ -18087,6 +18148,24 @@ function projectNodes(tNode, ngContentSelectors, projectableNodes) {
         projection.push(nodesforSlot != null && nodesforSlot.length ? Array.from(nodesforSlot) : null);
     }
 }
+/**
+ * Used to enable lifecycle hooks on the root component.
+ *
+ * Include this feature when calling `renderComponent` if the root component
+ * you are rendering has lifecycle hooks defined. Otherwise, the hooks won't
+ * be called properly.
+ *
+ * Example:
+ *
+ * ```ts
+ * renderComponent(AppComponent, {hostFeatures: [LifecycleHooksFeature]});
+ * ```
+ */
+function LifecycleHooksFeature() {
+    const tNode = getCurrentTNode();
+    ngDevMode && assertDefined(tNode, 'TNode is required');
+    registerPostOrderHooks(getLView()[TVIEW], tNode);
+}
 
 /**
  * Represents a container where one or more views can be attached to a component.
@@ -20596,17 +20675,22 @@ function bindingUpdated4(lView, bindingIndex, exp1, exp2, exp3, exp4) {
     return bindingUpdated2(lView, bindingIndex + 2, exp3, exp4) || different;
 }
 
+/**
+ * Checks whether a TNode is considered detached, i.e. not present in the
+ * translated i18n template. We should not attempt hydration for such nodes
+ * and instead, use a regular "creation mode".
+ */
+function isDetachedByI18n(tNode) {
+    return (tNode.flags & 32 /* TNodeFlags.isDetached */) === 32 /* TNodeFlags.isDetached */;
+}
+
 function templateFirstCreatePass(index, tView, lView, templateFn, decls, vars, tagName, attrs, localRefsIndex) {
     ngDevMode && assertFirstCreatePass(tView);
     ngDevMode && ngDevMode.firstCreatePass++;
     const tViewConsts = tView.consts;
     // TODO(pk): refactor getOrCreateTNode to have the "create" only version
     const tNode = getOrCreateTNode(tView, index, 4 /* TNodeType.Container */, tagName || null, attrs || null);
-    if (getBindingsEnabled()) {
-        resolveDirectives(tView, lView, tNode, getConstant(tViewConsts, localRefsIndex), findDirectiveDefMatches);
-    }
-    // Merge the template attrs last so that they have the highest priority.
-    tNode.mergedAttrs = mergeHostAttrs(tNode.mergedAttrs, tNode.attrs);
+    resolveDirectives(tView, lView, tNode, getConstant(tViewConsts, localRefsIndex));
     registerPostOrderHooks(tView, tNode);
     const embeddedTView = (tNode.tView = createTView(2 /* TViewType.Embedded */, tNode, templateFn, decls, vars, tView.directiveRegistry, tView.pipeRegistry, null, tView.schemas, tViewConsts, null /* ssrId */));
     if (tView.queries !== null) {
@@ -20649,7 +20733,7 @@ function declareTemplate(declarationLView, declarationTView, index, templateFn,
     // In client-only mode, this function is a noop.
     populateDehydratedViewsInLContainer(lContainer, tNode, declarationLView);
     if (isDirectiveHost(tNode)) {
-        createDirectivesInstancesInInstruction(declarationTView, declarationLView, tNode);
+        createDirectivesInstances(declarationTView, declarationLView, tNode);
     }
     if (localRefsIndex != null) {
         saveResolvedLocalsInData(declarationLView, tNode, localRefExtractor);
@@ -21191,6 +21275,7 @@ function findMatchingDehydratedViewForDeferBlock(lContainer, lDetails) {
  * Applies changes to the DOM to reflect a given state.
  */
 function applyDeferBlockState(newState, lDetails, lContainer, tNode, hostLView) {
+    profiler(20 /* ProfilerEvent.DeferBlockStateStart */);
     const stateTmplIndex = getTemplateIndexForState(newState, hostLView, tNode);
     if (stateTmplIndex !== null) {
         lDetails[DEFER_BLOCK_STATE] = newState;
@@ -21239,6 +21324,7 @@ function applyDeferBlockState(newState, lDetails, lContainer, tNode, hostLView)
             lDetails[ON_COMPLETE_FNS] = null;
         }
     }
+    profiler(21 /* ProfilerEvent.DeferBlockStateEnd */);
 }
 /**
  * Extends the `applyDeferBlockState` with timer-based scheduling.
@@ -23278,6 +23364,24 @@ class NgProbeToken {
 }
 /** Maximum number of times ApplicationRef will refresh all attached views in a single tick. */
 const MAXIMUM_REFRESH_RERUNS = 10;
+function _callAndReportToErrorHandler(errorHandler, ngZone, callback) {
+    try {
+        const result = callback();
+        if (isPromise(result)) {
+            return result.catch((e) => {
+                ngZone.runOutsideAngular(() => errorHandler.handleError(e));
+                // rethrow as the exception handler might not do it
+                throw e;
+            });
+        }
+        return result;
+    }
+    catch (e) {
+        ngZone.runOutsideAngular(() => errorHandler.handleError(e));
+        // rethrow as the exception handler might not do it
+        throw e;
+    }
+}
 function optionsReducer(dst, objs) {
     if (Array.isArray(objs)) {
         return objs.reduce(optionsReducer, dst);
@@ -23506,6 +23610,7 @@ class ApplicationRef {
      * {@example core/ts/platform/platform.ts region='domNode'}
      */
     bootstrap(componentOrFactory, rootSelectorOrNode) {
+        profiler(10 /* ProfilerEvent.BootstrapComponentStart */);
         (typeof ngDevMode === 'undefined' || ngDevMode) && warnIfDestroyed(this._destroyed);
         const isComponentFactory = componentOrFactory instanceof ComponentFactory$1;
         const initStatus = this._injector.get(ApplicationInitStatus);
@@ -23546,6 +23651,7 @@ class ApplicationRef {
             const _console = this._injector.get(Console);
             _console.log(`Angular is running in development mode.`);
         }
+        profiler(11 /* ProfilerEvent.BootstrapComponentEnd */, compRef);
         return compRef;
     }
     /**
@@ -23566,6 +23672,7 @@ class ApplicationRef {
     }
     /** @internal */
     _tick = () => {
+        profiler(12 /* ProfilerEvent.ChangeDetectionStart */);
         if (this.tracingSnapshot !== null) {
             const snapshot = this.tracingSnapshot;
             this.tracingSnapshot = null;
@@ -23598,6 +23705,7 @@ class ApplicationRef {
             this._runningTick = false;
             setActiveConsumer$1(prevConsumer);
             this.afterTick.next();
+            profiler(13 /* ProfilerEvent.ChangeDetectionEnd */);
         }
     };
     /**
@@ -23613,7 +23721,9 @@ class ApplicationRef {
         this.deferredDirtyFlags = 0 /* ApplicationRefDirtyFlags.None */;
         let runs = 0;
         while (this.dirtyFlags !== 0 /* ApplicationRefDirtyFlags.None */ && runs++ < MAXIMUM_REFRESH_RERUNS) {
+            profiler(14 /* ProfilerEvent.ChangeDetectionSyncStart */);
             this.synchronizeOnce();
+            profiler(15 /* ProfilerEvent.ChangeDetectionSyncEnd */);
         }
         if ((typeof ngDevMode === 'undefined' || ngDevMode) && runs >= MAXIMUM_REFRESH_RERUNS) {
             throw new RuntimeError(103 /* RuntimeErrorCode.INFINITE_CHANGE_DETECTION */, ngDevMode &&
@@ -27964,6 +28074,24 @@ function getExistingTNode(tView, index) {
     return tNode;
 }
 
+function elementStartFirstCreatePass(index, tView, lView, name, attrsIndex, localRefsIndex) {
+    ngDevMode && assertFirstCreatePass(tView);
+    ngDevMode && ngDevMode.firstCreatePass++;
+    const tViewConsts = tView.consts;
+    const attrs = getConstant(tViewConsts, attrsIndex);
+    const tNode = getOrCreateTNode(tView, index, 2 /* TNodeType.Element */, name, attrs);
+    resolveDirectives(tView, lView, tNode, getConstant(tViewConsts, localRefsIndex));
+    if (tNode.attrs !== null) {
+        computeStaticStyling(tNode, tNode.attrs, false);
+    }
+    if (tNode.mergedAttrs !== null) {
+        computeStaticStyling(tNode, tNode.mergedAttrs, true);
+    }
+    if (tView.queries !== null) {
+        tView.queries.elementStart(tView, tNode);
+    }
+    return tNode;
+}
 /**
  * Create DOM element. The instruction must later be followed by `elementEnd()` call.
  *
@@ -27988,7 +28116,7 @@ function ɵɵelementStart(index, name, attrsIndex, localRefsIndex) {
     ngDevMode && assertIndexInRange(lView, adjustedIndex);
     const renderer = lView[RENDERER];
     const tNode = tView.firstCreatePass
-        ? elementStartFirstCreatePass(adjustedIndex, tView, lView, name, findDirectiveDefMatches, getBindingsEnabled(), attrsIndex, localRefsIndex)
+        ? elementStartFirstCreatePass(adjustedIndex, tView, lView, name, attrsIndex, localRefsIndex)
         : tView.data[adjustedIndex];
     const native = _locateOrCreateElementNode(tView, lView, tNode, renderer, name, index);
     lView[adjustedIndex] = native;
@@ -28011,7 +28139,7 @@ function ɵɵelementStart(index, name, attrsIndex, localRefsIndex) {
     }
     increaseElementDepthCount();
     if (hasDirectives) {
-        createDirectivesInstancesInInstruction(tView, lView, tNode);
+        createDirectivesInstances(tView, lView, tNode);
         executeContentQueries(tView, tNode, lView);
     }
     if (localRefsIndex !== null) {
@@ -28044,7 +28172,10 @@ function ɵɵelementEnd() {
     decreaseElementDepthCount();
     const tView = getTView();
     if (tView.firstCreatePass) {
-        elementEndFirstCreatePass(tView, tNode);
+        registerPostOrderHooks(tView, currentTNode);
+        if (isContentQueryHost(currentTNode)) {
+            tView.queries.elementEnd(currentTNode);
+        }
     }
     if (tNode.classesWithoutHost != null && hasClassInput(tNode)) {
         setDirectiveInputsWhichShadowsStyling(tView, tNode, getLView(), tNode.classesWithoutHost, true);
@@ -28072,7 +28203,7 @@ function ɵɵelement(index, name, attrsIndex, localRefsIndex) {
 }
 let _locateOrCreateElementNode = (tView, lView, tNode, renderer, name, index) => {
     lastNodeWasCreated(true);
-    return createElementNode(renderer, name, getNamespace());
+    return createElementNode(renderer, name, getNamespace$1());
 };
 /**
  * Enables hydration code path (to lookup existing elements in DOM)
@@ -28087,7 +28218,7 @@ function locateOrCreateElementNodeImpl(tView, lView, tNode, renderer, name, inde
     lastNodeWasCreated(isNodeCreationMode);
     // Regular creation mode.
     if (isNodeCreationMode) {
-        return createElementNode(renderer, name, getNamespace());
+        return createElementNode(renderer, name, getNamespace$1());
     }
     // Hydration mode, looking up an existing element in DOM.
     const native = locateNextRNode(hydrationInfo, tView, lView, tNode);
@@ -28140,11 +28271,7 @@ function elementContainerStartFirstCreatePass(index, tView, lView, attrsIndex, l
         computeStaticStyling(tNode, attrs, true);
     }
     const localRefs = getConstant(tViewConsts, localRefsIndex);
-    if (getBindingsEnabled()) {
-        resolveDirectives(tView, lView, tNode, localRefs, findDirectiveDefMatches);
-    }
-    // Merge the template attrs last so that they have the highest priority.
-    tNode.mergedAttrs = mergeHostAttrs(tNode.mergedAttrs, tNode.attrs);
+    resolveDirectives(tView, lView, tNode, localRefs);
     if (tView.queries !== null) {
         tView.queries.elementStart(tView, tNode);
     }
@@ -28183,7 +28310,7 @@ function ɵɵelementContainerStart(index, attrsIndex, localRefsIndex) {
     }
     attachPatchData(comment, lView);
     if (isDirectiveHost(tNode)) {
-        createDirectivesInstancesInInstruction(tView, lView, tNode);
+        createDirectivesInstances(tView, lView, tNode);
         executeContentQueries(tView, tNode, lView);
     }
     if (localRefsIndex != null) {
@@ -30363,7 +30490,7 @@ function wrapListener(tNode, lView, context, listenerFn) {
         }
         // In order to be backwards compatible with View Engine, events on component host nodes
         // must also mark the component view itself dirty (i.e. the view that it owns).
-        const startView = isComponentHost(tNode) ? getComponentLViewByIndex(tNode.index, lView) : lView;
+        const startView = tNode.componentOffset > -1 ? getComponentLViewByIndex(tNode.index, lView) : lView;
         markViewDirty(startView, 5 /* NotificationSource.Listener */);
         let result = executeListenerWithErrorHandling(lView, context, listenerFn, e);
         // A just-invoked listener function might have coalesced listeners so we need to check for
@@ -30527,7 +30654,8 @@ function ɵɵprojection(nodeIndex, selectorIndex = 0, attrs, fallbackTemplateFn,
     if (isEmpty && fallbackIndex !== null) {
         insertFallbackContent(lView, tView, fallbackIndex);
     }
-    else if (isNodeCreationMode && !isDetachedByI18n(tProjectionNode)) {
+    else if (isNodeCreationMode &&
+        (tProjectionNode.flags & 32 /* TNodeFlags.isDetached */) !== 32 /* TNodeFlags.isDetached */) {
         // re-distribution of projectable nodes is stored on a component's view level
         applyProjection(tView, lView, tProjectionNode);
     }
@@ -33328,7 +33456,7 @@ function ɵɵreplaceMetadata(type, applyMetadata, namespaces, locals) {
         for (const root of trackedViews) {
             // Note: we have the additional check, because `IsRoot` can also indicate
             // a component created through something like `createComponent`.
-            if (isRootView(root) && root[PARENT] === null) {
+            if (root[FLAGS] & 512 /* LViewFlags.IsRoot */ && root[PARENT] === null) {
                 recreateMatchingLViews(newDef, oldDef, root);
             }
         }
@@ -33355,10 +33483,6 @@ function mergeWithExistingDefinition(currentDef, newDef) {
         // Preserve the old `setInput` function, because it has some state.
         // This is fine, because the component instance is preserved as well.
         setInput: clone.setInput,
-        // Externally this is redundant since we redeclare the definition using the original type.
-        // Internally we may receive a definition with an alternate, but identical, type so we have
-        // to ensure that the original one is preserved.
-        type: clone.type,
     });
     ngDevMode && assertEqual(replacement, currentDef, 'Expected definition to be merged in place');
     return { newDef: replacement, oldDef: clone };
@@ -34897,7 +35021,7 @@ class Version {
 /**
  * @publicApi
  */
-const VERSION = new Version('19.1.5');
+const VERSION = new Version('19.2.0-next.0');
 
 /**
  * Combination of NgModuleFactory and ComponentFactories.
@@ -36046,24 +36170,6 @@ function moduleDoBootstrap(moduleRef, allPlatformModules) {
     }
     allPlatformModules.push(moduleRef);
 }
-function _callAndReportToErrorHandler(errorHandler, ngZone, callback) {
-    try {
-        const result = callback();
-        if (isPromise(result)) {
-            return result.catch((e) => {
-                ngZone.runOutsideAngular(() => errorHandler.handleError(e));
-                // rethrow as the exception handler might not do it
-                throw e;
-            });
-        }
-        return result;
-    }
-    catch (e) {
-        ngZone.runOutsideAngular(() => errorHandler.handleError(e));
-        // rethrow as the exception handler might not do it
-        throw e;
-    }
-}
 
 /**
  * The Angular platform is the entry point for Angular on a web page.
@@ -38666,7 +38772,7 @@ function createComputed(computation) {
         producerUpdateValueVersion(node);
         // Record that someone looked at this signal.
         producerAccessed(node);
-        if (node.value === ERRORED) {
+        if (node.value === ERRORED$1) {
             throw node.error;
         }
         return node.value;
@@ -38678,26 +38784,26 @@ function createComputed(computation) {
  * A dedicated symbol used before a computed value has been calculated for the first time.
  * Explicitly typed as `any` so we can use it as signal's value.
  */
-const UNSET = /* @__PURE__ */ Symbol('UNSET');
+const UNSET$1 = /* @__PURE__ */ Symbol('UNSET');
 /**
  * A dedicated symbol used in place of a computed signal value to indicate that a given computation
  * is in progress. Used to detect cycles in computation chains.
  * Explicitly typed as `any` so we can use it as signal's value.
  */
-const COMPUTING = /* @__PURE__ */ Symbol('COMPUTING');
+const COMPUTING$1 = /* @__PURE__ */ Symbol('COMPUTING');
 /**
  * A dedicated symbol used in place of a computed signal value to indicate that a given computation
  * failed. The thrown error is cached until the computation gets dirty again.
  * Explicitly typed as `any` so we can use it as signal's value.
  */
-const ERRORED = /* @__PURE__ */ Symbol('ERRORED');
+const ERRORED$1 = /* @__PURE__ */ Symbol('ERRORED');
 // Note: Using an IIFE here to ensure that the spread assignment is not considered
 // a side-effect, ending up preserving `COMPUTED_NODE` and `REACTIVE_NODE`.
 // TODO: remove when https://github.com/evanw/esbuild/issues/3392 is resolved.
 const COMPUTED_NODE = /* @__PURE__ */ (() => {
     return {
         ...REACTIVE_NODE,
-        value: UNSET,
+        value: UNSET$1,
         dirty: true,
         error: null,
         equal: defaultEquals,
@@ -38705,15 +38811,15 @@ const COMPUTED_NODE = /* @__PURE__ */ (() => {
         producerMustRecompute(node) {
             // Force a recomputation if there's no current value, or if the current value is in the
             // process of being calculated (which should throw an error).
-            return node.value === UNSET || node.value === COMPUTING;
+            return node.value === UNSET$1 || node.value === COMPUTING$1;
         },
         producerRecomputeValue(node) {
-            if (node.value === COMPUTING) {
+            if (node.value === COMPUTING$1) {
                 // Our computation somehow led to a cyclic read of itself.
                 throw new Error('Detected cycle in computations.');
             }
             const oldValue = node.value;
-            node.value = COMPUTING;
+            node.value = COMPUTING$1;
             const prevConsumer = consumerBeforeComputation(node);
             let newValue;
             let wasEqual = false;
@@ -38723,13 +38829,13 @@ const COMPUTED_NODE = /* @__PURE__ */ (() => {
                 // to track any reactive reads inside `equal`.
                 setActiveConsumer(null);
                 wasEqual =
-                    oldValue !== UNSET &&
-                        oldValue !== ERRORED &&
-                        newValue !== ERRORED &&
+                    oldValue !== UNSET$1 &&
+                        oldValue !== ERRORED$1 &&
+                        newValue !== ERRORED$1 &&
                         node.equal(oldValue, newValue);
             }
             catch (err) {
-                newValue = ERRORED;
+                newValue = ERRORED$1;
                 node.error = err;
             }
             finally {
@@ -38823,8 +38929,8 @@ function signalValueChanged(node) {
     postSignalSetFn?.();
 }
 
-function createLinkedSignal(sourceFn, computationFn, equalityFn) {
-    const node = Object.create(LINKED_SIGNAL_NODE);
+function createLinkedSignal$1(sourceFn, computationFn, equalityFn) {
+    const node = Object.create(LINKED_SIGNAL_NODE$1);
     node.source = sourceFn;
     node.computation = computationFn;
     if (equalityFn != undefined) {
@@ -38835,7 +38941,7 @@ function createLinkedSignal(sourceFn, computationFn, equalityFn) {
         producerUpdateValueVersion(node);
         // Record that someone looked at this signal.
         producerAccessed(node);
-        if (node.value === ERRORED) {
+        if (node.value === ERRORED$1) {
             throw node.error;
         }
         return node.value;
@@ -38857,30 +38963,30 @@ function linkedSignalUpdateFn(node, updater) {
 // Note: Using an IIFE here to ensure that the spread assignment is not considered
 // a side-effect, ending up preserving `LINKED_SIGNAL_NODE` and `REACTIVE_NODE`.
 // TODO: remove when https://github.com/evanw/esbuild/issues/3392 is resolved.
-const LINKED_SIGNAL_NODE = /* @__PURE__ */ (() => {
+const LINKED_SIGNAL_NODE$1 = /* @__PURE__ */ (() => {
     return {
         ...REACTIVE_NODE,
-        value: UNSET,
+        value: UNSET$1,
         dirty: true,
         error: null,
         equal: defaultEquals,
         producerMustRecompute(node) {
             // Force a recomputation if there's no current value, or if the current value is in the
             // process of being calculated (which should throw an error).
-            return node.value === UNSET || node.value === COMPUTING;
+            return node.value === UNSET$1 || node.value === COMPUTING$1;
         },
         producerRecomputeValue(node) {
-            if (node.value === COMPUTING) {
+            if (node.value === COMPUTING$1) {
                 // Our computation somehow led to a cyclic read of itself.
                 throw new Error('Detected cycle in computations.');
             }
             const oldValue = node.value;
-            node.value = COMPUTING;
+            node.value = COMPUTING$1;
             const prevConsumer = consumerBeforeComputation(node);
             let newValue;
             try {
                 const newSourceValue = node.source();
-                const prev = oldValue === UNSET || oldValue === ERRORED
+                const prev = oldValue === UNSET$1 || oldValue === ERRORED$1
                     ? undefined
                     : {
                         source: node.sourceValue,
@@ -38890,13 +38996,13 @@ const LINKED_SIGNAL_NODE = /* @__PURE__ */ (() => {
                 node.sourceValue = newSourceValue;
             }
             catch (err) {
-                newValue = ERRORED;
+                newValue = ERRORED$1;
                 node.error = err;
             }
             finally {
                 consumerAfterComputation(node, prevConsumer);
             }
-            if (oldValue !== UNSET && newValue !== ERRORED && node.equal(oldValue, newValue)) {
+            if (oldValue !== UNSET$1 && newValue !== ERRORED$1 && node.equal(oldValue, newValue)) {
                 // No change to `valueVersion` - old and new values are
                 // semantically equivalent.
                 node.value = oldValue;
@@ -38998,6 +39104,7 @@ function setAlternateWeakRefImpl(impl) {
  * @returns A promise that returns an `ApplicationRef` instance once resolved.
  */
 function internalCreateApplication(config) {
+    profiler(8 /* ProfilerEvent.BootstrapApplicationStart */);
     try {
         const { rootComponent, appProviders, platformProviders } = config;
         if ((typeof ngDevMode === 'undefined' || ngDevMode) && rootComponent !== undefined) {
@@ -39028,6 +39135,9 @@ function internalCreateApplication(config) {
     catch (e) {
         return Promise.reject(e);
     }
+    finally {
+        profiler(9 /* ProfilerEvent.BootstrapApplicationEnd */);
+    }
 }
 
 /** Apps in which we've enabled event replay.
@@ -39992,12 +40102,12 @@ function printHydrationStats(injector) {
 /**
  * Returns a Promise that is resolved when an application becomes stable.
  */
-function whenStableWithTimeout(appRef) {
+function whenStableWithTimeout(appRef, injector) {
     const whenStablePromise = appRef.whenStable();
     if (typeof ngDevMode !== 'undefined' && ngDevMode) {
         const timeoutTime = APPLICATION_IS_STABLE_TIMEOUT;
-        const console = appRef.injector.get(Console);
-        const ngZone = appRef.injector.get(NgZone);
+        const console = injector.get(Console);
+        const ngZone = injector.get(NgZone);
         // The following call should not and does not prevent the app to become stable
         // We cannot use RxJS timer here because the app would remain unstable.
         // This also avoids an extra change detection cycle.
@@ -40095,6 +40205,7 @@ function withDomHydration() {
             useFactory: () => {
                 if (inject(IS_HYDRATION_DOM_REUSE_ENABLED)) {
                     const appRef = inject(ApplicationRef);
+                    const injector = inject(Injector);
                     return () => {
                         // Wait until an app becomes stable and cleanup all views that
                         // were not claimed during the application bootstrap process.
@@ -40103,20 +40214,11 @@ function withDomHydration() {
                         //
                         // Note: the cleanup task *MUST* be scheduled within the Angular zone in Zone apps
                         // to ensure that change detection is properly run afterward.
-                        whenStableWithTimeout(appRef).then(() => {
-                            // Note: we have to check whether the application is destroyed before
-                            // performing other operations with the `injector`.
-                            // The application may be destroyed **before** it becomes stable, so when
-                            // the `whenStableWithTimeout` resolves, the injector might already be in
-                            // a destroyed state. Thus, calling `injector.get` would throw an error
-                            // indicating that the injector has already been destroyed.
-                            if (appRef.destroyed) {
-                                return;
-                            }
+                        whenStableWithTimeout(appRef, injector).then(() => {
                             cleanupDehydratedViews(appRef);
                             if (typeof ngDevMode !== 'undefined' && ngDevMode) {
-                                countBlocksSkippedByHydration(appRef.injector);
-                                printHydrationStats(appRef.injector);
+                                countBlocksSkippedByHydration(injector);
+                                printHydrationStats(injector);
                             }
                         });
                     };
@@ -40518,28 +40620,123 @@ function computed(computation, options) {
 }
 
 const identityFn = (v) => v;
+/**
+ * Create a linked signal which represents state that is (re)set from a linked reactive expression.
+ */
+function createLinkedSignal(node) {
+    const linkedSignalGetter = () => {
+        // Check if the value needs updating before returning it.
+        producerUpdateValueVersion$1(node);
+        // Record that someone looked at this signal.
+        producerAccessed$1(node);
+        if (node.value === ERRORED) {
+            throw node.error;
+        }
+        return node.value;
+    };
+    const getter = linkedSignalGetter;
+    getter[SIGNAL$1] = node;
+    if (ngDevMode) {
+        getter.toString = () => `[LinkedSignal: ${getter()}]`;
+    }
+    getter.set = (newValue) => {
+        producerUpdateValueVersion$1(node);
+        signalSetFn$1(node, newValue);
+        producerMarkClean$1(node);
+    };
+    getter.update = (updateFn) => {
+        producerUpdateValueVersion$1(node);
+        signalUpdateFn$1(node, updateFn);
+        producerMarkClean$1(node);
+    };
+    getter.asReadonly = signalAsReadonlyFn.bind(getter);
+    return getter;
+}
 function linkedSignal(optionsOrComputation, options) {
     performanceMarkFeature('NgSignals');
-    if (typeof optionsOrComputation === 'function') {
-        const getter = createLinkedSignal$1(optionsOrComputation, (identityFn), options?.equal);
-        return upgradeLinkedSignalGetter(getter);
-    }
-    else {
-        const getter = createLinkedSignal$1(optionsOrComputation.source, optionsOrComputation.computation, optionsOrComputation.equal);
-        return upgradeLinkedSignalGetter(getter);
+    const isShorthand = typeof optionsOrComputation === 'function';
+    const node = Object.create(LINKED_SIGNAL_NODE);
+    node.source = isShorthand ? optionsOrComputation : optionsOrComputation.source;
+    if (!isShorthand) {
+        node.computation = optionsOrComputation.computation;
     }
-}
-function upgradeLinkedSignalGetter(getter) {
-    if (ngDevMode) {
-        getter.toString = () => `[LinkedSignal: ${getter()}]`;
+    const equal = isShorthand ? options?.equal : optionsOrComputation.equal;
+    if (equal) {
+        node.equal = equal;
     }
-    const node = getter[SIGNAL$1];
-    const upgradedGetter = getter;
-    upgradedGetter.set = (newValue) => linkedSignalSetFn$1(node, newValue);
-    upgradedGetter.update = (updateFn) => linkedSignalUpdateFn$1(node, updateFn);
-    upgradedGetter.asReadonly = signalAsReadonlyFn.bind(getter);
-    return upgradedGetter;
+    return createLinkedSignal(node);
 }
+/**
+ * A dedicated symbol used before a state value has been set / calculated for the first time.
+ * Explicitly typed as `any` so we can use it as signal's value.
+ */
+const UNSET = /* @__PURE__ */ Symbol('UNSET');
+/**
+ * A dedicated symbol used in place of a linked signal value to indicate that a given computation
+ * is in progress. Used to detect cycles in computation chains.
+ * Explicitly typed as `any` so we can use it as signal's value.
+ */
+const COMPUTING = /* @__PURE__ */ Symbol('COMPUTING');
+/**
+ * A dedicated symbol used in place of a linked signal value to indicate that a given computation
+ * failed. The thrown error is cached until the computation gets dirty again or the state is set.
+ * Explicitly typed as `any` so we can use it as signal's value.
+ */
+const ERRORED = /* @__PURE__ */ Symbol('ERRORED');
+// Note: Using an IIFE here to ensure that the spread assignment is not considered
+// a side-effect, ending up preserving `LINKED_SIGNAL_NODE` and `REACTIVE_NODE`.
+// TODO: remove when https://github.com/evanw/esbuild/issues/3392 is resolved.
+const LINKED_SIGNAL_NODE = /* @__PURE__ */ (() => {
+    return {
+        ...REACTIVE_NODE$1,
+        value: UNSET,
+        dirty: true,
+        error: null,
+        equal: defaultEquals$1,
+        computation: identityFn,
+        producerMustRecompute(node) {
+            // Force a recomputation if there's no current value, or if the current value is in the
+            // process of being calculated (which should throw an error).
+            return node.value === UNSET || node.value === COMPUTING;
+        },
+        producerRecomputeValue(node) {
+            if (node.value === COMPUTING) {
+                // Our computation somehow led to a cyclic read of itself.
+                throw new Error('Detected cycle in computations.');
+            }
+            const oldValue = node.value;
+            node.value = COMPUTING;
+            const prevConsumer = consumerBeforeComputation$1(node);
+            let newValue;
+            try {
+                const newSourceValue = node.source();
+                const prev = oldValue === UNSET || oldValue === ERRORED
+                    ? undefined
+                    : {
+                        source: node.sourceValue,
+                        value: oldValue,
+                    };
+                newValue = node.computation(newSourceValue, prev);
+                node.sourceValue = newSourceValue;
+            }
+            catch (err) {
+                newValue = ERRORED;
+                node.error = err;
+            }
+            finally {
+                consumerAfterComputation$1(node, prevConsumer);
+            }
+            if (oldValue !== UNSET && newValue !== ERRORED && node.equal(oldValue, newValue)) {
+                // No change to `valueVersion` - old and new values are
+                // semantically equivalent.
+                node.value = oldValue;
+                return;
+            }
+            node.value = newValue;
+            node.version++;
+        },
+    };
+})();
 
 /**
  * Execute an arbitrary function in a non-reactive (non-tracking) context. The executed function
@@ -41097,7 +41294,7 @@ var ResourceStatus;
 function resource(options) {
     options?.injector || assertInInjectionContext(resource);
     const request = (options.request ?? (() => null));
-    return new ResourceImpl(request, options.loader, undefined, options.equal ? wrapEqualityFn(options.equal) : undefined, options.injector ?? inject(Injector));
+    return new ResourceImpl(request, getLoader(options), undefined, options.equal ? wrapEqualityFn(options.equal) : undefined, options.injector ?? inject(Injector));
 }
 /**
  * Base class which implements `.value` as a `WritableSignal` by delegating `.set` and `.update`.
@@ -41143,9 +41340,13 @@ class ResourceImpl extends BaseWritableResource {
     resolvePendingTask = undefined;
     destroyed = false;
     constructor(request, loaderFn, defaultValue, equal, injector) {
+        super(
         // Feed a computed signal for the value to `BaseWritableResource`, which will upgrade it to a
         // `WritableSignal` that delegates to `ResourceImpl.set`.
-        super(computed(() => this.state().value, { equal }));
+        computed(() => {
+            const stream = this.state()?.stream?.();
+            return stream && isResolved(stream) ? stream.value : this.defaultValue;
+        }, { equal }));
         this.loaderFn = loaderFn;
         this.defaultValue = defaultValue;
         this.equal = equal;
@@ -41174,13 +41375,10 @@ class ResourceImpl extends BaseWritableResource {
                 status,
                 // When the state of the resource changes due to the request, remember the previous status
                 // for the loader to consider.
-                previousStatus: previous?.value.status ?? ResourceStatus.Idle,
+                previousStatus: computeStatusOfState(previous?.value),
                 // In `Reloading` state, we keep the previous value if there is one, since the identity of
                 // the request hasn't changed. Otherwise, we switch back to the default value.
-                value: previous && status === ResourceStatus.Reloading
-                    ? previous.value.value
-                    : this.defaultValue,
-                error: undefined,
+                stream: previous && status === ResourceStatus.Reloading ? previous.value.stream : undefined,
             }),
         });
         this.effectRef = effect(this.loadEffect.bind(this), {
@@ -41190,8 +41388,16 @@ class ResourceImpl extends BaseWritableResource {
         // Cancel any pending request when the resource itself is destroyed.
         injector.get(DestroyRef).onDestroy(() => this.destroy());
     }
-    status = computed(() => this.state().status);
-    error = computed(() => this.state().error);
+    status = computed(() => {
+        if (this.state().status !== ResourceStatus.Resolved) {
+            return this.state().status;
+        }
+        return isResolved(this.state().stream()) ? ResourceStatus.Resolved : ResourceStatus.Error;
+    });
+    error = computed(() => {
+        const stream = this.state().stream?.();
+        return stream && !isResolved(stream) ? stream.error : undefined;
+    });
     /**
      * Called either directly via `WritableResource.set` or via `.value.set()`.
      */
@@ -41199,16 +41405,15 @@ class ResourceImpl extends BaseWritableResource {
         if (this.destroyed) {
             return;
         }
-        const currentState = untracked(this.state);
-        if (this.equal ? this.equal(currentState.value, value) : currentState.value === value) {
+        const current = untracked(this.value);
+        if (this.equal ? this.equal(current, value) : current === value) {
             return;
         }
         // Enter Local state with the user-defined value.
         this.state.set({
             status: ResourceStatus.Local,
             previousStatus: ResourceStatus.Local,
-            value,
-            error: undefined,
+            stream: signal({ value }),
         });
         // We're departing from whatever state the resource was in previously, so cancel any in-progress
         // loading operations.
@@ -41234,8 +41439,7 @@ class ResourceImpl extends BaseWritableResource {
         this.state.set({
             status: ResourceStatus.Idle,
             previousStatus: ResourceStatus.Idle,
-            value: this.defaultValue,
-            error: undefined,
+            stream: undefined,
         });
     }
     async loadEffect() {
@@ -41268,49 +41472,43 @@ class ResourceImpl extends BaseWritableResource {
         // After the loading operation is cancelled, `this.resolvePendingTask` no longer represents this
         // particular task, but this `await` may eventually resolve/reject. Thus, when we cancel in
         // response to (1) below, we need to cancel the locally saved task.
-        const resolvePendingTask = (this.resolvePendingTask = this.pendingTasks.add());
+        let resolvePendingTask = (this.resolvePendingTask =
+            this.pendingTasks.add());
         const { signal: abortSignal } = (this.pendingController = new AbortController());
         try {
             // The actual loading is run through `untracked` - only the request side of `resource` is
             // reactive. This avoids any confusion with signals tracking or not tracking depending on
             // which side of the `await` they are.
-            const result = await untracked(() => this.loaderFn({
-                abortSignal,
+            const stream = await untracked(() => this.loaderFn({
                 request: request,
+                abortSignal,
                 previous: {
                     status: previousStatus,
                 },
             }));
             if (abortSignal.aborted) {
-                // This load operation was cancelled.
                 return;
             }
-            // Success :)
             this.state.set({
                 status: ResourceStatus.Resolved,
                 previousStatus: ResourceStatus.Resolved,
-                value: result,
-                error: undefined,
+                stream,
             });
         }
         catch (err) {
             if (abortSignal.aborted) {
-                // This load operation was cancelled.
                 return;
             }
-            // Fail :(
             this.state.set({
-                status: ResourceStatus.Error,
+                status: ResourceStatus.Resolved,
                 previousStatus: ResourceStatus.Error,
-                value: this.defaultValue,
-                error: err,
+                stream: signal({ error: err }),
             });
         }
         finally {
-            // Resolve the pending task now that loading is done.
-            resolvePendingTask();
-            // Free the abort controller to drop any registered 'abort' callbacks.
-            this.pendingController = undefined;
+            // Resolve the pending task now that the resource has a value.
+            resolvePendingTask?.();
+            resolvePendingTask = undefined;
         }
     }
     abortInProgressLoad() {
@@ -41327,6 +41525,35 @@ class ResourceImpl extends BaseWritableResource {
 function wrapEqualityFn(equal) {
     return (a, b) => (a === undefined || b === undefined ? a === b : equal(a, b));
 }
+function getLoader(options) {
+    if (isStreamingResourceOptions(options)) {
+        return options.stream;
+    }
+    return async (params) => {
+        try {
+            return signal({ value: await options.loader(params) });
+        }
+        catch (err) {
+            return signal({ error: err });
+        }
+    };
+}
+function isStreamingResourceOptions(options) {
+    return !!options.stream;
+}
+function computeStatusOfState(state) {
+    switch (state?.status) {
+        case undefined:
+            return ResourceStatus.Idle;
+        case ResourceStatus.Resolved:
+            return isResolved(untracked(state.stream)) ? ResourceStatus.Resolved : ResourceStatus.Error;
+        default:
+            return state.status;
+    }
+}
+function isResolved(state) {
+    return state.error === undefined;
+}
 
 /**
  * Creates a `ComponentRef` instance based on provided component type and a set of options.
@@ -41574,5 +41801,5 @@ if (typeof ngDevMode !== 'undefined' && ngDevMode) {
  * Generated bundle index. Do not edit.
  */
 
-export { ANIMATION_MODULE_TYPE, APP_BOOTSTRAP_LISTENER, APP_ID, APP_INITIALIZER, AfterRenderPhase, ApplicationInitStatus, ApplicationModule, ApplicationRef, Attribute, COMPILER_OPTIONS, CSP_NONCE, CUSTOM_ELEMENTS_SCHEMA, ChangeDetectionStrategy, ChangeDetectorRef, Compiler, CompilerFactory, Component, ComponentFactory$1 as ComponentFactory, ComponentFactoryResolver$1 as ComponentFactoryResolver, ComponentRef$1 as ComponentRef, ContentChild, ContentChildren, DEFAULT_CURRENCY_CODE, DebugElement, DebugEventListener, DebugNode, DefaultIterableDiffer, DestroyRef, Directive, ENVIRONMENT_INITIALIZER, ElementRef, EmbeddedViewRef, EnvironmentInjector, ErrorHandler, EventEmitter, HOST_TAG_NAME, Host, HostAttributeToken, HostBinding, HostListener, INJECTOR$1 as 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, OutputEmitterRef, PACKAGE_ROOT_URL, PLATFORM_ID, PLATFORM_INITIALIZER, PendingTasks, Pipe, PlatformRef, Query, QueryList, REQUEST, REQUEST_CONTEXT, RESPONSE_INIT, Renderer2, RendererFactory2, RendererStyleFlags2, ResourceStatus, Sanitizer, SecurityContext, Self, SimpleChange, SkipSelf, TRANSLATIONS, TRANSLATIONS_FORMAT, TemplateRef, Testability, TestabilityRegistry, TransferState, Type, VERSION, Version, ViewChild, ViewChildren, ViewContainerRef, ViewEncapsulation, ViewRef, afterNextRender, afterRender, afterRenderEffect, asNativeElements, assertInInjectionContext, assertNotInReactiveContext, assertPlatform, booleanAttribute, computed, contentChild, contentChildren, createComponent, createEnvironmentInjector, createNgModule, createNgModuleRef, createPlatform, createPlatformFactory, defineInjectable, destroyPlatform, effect, enableProdMode, forwardRef, getDebugNode, getModuleFactory, getNgModuleById, getPlatform, importProvidersFrom, inject, input, isDevMode, isSignal, isStandalone, linkedSignal, makeEnvironmentProviders, makeStateKey, mergeApplicationConfig, model, numberAttribute, output, platformCore, provideAppInitializer, provideEnvironmentInitializer, provideExperimentalCheckNoChangesForDebug, provideExperimentalZonelessChangeDetection, providePlatformInitializer, provideZoneChangeDetection, reflectComponentType, resolveForwardRef, resource, runInInjectionContext, setTestabilityGetter, signal, untracked, viewChild, viewChildren, ALLOW_MULTIPLE_PLATFORMS as ɵALLOW_MULTIPLE_PLATFORMS, AfterRenderManager as ɵAfterRenderManager, CONTAINER_HEADER_OFFSET as ɵCONTAINER_HEADER_OFFSET, ChangeDetectionScheduler as ɵChangeDetectionScheduler, ChangeDetectionSchedulerImpl as ɵChangeDetectionSchedulerImpl, ComponentFactory$1 as ɵComponentFactory, Console as ɵConsole, DEFAULT_LOCALE_ID as ɵDEFAULT_LOCALE_ID, DEFER_BLOCK_CONFIG as ɵDEFER_BLOCK_CONFIG, DEFER_BLOCK_DEPENDENCY_INTERCEPTOR as ɵDEFER_BLOCK_DEPENDENCY_INTERCEPTOR, DeferBlockBehavior as ɵDeferBlockBehavior, DeferBlockState as ɵDeferBlockState, ENABLE_ROOT_COMPONENT_BOOTSTRAP as ɵENABLE_ROOT_COMPONENT_BOOTSTRAP, EffectScheduler as ɵEffectScheduler, IMAGE_CONFIG as ɵIMAGE_CONFIG, IMAGE_CONFIG_DEFAULTS as ɵIMAGE_CONFIG_DEFAULTS, INJECTOR_SCOPE as ɵINJECTOR_SCOPE, ɵINPUT_SIGNAL_BRAND_WRITE_TYPE, INTERNAL_APPLICATION_ERROR_HANDLER as ɵINTERNAL_APPLICATION_ERROR_HANDLER, IS_HYDRATION_DOM_REUSE_ENABLED as ɵIS_HYDRATION_DOM_REUSE_ENABLED, IS_INCREMENTAL_HYDRATION_ENABLED as ɵIS_INCREMENTAL_HYDRATION_ENABLED, JSACTION_EVENT_CONTRACT as ɵJSACTION_EVENT_CONTRACT, LContext as ɵLContext, LocaleDataIndex as ɵLocaleDataIndex, MicrotaskEffectScheduler as ɵMicrotaskEffectScheduler, 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, PERFORMANCE_MARK_PREFIX as ɵPERFORMANCE_MARK_PREFIX, PROVIDED_NG_ZONE as ɵPROVIDED_NG_ZONE, PendingTasksInternal as ɵPendingTasksInternal, ReflectionCapabilities as ɵReflectionCapabilities, ComponentFactory as ɵRender3ComponentFactory, ComponentRef as ɵRender3ComponentRef, NgModuleRef as ɵRender3NgModuleRef, RuntimeError as ɵRuntimeError, SSR_CONTENT_INTEGRITY_MARKER as ɵSSR_CONTENT_INTEGRITY_MARKER, TESTABILITY as ɵTESTABILITY, TESTABILITY_GETTER as ɵTESTABILITY_GETTER, TracingAction as ɵTracingAction, TracingService as ɵTracingService, USE_RUNTIME_DEPS_TRACKER_FOR_JIT as ɵUSE_RUNTIME_DEPS_TRACKER_FOR_JIT, ViewRef$1 as ɵViewRef, XSS_SECURITY_URL as ɵXSS_SECURITY_URL, ZONELESS_ENABLED as ɵZONELESS_ENABLED, _sanitizeHtml as ɵ_sanitizeHtml, _sanitizeUrl as ɵ_sanitizeUrl, allowSanitizationBypassAndThrow as ɵallowSanitizationBypassAndThrow, annotateForHydration as ɵannotateForHydration, bypassSanitizationTrustHtml as ɵbypassSanitizationTrustHtml, bypassSanitizationTrustResourceUrl as ɵbypassSanitizationTrustResourceUrl, bypassSanitizationTrustScript as ɵbypassSanitizationTrustScript, bypassSanitizationTrustStyle as ɵbypassSanitizationTrustStyle, bypassSanitizationTrustUrl as ɵbypassSanitizationTrustUrl, clearResolutionOfComponentResourcesQueue as ɵclearResolutionOfComponentResourcesQueue, compileComponent as ɵcompileComponent, compileDirective as ɵcompileDirective, compileNgModule as ɵcompileNgModule, compileNgModuleDefs as ɵcompileNgModuleDefs, compileNgModuleFactory as ɵcompileNgModuleFactory, compilePipe as ɵcompilePipe, convertToBitFlags as ɵconvertToBitFlags, createInjector as ɵcreateInjector, defaultIterableDiffers as ɵdefaultIterableDiffers, defaultKeyValueDiffers as ɵdefaultKeyValueDiffers, depsTracker as ɵdepsTracker, detectChangesInViewIfRequired as ɵdetectChangesInViewIfRequired, devModeEqual as ɵdevModeEqual, disableProfiling as ɵdisableProfiling, enableProfiling as ɵenableProfiling, findLocaleData as ɵfindLocaleData, flushModuleScopingQueueAsMuchAsPossible as ɵflushModuleScopingQueueAsMuchAsPossible, formatRuntimeError as ɵformatRuntimeError, generateStandaloneInDeclarationsError as ɵgenerateStandaloneInDeclarationsError, getAsyncClassMetadataFn as ɵgetAsyncClassMetadataFn, getClosestComponentName as ɵgetClosestComponentName, getDebugNode as ɵgetDebugNode, getDeferBlocks$1 as ɵgetDeferBlocks, getDirectives as ɵgetDirectives, getHostElement as ɵgetHostElement, getInjectableDef as ɵgetInjectableDef, getLContext as ɵgetLContext, getLocaleCurrencyCode as ɵgetLocaleCurrencyCode, getLocalePluralCase as ɵgetLocalePluralCase, getOutputDestroyRef as ɵgetOutputDestroyRef, getSanitizationBypassType as ɵgetSanitizationBypassType, ɵgetUnknownElementStrictMode, ɵgetUnknownPropertyStrictMode, _global as ɵglobal, injectChangeDetectorRef as ɵinjectChangeDetectorRef, internalCreateApplication as ɵinternalCreateApplication, internalProvideZoneChangeDetection as ɵinternalProvideZoneChangeDetection, isBoundToModule as ɵisBoundToModule, isComponentDefPendingResolution as ɵisComponentDefPendingResolution, isEnvironmentProviders as ɵisEnvironmentProviders, isInjectable as ɵisInjectable, isNgModule as ɵisNgModule, isPromise as ɵisPromise, isSubscribable as ɵisSubscribable, microtaskEffect as ɵmicrotaskEffect, noSideEffects as ɵnoSideEffects, patchComponentDefWithScope as ɵpatchComponentDefWithScope, performanceMarkFeature as ɵperformanceMarkFeature, publishExternalGlobalUtil as ɵpublishExternalGlobalUtil, readHydrationInfo as ɵreadHydrationInfo, registerLocaleData as ɵregisterLocaleData, renderDeferBlockState as ɵrenderDeferBlockState, resetCompiledComponents as ɵresetCompiledComponents, resetJitOptions as ɵresetJitOptions, resolveComponentResources as ɵresolveComponentResources, restoreComponentResolutionQueue as ɵrestoreComponentResolutionQueue, setAllowDuplicateNgModuleIdsForTest as ɵsetAllowDuplicateNgModuleIdsForTest, setAlternateWeakRefImpl as ɵsetAlternateWeakRefImpl, ɵsetClassDebugInfo, setClassMetadata as ɵsetClassMetadata, setClassMetadataAsync as ɵsetClassMetadataAsync, setCurrentInjector as ɵsetCurrentInjector, setDocument as ɵsetDocument, setInjectorProfilerContext as ɵsetInjectorProfilerContext, setLocaleId as ɵsetLocaleId, ɵsetUnknownElementStrictMode, ɵsetUnknownPropertyStrictMode, startMeasuring as ɵstartMeasuring, stopMeasuring as ɵstopMeasuring, store as ɵstore, stringify as ɵstringify, transitiveScopesFor as ɵtransitiveScopesFor, triggerResourceLoading as ɵtriggerResourceLoading, truncateMiddle as ɵtruncateMiddle, unregisterAllLocaleData as ɵunregisterLocaleData, unwrapSafeValue as ɵunwrapSafeValue, ɵunwrapWritableSignal, withDomHydration as ɵwithDomHydration, withEventReplay as ɵwithEventReplay, withI18nSupport as ɵwithI18nSupport, withIncrementalHydration as ɵwithIncrementalHydration, ɵɵCopyDefinitionFeature, ɵɵExternalStylesFeature, FactoryTarget as ɵɵFactoryTarget, ɵɵHostDirectivesFeature, ɵɵInheritDefinitionFeature, ɵɵInputTransformsFeature, ɵɵNgOnChangesFeature, ɵɵProvidersFeature, ɵɵadvance, ɵɵattachSourceLocations, ɵɵattribute, ɵɵattributeInterpolate1, ɵɵattributeInterpolate2, ɵɵattributeInterpolate3, ɵɵattributeInterpolate4, ɵɵattributeInterpolate5, ɵɵattributeInterpolate6, ɵɵattributeInterpolate7, ɵɵattributeInterpolate8, ɵɵattributeInterpolateV, ɵɵclassMap, ɵɵclassMapInterpolate1, ɵɵclassMapInterpolate2, ɵɵclassMapInterpolate3, ɵɵclassMapInterpolate4, ɵɵclassMapInterpolate5, ɵɵclassMapInterpolate6, ɵɵclassMapInterpolate7, ɵɵclassMapInterpolate8, ɵɵclassMapInterpolateV, ɵɵclassProp, ɵɵcomponentInstance, ɵɵconditional, ɵɵcontentQuery, ɵɵcontentQuerySignal, ɵɵdeclareLet, ɵɵdefer, ɵɵdeferEnableTimerScheduling, ɵɵdeferHydrateNever, ɵɵdeferHydrateOnHover, ɵɵdeferHydrateOnIdle, ɵɵdeferHydrateOnImmediate, ɵɵdeferHydrateOnInteraction, ɵɵdeferHydrateOnTimer, ɵɵdeferHydrateOnViewport, ɵɵdeferHydrateWhen, ɵɵdeferOnHover, ɵɵdeferOnIdle, ɵɵdeferOnImmediate, ɵɵdeferOnInteraction, ɵɵdeferOnTimer, ɵɵdeferOnViewport, ɵɵdeferPrefetchOnHover, ɵɵdeferPrefetchOnIdle, ɵɵdeferPrefetchOnImmediate, ɵɵdeferPrefetchOnInteraction, ɵɵdeferPrefetchOnTimer, ɵɵdeferPrefetchOnViewport, ɵɵdeferPrefetchWhen, ɵɵdeferWhen, ɵɵdefineComponent, ɵɵdefineDirective, ɵɵdefineInjectable, ɵɵdefineInjector, ɵɵdefineNgModule, ɵɵdefinePipe, ɵɵdirectiveInject, ɵɵdisableBindings, ɵɵelement, ɵɵelementContainer, ɵɵelementContainerEnd, ɵɵelementContainerStart, ɵɵelementEnd, ɵɵelementStart, ɵɵenableBindings, ɵɵgetComponentDepsFactory, ɵɵgetCurrentView, ɵɵgetInheritedFactory, ɵɵhostProperty, ɵɵi18n, ɵɵi18nApply, ɵɵi18nAttributes, ɵɵi18nEnd, ɵɵi18nExp, ɵɵi18nPostprocess, ɵɵi18nStart, ɵɵinject, ɵɵinjectAttribute, ɵɵinvalidFactory, ɵɵinvalidFactoryDep, ɵɵlistener, ɵɵloadQuery, ɵɵnamespaceHTML, ɵɵnamespaceMathML, ɵɵnamespaceSVG, ɵɵnextContext, ɵɵngDeclareClassMetadata, ɵɵngDeclareClassMetadataAsync, ɵɵ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, ɵɵqueryAdvance, ɵɵqueryRefresh, ɵɵreadContextLet, ɵɵreference, registerNgModuleType as ɵɵregisterNgModuleType, ɵɵrepeater, ɵɵrepeaterCreate, ɵɵrepeaterTrackByIdentity, ɵɵrepeaterTrackByIndex, ɵɵreplaceMetadata, ɵɵresetView, ɵɵresolveBody, ɵɵresolveDocument, ɵɵresolveWindow, ɵɵrestoreView, ɵɵsanitizeHtml, ɵɵsanitizeResourceUrl, ɵɵsanitizeScript, ɵɵsanitizeStyle, ɵɵsanitizeUrl, ɵɵsanitizeUrlOrResourceUrl, ɵɵsetComponentScope, ɵɵsetNgModuleScope, ɵɵstoreLet, ɵɵ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, ɵɵtwoWayBindingSet, ɵɵtwoWayListener, ɵɵtwoWayProperty, ɵɵvalidateIframeAttribute, ɵɵviewQuery, ɵɵviewQuerySignal };
+export { ANIMATION_MODULE_TYPE, APP_BOOTSTRAP_LISTENER, APP_ID, APP_INITIALIZER, AfterRenderPhase, ApplicationInitStatus, ApplicationModule, ApplicationRef, Attribute, COMPILER_OPTIONS, CSP_NONCE, CUSTOM_ELEMENTS_SCHEMA, ChangeDetectionStrategy, ChangeDetectorRef, Compiler, CompilerFactory, Component, ComponentFactory$1 as ComponentFactory, ComponentFactoryResolver$1 as ComponentFactoryResolver, ComponentRef$1 as ComponentRef, ContentChild, ContentChildren, DEFAULT_CURRENCY_CODE, DebugElement, DebugEventListener, DebugNode, DefaultIterableDiffer, DestroyRef, Directive, ENVIRONMENT_INITIALIZER, ElementRef, EmbeddedViewRef, EnvironmentInjector, ErrorHandler, EventEmitter, HOST_TAG_NAME, Host, HostAttributeToken, HostBinding, HostListener, INJECTOR$1 as 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, OutputEmitterRef, PACKAGE_ROOT_URL, PLATFORM_ID, PLATFORM_INITIALIZER, PendingTasks, Pipe, PlatformRef, Query, QueryList, REQUEST, REQUEST_CONTEXT, RESPONSE_INIT, Renderer2, RendererFactory2, RendererStyleFlags2, ResourceStatus, Sanitizer, SecurityContext, Self, SimpleChange, SkipSelf, TRANSLATIONS, TRANSLATIONS_FORMAT, TemplateRef, Testability, TestabilityRegistry, TransferState, Type, VERSION, Version, ViewChild, ViewChildren, ViewContainerRef, ViewEncapsulation, ViewRef, afterNextRender, afterRender, afterRenderEffect, asNativeElements, assertInInjectionContext, assertNotInReactiveContext, assertPlatform, booleanAttribute, computed, contentChild, contentChildren, createComponent, createEnvironmentInjector, createNgModule, createNgModuleRef, createPlatform, createPlatformFactory, defineInjectable, destroyPlatform, effect, enableProdMode, forwardRef, getDebugNode, getModuleFactory, getNgModuleById, getPlatform, importProvidersFrom, inject, input, isDevMode, isSignal, isStandalone, linkedSignal, makeEnvironmentProviders, makeStateKey, mergeApplicationConfig, model, numberAttribute, output, platformCore, provideAppInitializer, provideEnvironmentInitializer, provideExperimentalCheckNoChangesForDebug, provideExperimentalZonelessChangeDetection, providePlatformInitializer, provideZoneChangeDetection, reflectComponentType, resolveForwardRef, resource, runInInjectionContext, setTestabilityGetter, signal, untracked, viewChild, viewChildren, ALLOW_MULTIPLE_PLATFORMS as ɵALLOW_MULTIPLE_PLATFORMS, AfterRenderManager as ɵAfterRenderManager, CONTAINER_HEADER_OFFSET as ɵCONTAINER_HEADER_OFFSET, ChangeDetectionScheduler as ɵChangeDetectionScheduler, ChangeDetectionSchedulerImpl as ɵChangeDetectionSchedulerImpl, ComponentFactory$1 as ɵComponentFactory, Console as ɵConsole, DEFAULT_LOCALE_ID as ɵDEFAULT_LOCALE_ID, DEFER_BLOCK_CONFIG as ɵDEFER_BLOCK_CONFIG, DEFER_BLOCK_DEPENDENCY_INTERCEPTOR as ɵDEFER_BLOCK_DEPENDENCY_INTERCEPTOR, DeferBlockBehavior as ɵDeferBlockBehavior, DeferBlockState as ɵDeferBlockState, ENABLE_ROOT_COMPONENT_BOOTSTRAP as ɵENABLE_ROOT_COMPONENT_BOOTSTRAP, EffectScheduler as ɵEffectScheduler, IMAGE_CONFIG as ɵIMAGE_CONFIG, IMAGE_CONFIG_DEFAULTS as ɵIMAGE_CONFIG_DEFAULTS, INJECTOR_SCOPE as ɵINJECTOR_SCOPE, ɵINPUT_SIGNAL_BRAND_WRITE_TYPE, INTERNAL_APPLICATION_ERROR_HANDLER as ɵINTERNAL_APPLICATION_ERROR_HANDLER, IS_HYDRATION_DOM_REUSE_ENABLED as ɵIS_HYDRATION_DOM_REUSE_ENABLED, IS_INCREMENTAL_HYDRATION_ENABLED as ɵIS_INCREMENTAL_HYDRATION_ENABLED, JSACTION_EVENT_CONTRACT as ɵJSACTION_EVENT_CONTRACT, LContext as ɵLContext, LifecycleHooksFeature as ɵLifecycleHooksFeature, LocaleDataIndex as ɵLocaleDataIndex, MicrotaskEffectScheduler as ɵMicrotaskEffectScheduler, 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, PERFORMANCE_MARK_PREFIX as ɵPERFORMANCE_MARK_PREFIX, PROVIDED_NG_ZONE as ɵPROVIDED_NG_ZONE, PendingTasksInternal as ɵPendingTasksInternal, ReflectionCapabilities as ɵReflectionCapabilities, ComponentFactory as ɵRender3ComponentFactory, ComponentRef as ɵRender3ComponentRef, NgModuleRef as ɵRender3NgModuleRef, RuntimeError as ɵRuntimeError, SSR_CONTENT_INTEGRITY_MARKER as ɵSSR_CONTENT_INTEGRITY_MARKER, TESTABILITY as ɵTESTABILITY, TESTABILITY_GETTER as ɵTESTABILITY_GETTER, TracingAction as ɵTracingAction, TracingService as ɵTracingService, USE_RUNTIME_DEPS_TRACKER_FOR_JIT as ɵUSE_RUNTIME_DEPS_TRACKER_FOR_JIT, ViewRef$1 as ɵViewRef, XSS_SECURITY_URL as ɵXSS_SECURITY_URL, ZONELESS_ENABLED as ɵZONELESS_ENABLED, _sanitizeHtml as ɵ_sanitizeHtml, _sanitizeUrl as ɵ_sanitizeUrl, allowSanitizationBypassAndThrow as ɵallowSanitizationBypassAndThrow, annotateForHydration as ɵannotateForHydration, bypassSanitizationTrustHtml as ɵbypassSanitizationTrustHtml, bypassSanitizationTrustResourceUrl as ɵbypassSanitizationTrustResourceUrl, bypassSanitizationTrustScript as ɵbypassSanitizationTrustScript, bypassSanitizationTrustStyle as ɵbypassSanitizationTrustStyle, bypassSanitizationTrustUrl as ɵbypassSanitizationTrustUrl, clearResolutionOfComponentResourcesQueue as ɵclearResolutionOfComponentResourcesQueue, compileComponent as ɵcompileComponent, compileDirective as ɵcompileDirective, compileNgModule as ɵcompileNgModule, compileNgModuleDefs as ɵcompileNgModuleDefs, compileNgModuleFactory as ɵcompileNgModuleFactory, compilePipe as ɵcompilePipe, convertToBitFlags as ɵconvertToBitFlags, createInjector as ɵcreateInjector, defaultIterableDiffers as ɵdefaultIterableDiffers, defaultKeyValueDiffers as ɵdefaultKeyValueDiffers, depsTracker as ɵdepsTracker, detectChangesInViewIfRequired as ɵdetectChangesInViewIfRequired, devModeEqual as ɵdevModeEqual, disableProfiling as ɵdisableProfiling, enableProfiling as ɵenableProfiling, findLocaleData as ɵfindLocaleData, flushModuleScopingQueueAsMuchAsPossible as ɵflushModuleScopingQueueAsMuchAsPossible, formatRuntimeError as ɵformatRuntimeError, generateStandaloneInDeclarationsError as ɵgenerateStandaloneInDeclarationsError, getAsyncClassMetadataFn as ɵgetAsyncClassMetadataFn, getClosestComponentName as ɵgetClosestComponentName, getDebugNode as ɵgetDebugNode, getDeferBlocks$1 as ɵgetDeferBlocks, getDirectives as ɵgetDirectives, getHostElement as ɵgetHostElement, getInjectableDef as ɵgetInjectableDef, getLContext as ɵgetLContext, getLocaleCurrencyCode as ɵgetLocaleCurrencyCode, getLocalePluralCase as ɵgetLocalePluralCase, getOutputDestroyRef as ɵgetOutputDestroyRef, getSanitizationBypassType as ɵgetSanitizationBypassType, ɵgetUnknownElementStrictMode, ɵgetUnknownPropertyStrictMode, _global as ɵglobal, injectChangeDetectorRef as ɵinjectChangeDetectorRef, internalCreateApplication as ɵinternalCreateApplication, internalProvideZoneChangeDetection as ɵinternalProvideZoneChangeDetection, isBoundToModule as ɵisBoundToModule, isComponentDefPendingResolution as ɵisComponentDefPendingResolution, isEnvironmentProviders as ɵisEnvironmentProviders, isInjectable as ɵisInjectable, isNgModule as ɵisNgModule, isPromise as ɵisPromise, isSubscribable as ɵisSubscribable, microtaskEffect as ɵmicrotaskEffect, noSideEffects as ɵnoSideEffects, patchComponentDefWithScope as ɵpatchComponentDefWithScope, performanceMarkFeature as ɵperformanceMarkFeature, publishExternalGlobalUtil as ɵpublishExternalGlobalUtil, readHydrationInfo as ɵreadHydrationInfo, registerLocaleData as ɵregisterLocaleData, renderDeferBlockState as ɵrenderDeferBlockState, resetCompiledComponents as ɵresetCompiledComponents, resetJitOptions as ɵresetJitOptions, resolveComponentResources as ɵresolveComponentResources, restoreComponentResolutionQueue as ɵrestoreComponentResolutionQueue, setAllowDuplicateNgModuleIdsForTest as ɵsetAllowDuplicateNgModuleIdsForTest, setAlternateWeakRefImpl as ɵsetAlternateWeakRefImpl, ɵsetClassDebugInfo, setClassMetadata as ɵsetClassMetadata, setClassMetadataAsync as ɵsetClassMetadataAsync, setCurrentInjector as ɵsetCurrentInjector, setDocument as ɵsetDocument, setInjectorProfilerContext as ɵsetInjectorProfilerContext, setLocaleId as ɵsetLocaleId, ɵsetUnknownElementStrictMode, ɵsetUnknownPropertyStrictMode, startMeasuring as ɵstartMeasuring, stopMeasuring as ɵstopMeasuring, store as ɵstore, stringify as ɵstringify, transitiveScopesFor as ɵtransitiveScopesFor, triggerResourceLoading as ɵtriggerResourceLoading, truncateMiddle as ɵtruncateMiddle, unregisterAllLocaleData as ɵunregisterLocaleData, unwrapSafeValue as ɵunwrapSafeValue, ɵunwrapWritableSignal, withDomHydration as ɵwithDomHydration, withEventReplay as ɵwithEventReplay, withI18nSupport as ɵwithI18nSupport, withIncrementalHydration as ɵwithIncrementalHydration, ɵɵCopyDefinitionFeature, ɵɵExternalStylesFeature, FactoryTarget as ɵɵFactoryTarget, ɵɵHostDirectivesFeature, ɵɵInheritDefinitionFeature, ɵɵInputTransformsFeature, ɵɵNgOnChangesFeature, ɵɵProvidersFeature, ɵɵadvance, ɵɵattachSourceLocations, ɵɵattribute, ɵɵattributeInterpolate1, ɵɵattributeInterpolate2, ɵɵattributeInterpolate3, ɵɵattributeInterpolate4, ɵɵattributeInterpolate5, ɵɵattributeInterpolate6, ɵɵattributeInterpolate7, ɵɵattributeInterpolate8, ɵɵattributeInterpolateV, ɵɵclassMap, ɵɵclassMapInterpolate1, ɵɵclassMapInterpolate2, ɵɵclassMapInterpolate3, ɵɵclassMapInterpolate4, ɵɵclassMapInterpolate5, ɵɵclassMapInterpolate6, ɵɵclassMapInterpolate7, ɵɵclassMapInterpolate8, ɵɵclassMapInterpolateV, ɵɵclassProp, ɵɵcomponentInstance, ɵɵconditional, ɵɵcontentQuery, ɵɵcontentQuerySignal, ɵɵdeclareLet, ɵɵdefer, ɵɵdeferEnableTimerScheduling, ɵɵdeferHydrateNever, ɵɵdeferHydrateOnHover, ɵɵdeferHydrateOnIdle, ɵɵdeferHydrateOnImmediate, ɵɵdeferHydrateOnInteraction, ɵɵdeferHydrateOnTimer, ɵɵdeferHydrateOnViewport, ɵɵdeferHydrateWhen, ɵɵdeferOnHover, ɵɵdeferOnIdle, ɵɵdeferOnImmediate, ɵɵdeferOnInteraction, ɵɵdeferOnTimer, ɵɵdeferOnViewport, ɵɵdeferPrefetchOnHover, ɵɵdeferPrefetchOnIdle, ɵɵdeferPrefetchOnImmediate, ɵɵdeferPrefetchOnInteraction, ɵɵdeferPrefetchOnTimer, ɵɵdeferPrefetchOnViewport, ɵɵdeferPrefetchWhen, ɵɵdeferWhen, ɵɵdefineComponent, ɵɵdefineDirective, ɵɵdefineInjectable, ɵɵdefineInjector, ɵɵdefineNgModule, ɵɵdefinePipe, ɵɵdirectiveInject, ɵɵdisableBindings, ɵɵelement, ɵɵelementContainer, ɵɵelementContainerEnd, ɵɵelementContainerStart, ɵɵelementEnd, ɵɵelementStart, ɵɵenableBindings, ɵɵgetComponentDepsFactory, ɵɵgetCurrentView, ɵɵgetInheritedFactory, ɵɵhostProperty, ɵɵi18n, ɵɵi18nApply, ɵɵi18nAttributes, ɵɵi18nEnd, ɵɵi18nExp, ɵɵi18nPostprocess, ɵɵi18nStart, ɵɵinject, ɵɵinjectAttribute, ɵɵinvalidFactory, ɵɵinvalidFactoryDep, ɵɵlistener, ɵɵloadQuery, ɵɵnamespaceHTML, ɵɵnamespaceMathML, ɵɵnamespaceSVG, ɵɵnextContext, ɵɵngDeclareClassMetadata, ɵɵngDeclareClassMetadataAsync, ɵɵ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, ɵɵqueryAdvance, ɵɵqueryRefresh, ɵɵreadContextLet, ɵɵreference, registerNgModuleType as ɵɵregisterNgModuleType, ɵɵrepeater, ɵɵrepeaterCreate, ɵɵrepeaterTrackByIdentity, ɵɵrepeaterTrackByIndex, ɵɵreplaceMetadata, ɵɵresetView, ɵɵresolveBody, ɵɵresolveDocument, ɵɵresolveWindow, ɵɵrestoreView, ɵɵsanitizeHtml, ɵɵsanitizeResourceUrl, ɵɵsanitizeScript, ɵɵsanitizeStyle, ɵɵsanitizeUrl, ɵɵsanitizeUrlOrResourceUrl, ɵɵsetComponentScope, ɵɵsetNgModuleScope, ɵɵstoreLet, ɵɵ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, ɵɵtwoWayBindingSet, ɵɵtwoWayListener, ɵɵtwoWayProperty, ɵɵvalidateIframeAttribute, ɵɵviewQuery, ɵɵviewQuerySignal };
 //# sourceMappingURL=core.mjs.map