@angular/core 19.2.0-next.3 → 19.2.0

package/fesm2022/core.mjs

@@ -1,10 +1,10 @@
 /**
- * @license Angular v19.2.0-next.3
+ * @license Angular v19.2.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, createWatch as createWatch$1, isInNotificationPhase as isInNotificationPhase$1, createLinkedSignal as createLinkedSignal$1, linkedSignalSetFn as linkedSignalSetFn$1, linkedSignalUpdateFn as linkedSignalUpdateFn$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';
@@ -350,23 +350,21 @@ function stringify(token) {
         return token;
     }
     if (Array.isArray(token)) {
-        return '[' + token.map(stringify).join(', ') + ']';
+        return `[${token.map(stringify).join(', ')}]`;
     }
     if (token == null) {
         return '' + token;
     }
-    if (token.overriddenName) {
-        return `${token.overriddenName}`;
+    const name = token.overriddenName || token.name;
+    if (name) {
+        return `${name}`;
     }
-    if (token.name) {
-        return `${token.name}`;
+    const result = token.toString();
+    if (result == null) {
+        return '' + result;
     }
-    const res = token.toString();
-    if (res == null) {
-        return '' + res;
-    }
-    const newLineIndex = res.indexOf('\n');
-    return newLineIndex === -1 ? res : res.substring(0, newLineIndex);
+    const newLineIndex = result.indexOf('\n');
+    return newLineIndex >= 0 ? result.slice(0, newLineIndex) : result;
 }
 /**
  * Concatenates two strings with separator, allocating new strings only when necessary.
@@ -969,8 +967,9 @@ function stringifyTypeFromDebugInfo(debugInfo) {
 
 /** Called when directives inject each other (creating a circular dependency) */
 function throwCyclicDependencyError(token, path) {
-    const depPath = path ? `. Dependency path: ${path.join(' > ')} > ${token}` : '';
-    throw new RuntimeError(-200 /* RuntimeErrorCode.CYCLIC_DI_DEPENDENCY */, ngDevMode ? `Circular dependency in DI detected for ${token}${depPath}` : token);
+    throw new RuntimeError(-200 /* RuntimeErrorCode.CYCLIC_DI_DEPENDENCY */, ngDevMode
+        ? `Circular dependency in DI detected for ${token}${path ? `. Dependency path: ${path.join(' > ')} > ${token}` : ''}`
+        : token);
 }
 function throwMixedMultiProviderError() {
     throw new Error(`Cannot mix multi providers and regular providers`);
@@ -7108,23 +7107,6 @@ function unwrapElementRef(value) {
     return value instanceof ElementRef ? value.nativeElement : value;
 }
 
-const markedFeatures = new Set();
-// tslint:disable:ban
-/**
- * A guarded `performance.mark` for feature marking.
- *
- * This method exists because while all supported browser and node.js version supported by Angular
- * support performance.mark API. This is not the case for other environments such as JSDOM and
- * Cloudflare workers.
- */
-function performanceMarkFeature(feature) {
-    if (markedFeatures.has(feature)) {
-        return;
-    }
-    markedFeatures.add(feature);
-    performance?.mark?.('mark_feature_usage', { detail: { feature } });
-}
-
 /**
  * Checks if the given `value` is a reactive `Signal`.
  */
@@ -7147,7 +7129,6 @@ function ɵunwrapWritableSignal(value) {
  * Create a `Signal` that can be set or updated directly.
  */
 function signal(initialValue, options) {
-    performanceMarkFeature('NgSignals');
     const signalFn = createSignal$1(initialValue);
     const node = signalFn[SIGNAL$1];
     if (options?.equal) {
@@ -8248,23 +8229,12 @@ function assertDomElement(value) {
 function extractInputDebugMetadata(inputs) {
     const res = {};
     for (const key in inputs) {
-        if (!inputs.hasOwnProperty(key)) {
-            continue;
-        }
-        const value = inputs[key];
-        if (value === undefined) {
-            continue;
-        }
-        let minifiedName;
-        if (Array.isArray(value)) {
-            minifiedName = value[0];
-            // flags are not used for now.
-            // TODO: Consider exposing flag information in discovery.
-        }
-        else {
-            minifiedName = value;
+        if (inputs.hasOwnProperty(key)) {
+            const value = inputs[key];
+            if (value !== undefined) {
+                res[key] = value[0];
+            }
         }
-        res[key] = minifiedName;
     }
     return res;
 }
@@ -8638,6 +8608,23 @@ var TracingAction;
  */
 const TracingService = new InjectionToken(ngDevMode ? 'TracingService' : '');
 
+const markedFeatures = new Set();
+// tslint:disable:ban
+/**
+ * A guarded `performance.mark` for feature marking.
+ *
+ * This method exists because while all supported browser and node.js version supported by Angular
+ * support performance.mark API. This is not the case for other environments such as JSDOM and
+ * Cloudflare workers.
+ */
+function performanceMarkFeature(feature) {
+    if (markedFeatures.has(feature)) {
+        return;
+    }
+    markedFeatures.add(feature);
+    performance?.mark?.('mark_feature_usage', { detail: { feature } });
+}
+
 /**
  * Asserts that the current stack frame is not within a reactive context. Useful
  * to disallow certain code from running inside a reactive context (see {@link toSignal}).
@@ -12242,6 +12229,206 @@ function setupStaticAttributes(renderer, element, tNode) {
     }
 }
 
+/**
+ * Creates a TView instance
+ *
+ * @param type Type of `TView`.
+ * @param declTNode Declaration location of this `TView`.
+ * @param templateFn Template function
+ * @param decls The number of nodes, local refs, and pipes in this template
+ * @param directives Registry of directives for this view
+ * @param pipes Registry of pipes for this view
+ * @param viewQuery View queries for this view
+ * @param schemas Schemas for this view
+ * @param consts Constants for this view
+ */
+function createTView(type, declTNode, templateFn, decls, vars, directives, pipes, viewQuery, schemas, constsOrFactory, ssrId) {
+    ngDevMode && ngDevMode.tView++;
+    const bindingStartIndex = HEADER_OFFSET + decls;
+    // This length does not yet contain host bindings from child directives because at this point,
+    // we don't know which directives are active on this template. As soon as a directive is matched
+    // that has a host binding, we will update the blueprint with that def's hostVars count.
+    const initialViewLength = bindingStartIndex + vars;
+    const blueprint = createViewBlueprint(bindingStartIndex, initialViewLength);
+    const consts = typeof constsOrFactory === 'function' ? constsOrFactory() : constsOrFactory;
+    const tView = (blueprint[TVIEW] = {
+        type: type,
+        blueprint: blueprint,
+        template: templateFn,
+        queries: null,
+        viewQuery: viewQuery,
+        declTNode: declTNode,
+        data: blueprint.slice().fill(null, bindingStartIndex),
+        bindingStartIndex: bindingStartIndex,
+        expandoStartIndex: initialViewLength,
+        hostBindingOpCodes: null,
+        firstCreatePass: true,
+        firstUpdatePass: true,
+        staticViewQueries: false,
+        staticContentQueries: false,
+        preOrderHooks: null,
+        preOrderCheckHooks: null,
+        contentHooks: null,
+        contentCheckHooks: null,
+        viewHooks: null,
+        viewCheckHooks: null,
+        destroyHooks: null,
+        cleanup: null,
+        contentQueries: null,
+        components: null,
+        directiveRegistry: typeof directives === 'function' ? directives() : directives,
+        pipeRegistry: typeof pipes === 'function' ? pipes() : pipes,
+        firstChild: null,
+        schemas: schemas,
+        consts: consts,
+        incompleteFirstPass: false,
+        ssrId,
+    });
+    if (ngDevMode) {
+        // For performance reasons it is important that the tView retains the same shape during runtime.
+        // (To make sure that all of the code is monomorphic.) For this reason we seal the object to
+        // prevent class transitions.
+        Object.seal(tView);
+    }
+    return tView;
+}
+function createViewBlueprint(bindingStartIndex, initialViewLength) {
+    const blueprint = [];
+    for (let i = 0; i < initialViewLength; i++) {
+        blueprint.push(i < bindingStartIndex ? null : NO_CHANGE);
+    }
+    return blueprint;
+}
+/**
+ * Gets TView from a template function or creates a new TView
+ * if it doesn't already exist.
+ *
+ * @param def ComponentDef
+ * @returns TView
+ */
+function getOrCreateComponentTView(def) {
+    const tView = def.tView;
+    // Create a TView if there isn't one, or recreate it if the first create pass didn't
+    // complete successfully since we can't know for sure whether it's in a usable shape.
+    if (tView === null || tView.incompleteFirstPass) {
+        // Declaration node here is null since this function is called when we dynamically create a
+        // component and hence there is no declaration.
+        const declTNode = null;
+        return (def.tView = createTView(1 /* TViewType.Component */, declTNode, def.template, def.decls, def.vars, def.directiveDefs, def.pipeDefs, def.viewQuery, def.schemas, def.consts, def.id));
+    }
+    return tView;
+}
+function createLView(parentLView, tView, context, flags, host, tHostNode, environment, renderer, injector, embeddedViewInjector, hydrationInfo) {
+    const lView = tView.blueprint.slice();
+    lView[HOST] = host;
+    lView[FLAGS] =
+        flags |
+            4 /* LViewFlags.CreationMode */ |
+            128 /* LViewFlags.Attached */ |
+            8 /* LViewFlags.FirstLViewPass */ |
+            64 /* LViewFlags.Dirty */ |
+            1024 /* LViewFlags.RefreshView */;
+    if (embeddedViewInjector !== null ||
+        (parentLView && parentLView[FLAGS] & 2048 /* LViewFlags.HasEmbeddedViewInjector */)) {
+        lView[FLAGS] |= 2048 /* LViewFlags.HasEmbeddedViewInjector */;
+    }
+    resetPreOrderHookFlags(lView);
+    ngDevMode && tView.declTNode && parentLView && assertTNodeForLView(tView.declTNode, parentLView);
+    lView[PARENT] = lView[DECLARATION_VIEW] = parentLView;
+    lView[CONTEXT] = context;
+    lView[ENVIRONMENT] = (environment || (parentLView && parentLView[ENVIRONMENT]));
+    ngDevMode && assertDefined(lView[ENVIRONMENT], 'LViewEnvironment is required');
+    lView[RENDERER] = (renderer || (parentLView && parentLView[RENDERER]));
+    ngDevMode && assertDefined(lView[RENDERER], 'Renderer is required');
+    lView[INJECTOR] = injector || (parentLView && parentLView[INJECTOR]) || null;
+    lView[T_HOST] = tHostNode;
+    lView[ID] = getUniqueLViewId();
+    lView[HYDRATION] = hydrationInfo;
+    lView[EMBEDDED_VIEW_INJECTOR] = embeddedViewInjector;
+    ngDevMode &&
+        assertEqual(tView.type == 2 /* TViewType.Embedded */ ? parentLView !== null : true, true, 'Embedded views must have parentLView');
+    lView[DECLARATION_COMPONENT_VIEW] =
+        tView.type == 2 /* TViewType.Embedded */ ? parentLView[DECLARATION_COMPONENT_VIEW] : lView;
+    return lView;
+}
+function createComponentLView(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
+    // accessed through their containers because they may be removed / re-added later.
+    const rendererFactory = lView[ENVIRONMENT].rendererFactory;
+    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);
+}
+/**
+ * Gets the initial set of LView flags based on the component definition that the LView represents.
+ * @param def Component definition from which to determine the flags.
+ */
+function getInitialLViewFlagsFromDef(def) {
+    let flags = 16 /* LViewFlags.CheckAlways */;
+    if (def.signals) {
+        flags = 4096 /* LViewFlags.SignalView */;
+    }
+    else if (def.onPush) {
+        flags = 64 /* LViewFlags.Dirty */;
+    }
+    return flags;
+}
+/**
+ * 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;
+}
+/**
+ * Adds LView or LContainer to the end of the current view tree.
+ *
+ * This structure will be used to traverse through nested views to remove listeners
+ * and call onDestroy callbacks.
+ *
+ * @param lView The view where LView or LContainer should be added
+ * @param adjustedHostIndex Index of the view's host node in LView[], adjusted for header
+ * @param lViewOrLContainer The LView or LContainer to add to the view tree
+ * @returns The state passed in
+ */
+function addToEndOfViewTree(lView, lViewOrLContainer) {
+    // TODO(benlesh/misko): This implementation is incorrect, because it always adds the LContainer
+    // to the end of the queue, which means if the developer retrieves the LContainers from RNodes out
+    // of order, the change detection will run out of order, as the act of retrieving the the
+    // LContainer from the RNode is what adds it to the queue.
+    if (lView[CHILD_HEAD]) {
+        lView[CHILD_TAIL][NEXT] = lViewOrLContainer;
+    }
+    else {
+        lView[CHILD_HEAD] = lViewOrLContainer;
+    }
+    lView[CHILD_TAIL] = lViewOrLContainer;
+    return lViewOrLContainer;
+}
+
 /**
  * Advances to an element for later binding instructions.
  *
@@ -12303,9 +12490,21 @@ var InputFlags;
     InputFlags[InputFlags["HasDecoratorInputTransform"] = 2] = "HasDecoratorInputTransform";
 })(InputFlags || (InputFlags = {}));
 
-function writeToDirectiveInput(def, instance, publicName, privateName, flags, value) {
+function writeToDirectiveInput(def, instance, publicName, value) {
     const prevConsumer = setActiveConsumer$1(null);
     try {
+        if (ngDevMode) {
+            if (!def.inputs.hasOwnProperty(publicName)) {
+                throw new Error(`ASSERTION ERROR: Directive ${def.type.name} does not have an input with a public name of "${publicName}"`);
+            }
+            // Usually we resolve the directive instance using `LView[someIndex]` before writing to an
+            // input, however if the read happens to early, the `LView[someIndex]` might actually be a
+            // `NodeInjectorFactory`. Check for this specific case here since it can break in subtle ways.
+            if (isFactory(instance)) {
+                throw new Error(`ASSERTION ERROR: Cannot write input to factory for type ${def.type.name}. Directive has not been created yet.`);
+            }
+        }
+        const [privateName, flags, transform] = def.inputs[publicName];
         // 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
@@ -12320,9 +12519,9 @@ function writeToDirectiveInput(def, instance, publicName, privateName, flags, va
         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);
+        else if (transform !== null) {
+            // If there is a decorator input transform, run it.
+            value = transform.call(instance, value);
         }
         if (def.setInput !== null) {
             def.setInput(instance, inputSignalNode, value, publicName, privateName);
@@ -12336,39 +12535,6 @@ function writeToDirectiveInput(def, instance, publicName, privateName, flags, va
     }
 }
 
-function createLView(parentLView, tView, context, flags, host, tHostNode, environment, renderer, injector, embeddedViewInjector, hydrationInfo) {
-    const lView = tView.blueprint.slice();
-    lView[HOST] = host;
-    lView[FLAGS] =
-        flags |
-            4 /* LViewFlags.CreationMode */ |
-            128 /* LViewFlags.Attached */ |
-            8 /* LViewFlags.FirstLViewPass */ |
-            64 /* LViewFlags.Dirty */ |
-            1024 /* LViewFlags.RefreshView */;
-    if (embeddedViewInjector !== null ||
-        (parentLView && parentLView[FLAGS] & 2048 /* LViewFlags.HasEmbeddedViewInjector */)) {
-        lView[FLAGS] |= 2048 /* LViewFlags.HasEmbeddedViewInjector */;
-    }
-    resetPreOrderHookFlags(lView);
-    ngDevMode && tView.declTNode && parentLView && assertTNodeForLView(tView.declTNode, parentLView);
-    lView[PARENT] = lView[DECLARATION_VIEW] = parentLView;
-    lView[CONTEXT] = context;
-    lView[ENVIRONMENT] = (environment || (parentLView && parentLView[ENVIRONMENT]));
-    ngDevMode && assertDefined(lView[ENVIRONMENT], 'LViewEnvironment is required');
-    lView[RENDERER] = (renderer || (parentLView && parentLView[RENDERER]));
-    ngDevMode && assertDefined(lView[RENDERER], 'Renderer is required');
-    lView[INJECTOR] = injector || (parentLView && parentLView[INJECTOR]) || null;
-    lView[T_HOST] = tHostNode;
-    lView[ID] = getUniqueLViewId();
-    lView[HYDRATION] = hydrationInfo;
-    lView[EMBEDDED_VIEW_INJECTOR] = embeddedViewInjector;
-    ngDevMode &&
-        assertEqual(tView.type == 2 /* TViewType.Embedded */ ? parentLView !== null : true, true, 'Embedded views must have parentLView');
-    lView[DECLARATION_COMPONENT_VIEW] =
-        tView.type == 2 /* TViewType.Embedded */ ? parentLView[DECLARATION_COMPONENT_VIEW] : lView;
-    return lView;
-}
 function executeTemplate(tView, lView, templateFn, rf, context) {
     const prevSelectedIndex = getSelectedIndex();
     const isUpdatePhase = rf & 2 /* RenderFlags.Update */;
@@ -12393,15 +12559,6 @@ function executeTemplate(tView, lView, templateFn, rf, context) {
         profiler(postHookType, context);
     }
 }
-/**
- * Creates directive instances.
- */
-function createDirectivesInstancesInInstruction(tView, lView, tNode) {
-    if (!getBindingsEnabled())
-        return;
-    attachPatchData(getNativeByTNode(tNode, lView), lView);
-    createDirectivesInstances(tView, lView, tNode);
-}
 /**
  * Creates directive instances.
  */
@@ -12428,95 +12585,6 @@ function saveResolvedLocalsInData(viewData, tNode, localRefExtractor = getNative
         }
     }
 }
-/**
- * Gets TView from a template function or creates a new TView
- * if it doesn't already exist.
- *
- * @param def ComponentDef
- * @returns TView
- */
-function getOrCreateComponentTView(def) {
-    const tView = def.tView;
-    // Create a TView if there isn't one, or recreate it if the first create pass didn't
-    // complete successfully since we can't know for sure whether it's in a usable shape.
-    if (tView === null || tView.incompleteFirstPass) {
-        // Declaration node here is null since this function is called when we dynamically create a
-        // component and hence there is no declaration.
-        const declTNode = null;
-        return (def.tView = createTView(1 /* TViewType.Component */, declTNode, def.template, def.decls, def.vars, def.directiveDefs, def.pipeDefs, def.viewQuery, def.schemas, def.consts, def.id));
-    }
-    return tView;
-}
-/**
- * Creates a TView instance
- *
- * @param type Type of `TView`.
- * @param declTNode Declaration location of this `TView`.
- * @param templateFn Template function
- * @param decls The number of nodes, local refs, and pipes in this template
- * @param directives Registry of directives for this view
- * @param pipes Registry of pipes for this view
- * @param viewQuery View queries for this view
- * @param schemas Schemas for this view
- * @param consts Constants for this view
- */
-function createTView(type, declTNode, templateFn, decls, vars, directives, pipes, viewQuery, schemas, constsOrFactory, ssrId) {
-    ngDevMode && ngDevMode.tView++;
-    const bindingStartIndex = HEADER_OFFSET + decls;
-    // This length does not yet contain host bindings from child directives because at this point,
-    // we don't know which directives are active on this template. As soon as a directive is matched
-    // that has a host binding, we will update the blueprint with that def's hostVars count.
-    const initialViewLength = bindingStartIndex + vars;
-    const blueprint = createViewBlueprint(bindingStartIndex, initialViewLength);
-    const consts = typeof constsOrFactory === 'function' ? constsOrFactory() : constsOrFactory;
-    const tView = (blueprint[TVIEW] = {
-        type: type,
-        blueprint: blueprint,
-        template: templateFn,
-        queries: null,
-        viewQuery: viewQuery,
-        declTNode: declTNode,
-        data: blueprint.slice().fill(null, bindingStartIndex),
-        bindingStartIndex: bindingStartIndex,
-        expandoStartIndex: initialViewLength,
-        hostBindingOpCodes: null,
-        firstCreatePass: true,
-        firstUpdatePass: true,
-        staticViewQueries: false,
-        staticContentQueries: false,
-        preOrderHooks: null,
-        preOrderCheckHooks: null,
-        contentHooks: null,
-        contentCheckHooks: null,
-        viewHooks: null,
-        viewCheckHooks: null,
-        destroyHooks: null,
-        cleanup: null,
-        contentQueries: null,
-        components: null,
-        directiveRegistry: typeof directives === 'function' ? directives() : directives,
-        pipeRegistry: typeof pipes === 'function' ? pipes() : pipes,
-        firstChild: null,
-        schemas: schemas,
-        consts: consts,
-        incompleteFirstPass: false,
-        ssrId,
-    });
-    if (ngDevMode) {
-        // For performance reasons it is important that the tView retains the same shape during runtime.
-        // (To make sure that all of the code is monomorphic.) For this reason we seal the object to
-        // prevent class transitions.
-        Object.seal(tView);
-    }
-    return tView;
-}
-function createViewBlueprint(bindingStartIndex, initialViewLength) {
-    const blueprint = [];
-    for (let i = 0; i < initialViewLength; i++) {
-        blueprint.push(i < bindingStartIndex ? null : NO_CHANGE);
-    }
-    return blueprint;
-}
 /**
  * Locates the host native element, used for bootstrapping existing nodes into rendering pipeline.
  *
@@ -12608,18 +12676,16 @@ function mapPropName(name) {
 }
 function elementPropertyInternal(tView, tNode, lView, propName, value, renderer, sanitizer, nativeOnly) {
     ngDevMode && assertNotSame(value, NO_CHANGE, 'Incoming value should never be NO_CHANGE.');
-    const element = getNativeByTNode(tNode, lView);
-    let inputData = tNode.inputs;
-    let dataValue;
-    if (!nativeOnly && inputData != null && (dataValue = inputData[propName])) {
-        setInputsForProperty(tView, lView, dataValue, propName, value);
-        if (isComponentHost(tNode))
-            markDirtyIfOnPush(lView, tNode.index);
-        if (ngDevMode) {
-            setNgReflectProperties(lView, element, tNode.type, dataValue, value);
+    if (!nativeOnly) {
+        const hasSetInput = setAllInputsForProperty(tNode, tView, lView, propName, value);
+        if (hasSetInput) {
+            isComponentHost(tNode) && markDirtyIfOnPush(lView, tNode.index);
+            ngDevMode && setNgReflectProperties(lView, tView, tNode, propName, value);
+            return; // Stop propcessing if we've matched at least one input.
         }
     }
-    else if (tNode.type & 3 /* TNodeType.AnyRNode */) {
+    if (tNode.type & 3 /* TNodeType.AnyRNode */) {
+        const element = getNativeByTNode(tNode, lView);
         propName = mapPropName(propName);
         if (ngDevMode) {
             validateAgainstEventProperties(propName);
@@ -12649,11 +12715,12 @@ function markDirtyIfOnPush(lView, viewIndex) {
         childComponentLView[FLAGS] |= 64 /* LViewFlags.Dirty */;
     }
 }
-function setNgReflectProperty(lView, element, type, attrName, value) {
+function setNgReflectProperty(lView, tNode, attrName, value) {
+    const element = getNativeByTNode(tNode, lView);
     const renderer = lView[RENDERER];
     attrName = normalizeDebugBindingName(attrName);
     const debugValue = normalizeDebugBindingValue(value);
-    if (type & 3 /* TNodeType.AnyRNode */) {
+    if (tNode.type & 3 /* TNodeType.AnyRNode */) {
         if (value == null) {
             renderer.removeAttribute(element, attrName);
         }
@@ -12666,18 +12733,25 @@ function setNgReflectProperty(lView, element, type, attrName, value) {
         renderer.setValue(element, textContent);
     }
 }
-function setNgReflectProperties(lView, element, type, dataValue, value) {
-    if (type & (3 /* TNodeType.AnyRNode */ | 4 /* TNodeType.Container */)) {
-        /**
-         * dataValue is an array containing runtime input or output names for the directives:
-         * i+0: directive instance index
-         * i+1: privateName
-         *
-         * e.g. [0, 'change', 'change-minified']
-         * we want to set the reflected property with the privateName: dataValue[i+1]
-         */
-        for (let i = 0; i < dataValue.length; i += 3) {
-            setNgReflectProperty(lView, element, type, dataValue[i + 1], value);
+function setNgReflectProperties(lView, tView, tNode, publicName, value) {
+    if (!(tNode.type & (3 /* TNodeType.AnyRNode */ | 4 /* TNodeType.Container */))) {
+        return;
+    }
+    const inputConfig = tNode.inputs?.[publicName];
+    const hostInputConfig = tNode.hostDirectiveInputs?.[publicName];
+    if (hostInputConfig) {
+        for (let i = 0; i < hostInputConfig.length; i += 2) {
+            const index = hostInputConfig[i];
+            const publicName = hostInputConfig[i + 1];
+            const def = tView.data[index];
+            setNgReflectProperty(lView, tNode, def.inputs[publicName][0], value);
+        }
+    }
+    // Note: we set the private name of the input as the reflected property, not the public one.
+    if (inputConfig) {
+        for (const index of inputConfig) {
+            const def = tView.data[index];
+            setNgReflectProperty(lView, tNode, def.inputs[publicName][0], value);
         }
     }
 }
@@ -12774,31 +12848,6 @@ function findDirectiveDefMatches(tView, tNode) {
     }
     return matches;
 }
-/**
- * Gets the initial set of LView flags based on the component definition that the LView represents.
- * @param def Component definition from which to determine the flags.
- */
-function getInitialLViewFlagsFromDef(def) {
-    let flags = 16 /* LViewFlags.CheckAlways */;
-    if (def.signals) {
-        flags = 4096 /* LViewFlags.SignalView */;
-    }
-    else if (def.onPush) {
-        flags = 64 /* LViewFlags.Dirty */;
-    }
-    return flags;
-}
-function createComponentLView(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
-    // accessed through their containers because they may be removed / re-added later.
-    const rendererFactory = lView[ENVIRONMENT].rendererFactory;
-    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);
-}
 function elementAttributeInternal(tNode, lView, name, value, sanitizer, namespace) {
     if (ngDevMode) {
         assertNotSame(value, NO_CHANGE, 'Incoming value should never be NO_CHANGE.');
@@ -12832,75 +12881,16 @@ function setElementAttribute(renderer, element, namespace, tagName, name, value,
 function setInputsFromAttrs(lView, directiveIndex, instance, def, tNode, initialInputData) {
     const initialInputs = initialInputData[directiveIndex];
     if (initialInputs !== null) {
-        for (let i = 0; i < initialInputs.length;) {
-            const publicName = initialInputs[i++];
-            const privateName = initialInputs[i++];
-            const flags = initialInputs[i++];
-            const value = initialInputs[i++];
-            writeToDirectiveInput(def, instance, publicName, privateName, flags, value);
+        for (let i = 0; i < initialInputs.length; i += 2) {
+            const lookupName = initialInputs[i];
+            const value = initialInputs[i + 1];
+            writeToDirectiveInput(def, instance, lookupName, value);
             if (ngDevMode) {
-                const nativeElement = getNativeByTNode(tNode, lView);
-                setNgReflectProperty(lView, nativeElement, tNode.type, privateName, value);
+                setNgReflectProperty(lView, tNode, def.inputs[lookupName][0], value);
             }
         }
     }
 }
-//////////////////////////
-//// ViewContainer & View
-//////////////////////////
-/**
- * Creates a LContainer, either from a container instruction, or for a ViewContainerRef.
- *
- * @param hostNative The host element for the LContainer
- * @param hostTNode The host TNode for the LContainer
- * @param currentView The parent view of the LContainer
- * @param native The native comment element
- * @param isForViewContainerRef Optional a flag indicating the ViewContainerRef case
- * @returns LContainer
- */
-function createLContainer(hostNative, currentView, native, tNode) {
-    ngDevMode && assertLView(currentView);
-    const lContainer = [
-        hostNative, // host native
-        true, // Boolean `true` in this position signifies that this is an `LContainer`
-        0, // flags
-        currentView, // parent
-        null, // next
-        tNode, // t_host
-        null, // dehydrated views
-        native, // native,
-        null, // view refs
-        null, // moved views
-    ];
-    ngDevMode &&
-        assertEqual(lContainer.length, CONTAINER_HEADER_OFFSET, 'Should allocate correct number of slots for LContainer header.');
-    return lContainer;
-}
-/**
- * Adds LView or LContainer to the end of the current view tree.
- *
- * This structure will be used to traverse through nested views to remove listeners
- * and call onDestroy callbacks.
- *
- * @param lView The view where LView or LContainer should be added
- * @param adjustedHostIndex Index of the view's host node in LView[], adjusted for header
- * @param lViewOrLContainer The LView or LContainer to add to the view tree
- * @returns The state passed in
- */
-function addToEndOfViewTree(lView, lViewOrLContainer) {
-    // TODO(benlesh/misko): This implementation is incorrect, because it always adds the LContainer
-    // to the end of the queue, which means if the developer retrieves the LContainers from RNodes out
-    // of order, the change detection will run out of order, as the act of retrieving the the
-    // LContainer from the RNode is what adds it to the queue.
-    if (lView[CHILD_HEAD]) {
-        lView[CHILD_TAIL][NEXT] = lViewOrLContainer;
-    }
-    else {
-        lView[CHILD_HEAD] = lViewOrLContainer;
-    }
-    lView[CHILD_TAIL] = lViewOrLContainer;
-    return lViewOrLContainer;
-}
 ///////////////////////////////
 //// Bindings & interpolations
 ///////////////////////////////
@@ -12930,7 +12920,7 @@ function storePropertyBindingMetadata(tData, tNode, propertyName, bindingIndex,
     // Since we don't have a concept of the "first update pass" we need to check for presence of the
     // binding meta-data to decide if one should be stored (or if was stored already).
     if (tData[bindingIndex] === null) {
-        if (tNode.inputs == null || !tNode.inputs[propertyName]) {
+        if (!tNode.inputs?.[propertyName] && !tNode.hostDirectiveInputs?.[propertyName]) {
             const propBindingIdxs = tNode.propertyBindings || (tNode.propertyBindings = []);
             propBindingIdxs.push(bindingIndex);
             let bindingMetadata = propertyName;
@@ -12965,24 +12955,88 @@ function handleError(lView, error) {
     errorHandler && errorHandler.handleError(error);
 }
 /**
- * Set the inputs of directives at the current node to corresponding value.
+ * Set all directive inputs with the specific public name on the node.
  *
- * @param tView The current TView
- * @param lView the `LView` which contains the directives.
- * @param inputs mapping between the public "input" name and privately-known,
- *        possibly minified, property names to write to.
+ * @param tNode TNode on which the input is being set.
+ * @param tView Current TView
+ * @param lView `LView` which contains the directives.
+ * @param publicName Public name of the input being set.
+ * @param value Value to set.
+ */
+function setAllInputsForProperty(tNode, tView, lView, publicName, value) {
+    const inputs = tNode.inputs?.[publicName];
+    const hostDirectiveInputs = tNode.hostDirectiveInputs?.[publicName];
+    let hasMatch = false;
+    if (hostDirectiveInputs) {
+        for (let i = 0; i < hostDirectiveInputs.length; i += 2) {
+            const index = hostDirectiveInputs[i];
+            ngDevMode && assertIndexInRange(lView, index);
+            const publicName = hostDirectiveInputs[i + 1];
+            const def = tView.data[index];
+            writeToDirectiveInput(def, lView[index], publicName, value);
+            hasMatch = true;
+        }
+    }
+    if (inputs) {
+        for (const index of inputs) {
+            ngDevMode && assertIndexInRange(lView, index);
+            const instance = lView[index];
+            const def = tView.data[index];
+            writeToDirectiveInput(def, instance, publicName, value);
+            hasMatch = true;
+        }
+    }
+    return hasMatch;
+}
+/**
+ * Sets an input value only on a specific directive and its host directives.
+ * @param tNode TNode on which the input is being set.
+ * @param tView Current TView
+ * @param lView `LView` which contains the directives.
+ * @param target Directive on which to set the input.
+ * @param publicName Public name of the input being set.
  * @param value Value to set.
  */
-function setInputsForProperty(tView, lView, inputs, publicName, value) {
-    for (let i = 0; i < inputs.length;) {
-        const index = inputs[i++];
-        const privateName = inputs[i++];
-        const flags = inputs[i++];
-        const instance = lView[index];
-        ngDevMode && assertIndexInRange(lView, index);
-        const def = tView.data[index];
-        writeToDirectiveInput(def, instance, publicName, privateName, flags, value);
+function setDirectiveInput(tNode, tView, lView, target, publicName, value) {
+    let hostIndex = null;
+    let hostDirectivesStart = null;
+    let hostDirectivesEnd = null;
+    let hasSet = false;
+    if (ngDevMode && !tNode.directiveToIndex?.has(target.type)) {
+        throw new Error(`Node does not have a directive with type ${target.type.name}`);
+    }
+    const data = tNode.directiveToIndex.get(target.type);
+    if (typeof data === 'number') {
+        hostIndex = data;
+    }
+    else {
+        [hostIndex, hostDirectivesStart, hostDirectivesEnd] = data;
+    }
+    if (hostDirectivesStart !== null &&
+        hostDirectivesEnd !== null &&
+        tNode.hostDirectiveInputs?.hasOwnProperty(publicName)) {
+        const hostDirectiveInputs = tNode.hostDirectiveInputs[publicName];
+        for (let i = 0; i < hostDirectiveInputs.length; i += 2) {
+            const index = hostDirectiveInputs[i];
+            if (index >= hostDirectivesStart && index <= hostDirectivesEnd) {
+                ngDevMode && assertIndexInRange(lView, index);
+                const def = tView.data[index];
+                const hostDirectivePublicName = hostDirectiveInputs[i + 1];
+                writeToDirectiveInput(def, lView[index], hostDirectivePublicName, value);
+                hasSet = true;
+            }
+            else if (index > hostDirectivesEnd) {
+                // Directives here are in ascending order so we can stop looking once we're past the range.
+                break;
+            }
+        }
+    }
+    if (hostIndex !== null) {
+        ngDevMode && assertIndexInRange(lView, hostIndex);
+        writeToDirectiveInput(target, lView[hostIndex], publicName, value);
+        hasSet = true;
     }
+    return hasSet;
 }
 
 function renderComponent(hostLView, componentHostIdx) {
@@ -13103,24 +13157,41 @@ function renderChildComponents(hostLView, components) {
     }
 }
 
+function createAndRenderEmbeddedLView(declarationLView, templateTNode, context, options) {
+    const prevConsumer = setActiveConsumer$1(null);
+    try {
+        const embeddedTView = templateTNode.tView;
+        ngDevMode && assertDefined(embeddedTView, 'TView must be defined for a template node.');
+        ngDevMode && assertTNodeForLView(templateTNode, declarationLView);
+        // Embedded views follow the change detection strategy of the view they're declared in.
+        const isSignalView = declarationLView[FLAGS] & 4096 /* LViewFlags.SignalView */;
+        const viewFlags = isSignalView ? 4096 /* LViewFlags.SignalView */ : 16 /* LViewFlags.CheckAlways */;
+        const embeddedLView = createLView(declarationLView, embeddedTView, context, viewFlags, null, templateTNode, null, null, options?.injector ?? null, options?.embeddedViewInjector ?? null, options?.dehydratedView ?? null);
+        const declarationLContainer = declarationLView[templateTNode.index];
+        ngDevMode && assertLContainer(declarationLContainer);
+        embeddedLView[DECLARATION_LCONTAINER] = declarationLContainer;
+        const declarationViewLQueries = declarationLView[QUERIES];
+        if (declarationViewLQueries !== null) {
+            embeddedLView[QUERIES] = declarationViewLQueries.createEmbeddedView(embeddedTView);
+        }
+        // execute creation mode of a view
+        renderView(embeddedTView, embeddedLView, context);
+        return embeddedLView;
+    }
+    finally {
+        setActiveConsumer$1(prevConsumer);
+    }
+}
 /**
- * Flags for renderer-specific style modifiers.
- * @publicApi
+ * Returns whether an elements that belong to a view should be
+ * inserted into the DOM. For client-only cases, DOM elements are
+ * always inserted. For hydration cases, we check whether serialized
+ * info is available for a view and the view is not in a "skip hydration"
+ * block (in which case view contents was re-created, thus needing insertion).
  */
-var RendererStyleFlags2;
-(function (RendererStyleFlags2) {
-    // TODO(misko): This needs to be refactored into a separate file so that it can be imported from
-    // `node_manipulation.ts` Currently doing the import cause resolution order to change and fails
-    // the tests. The work around is to have hard coded value in `node_manipulation.ts` for now.
-    /**
-     * Marks a style as important.
-     */
-    RendererStyleFlags2[RendererStyleFlags2["Important"] = 1] = "Important";
-    /**
-     * Marks a style as using dash case naming (this-is-dash-case).
-     */
-    RendererStyleFlags2[RendererStyleFlags2["DashCase"] = 2] = "DashCase";
-})(RendererStyleFlags2 || (RendererStyleFlags2 = {}));
+function shouldAddViewToDom(tNode, dehydratedView) {
+    return (!dehydratedView || dehydratedView.firstChild === null || hasInSkipHydrationBlockFlag(tNode));
+}
 
 let _icuContainerIterate;
 /**
@@ -13143,6 +13214,25 @@ function ensureIcuContainerVisitorLoaded(loader) {
     }
 }
 
+/**
+ * Flags for renderer-specific style modifiers.
+ * @publicApi
+ */
+var RendererStyleFlags2;
+(function (RendererStyleFlags2) {
+    // TODO(misko): This needs to be refactored into a separate file so that it can be imported from
+    // `node_manipulation.ts` Currently doing the import cause resolution order to change and fails
+    // the tests. The work around is to have hard coded value in `node_manipulation.ts` for now.
+    /**
+     * Marks a style as important.
+     */
+    RendererStyleFlags2[RendererStyleFlags2["Important"] = 1] = "Important";
+    /**
+     * Marks a style as using dash case naming (this-is-dash-case).
+     */
+    RendererStyleFlags2[RendererStyleFlags2["DashCase"] = 2] = "DashCase";
+})(RendererStyleFlags2 || (RendererStyleFlags2 = {}));
+
 /**
  * Checks whether a TNode is considered detached, i.e. not present in the
  * translated i18n template. We should not attempt hydration for such nodes
@@ -13297,83 +13387,6 @@ function destroyViewTree(rootView) {
         lViewOrLContainer = next;
     }
 }
-/**
- * Inserts a view into a container.
- *
- * This adds the view to the container's array of active views in the correct
- * position. It also adds the view's elements to the DOM if the container isn't a
- * root node of another view (in that case, the view's elements will be added when
- * the container's parent view is added later).
- *
- * @param tView The `TView' of the `LView` to insert
- * @param lView The view to insert
- * @param lContainer The container into which the view should be inserted
- * @param index Which index in the container to insert the child view into
- */
-function insertView(tView, lView, lContainer, index) {
-    ngDevMode && assertLView(lView);
-    ngDevMode && assertLContainer(lContainer);
-    const indexInContainer = CONTAINER_HEADER_OFFSET + index;
-    const containerLength = lContainer.length;
-    if (index > 0) {
-        // This is a new view, we need to add it to the children.
-        lContainer[indexInContainer - 1][NEXT] = lView;
-    }
-    if (index < containerLength - CONTAINER_HEADER_OFFSET) {
-        lView[NEXT] = lContainer[indexInContainer];
-        addToArray(lContainer, CONTAINER_HEADER_OFFSET + index, lView);
-    }
-    else {
-        lContainer.push(lView);
-        lView[NEXT] = null;
-    }
-    lView[PARENT] = lContainer;
-    // track views where declaration and insertion points are different
-    const declarationLContainer = lView[DECLARATION_LCONTAINER];
-    if (declarationLContainer !== null && lContainer !== declarationLContainer) {
-        trackMovedView(declarationLContainer, lView);
-    }
-    // notify query that a new view has been added
-    const lQueries = lView[QUERIES];
-    if (lQueries !== null) {
-        lQueries.insertView(tView);
-    }
-    updateAncestorTraversalFlagsOnAttach(lView);
-    // Sets the attached flag
-    lView[FLAGS] |= 128 /* LViewFlags.Attached */;
-}
-/**
- * Track views created from the declaration container (TemplateRef) and inserted into a
- * different LContainer or attached directly to ApplicationRef.
- */
-function trackMovedView(declarationContainer, lView) {
-    ngDevMode && assertDefined(lView, 'LView required');
-    ngDevMode && assertLContainer(declarationContainer);
-    const movedViews = declarationContainer[MOVED_VIEWS];
-    const parent = lView[PARENT];
-    ngDevMode && assertDefined(parent, 'missing parent');
-    if (isLView(parent)) {
-        declarationContainer[FLAGS] |= 2 /* LContainerFlags.HasTransplantedViews */;
-    }
-    else {
-        const insertedComponentLView = parent[PARENT][DECLARATION_COMPONENT_VIEW];
-        ngDevMode && assertDefined(insertedComponentLView, 'Missing insertedComponentLView');
-        const declaredComponentLView = lView[DECLARATION_COMPONENT_VIEW];
-        ngDevMode && assertDefined(declaredComponentLView, 'Missing declaredComponentLView');
-        if (declaredComponentLView !== insertedComponentLView) {
-            // At this point the declaration-component is not same as insertion-component; this means that
-            // this is a transplanted view. Mark the declared lView as having transplanted views so that
-            // those views can participate in CD.
-            declarationContainer[FLAGS] |= 2 /* LContainerFlags.HasTransplantedViews */;
-        }
-    }
-    if (movedViews === null) {
-        declarationContainer[MOVED_VIEWS] = [lView];
-    }
-    else {
-        movedViews.push(lView);
-    }
-}
 function detachMovedView(declarationContainer, lView) {
     ngDevMode && assertLContainer(declarationContainer);
     ngDevMode &&
@@ -13382,43 +13395,6 @@ function detachMovedView(declarationContainer, lView) {
     const declarationViewIndex = movedViews.indexOf(lView);
     movedViews.splice(declarationViewIndex, 1);
 }
-/**
- * Detaches a view from a container.
- *
- * This method removes the view from the container's array of active views. It also
- * removes the view's elements from the DOM.
- *
- * @param lContainer The container from which to detach a view
- * @param removeIndex The index of the view to detach
- * @returns Detached LView instance.
- */
-function detachView(lContainer, removeIndex) {
-    if (lContainer.length <= CONTAINER_HEADER_OFFSET)
-        return;
-    const indexInContainer = CONTAINER_HEADER_OFFSET + removeIndex;
-    const viewToDetach = lContainer[indexInContainer];
-    if (viewToDetach) {
-        const declarationLContainer = viewToDetach[DECLARATION_LCONTAINER];
-        if (declarationLContainer !== null && declarationLContainer !== lContainer) {
-            detachMovedView(declarationLContainer, viewToDetach);
-        }
-        if (removeIndex > 0) {
-            lContainer[indexInContainer - 1][NEXT] = viewToDetach[NEXT];
-        }
-        const removedLView = removeFromArray(lContainer, CONTAINER_HEADER_OFFSET + removeIndex);
-        removeViewFromDOM(viewToDetach[TVIEW], viewToDetach);
-        // notify query that a view has been removed
-        const lQueries = removedLView[QUERIES];
-        if (lQueries !== null) {
-            lQueries.detachView(removedLView[TVIEW]);
-        }
-        viewToDetach[PARENT] = null;
-        viewToDetach[NEXT] = null;
-        // Unsets the attached flag
-        viewToDetach[FLAGS] &= ~128 /* LViewFlags.Attached */;
-    }
-    return viewToDetach;
-}
 /**
  * A standalone function which destroys an LView,
  * conducting clean up (e.g. removing listeners, calling onDestroys).
@@ -13985,80 +13961,6 @@ function applyStyling(renderer, isClassBased, rNode, prop, value) {
     }
 }
 
-function createAndRenderEmbeddedLView(declarationLView, templateTNode, context, options) {
-    const prevConsumer = setActiveConsumer$1(null);
-    try {
-        const embeddedTView = templateTNode.tView;
-        ngDevMode && assertDefined(embeddedTView, 'TView must be defined for a template node.');
-        ngDevMode && assertTNodeForLView(templateTNode, declarationLView);
-        // Embedded views follow the change detection strategy of the view they're declared in.
-        const isSignalView = declarationLView[FLAGS] & 4096 /* LViewFlags.SignalView */;
-        const viewFlags = isSignalView ? 4096 /* LViewFlags.SignalView */ : 16 /* LViewFlags.CheckAlways */;
-        const embeddedLView = createLView(declarationLView, embeddedTView, context, viewFlags, null, templateTNode, null, null, options?.injector ?? null, options?.embeddedViewInjector ?? null, options?.dehydratedView ?? null);
-        const declarationLContainer = declarationLView[templateTNode.index];
-        ngDevMode && assertLContainer(declarationLContainer);
-        embeddedLView[DECLARATION_LCONTAINER] = declarationLContainer;
-        const declarationViewLQueries = declarationLView[QUERIES];
-        if (declarationViewLQueries !== null) {
-            embeddedLView[QUERIES] = declarationViewLQueries.createEmbeddedView(embeddedTView);
-        }
-        // execute creation mode of a view
-        renderView(embeddedTView, embeddedLView, context);
-        return embeddedLView;
-    }
-    finally {
-        setActiveConsumer$1(prevConsumer);
-    }
-}
-function getLViewFromLContainer(lContainer, index) {
-    const adjustedIndex = CONTAINER_HEADER_OFFSET + index;
-    // avoid reading past the array boundaries
-    if (adjustedIndex < lContainer.length) {
-        const lView = lContainer[adjustedIndex];
-        ngDevMode && assertLView(lView);
-        return lView;
-    }
-    return undefined;
-}
-/**
- * Returns whether an elements that belong to a view should be
- * inserted into the DOM. For client-only cases, DOM elements are
- * always inserted. For hydration cases, we check whether serialized
- * info is available for a view and the view is not in a "skip hydration"
- * block (in which case view contents was re-created, thus needing insertion).
- */
-function shouldAddViewToDom(tNode, dehydratedView) {
-    return (!dehydratedView || dehydratedView.firstChild === null || hasInSkipHydrationBlockFlag(tNode));
-}
-function addLViewToLContainer(lContainer, lView, index, addToDOM = true) {
-    const tView = lView[TVIEW];
-    // Insert into the view tree so the new view can be change-detected
-    insertView(tView, lView, lContainer, index);
-    // Insert elements that belong to this view into the DOM tree
-    if (addToDOM) {
-        const beforeNode = getBeforeNodeForView(index, lContainer);
-        const renderer = lView[RENDERER];
-        const parentRNode = renderer.parentNode(lContainer[NATIVE]);
-        if (parentRNode !== null) {
-            addViewToDOM(tView, lContainer[T_HOST], renderer, lView, parentRNode, beforeNode);
-        }
-    }
-    // When in hydration mode, reset the pointer to the first child in
-    // the dehydrated view. This indicates that the view was hydrated and
-    // further attaching/detaching should work with this view as normal.
-    const hydrationInfo = lView[HYDRATION];
-    if (hydrationInfo !== null && hydrationInfo.firstChild !== null) {
-        hydrationInfo.firstChild = null;
-    }
-}
-function removeLViewFromLContainer(lContainer, index) {
-    const lView = detachView(lContainer, index);
-    if (lView !== undefined) {
-        destroyLView(lView[TVIEW], lView);
-    }
-    return lView;
-}
-
 function collectNativeNodes(tView, lView, tNode, result, isProjection = false) {
     while (tNode !== null) {
         // Let declarations don't have corresponding DOM nodes so we skip over them.
@@ -14697,6 +14599,187 @@ function markViewDirty(lView, source) {
     return null;
 }
 
+/**
+ * Creates a LContainer, either from a container instruction, or for a ViewContainerRef.
+ *
+ * @param hostNative The host element for the LContainer
+ * @param hostTNode The host TNode for the LContainer
+ * @param currentView The parent view of the LContainer
+ * @param native The native comment element
+ * @param isForViewContainerRef Optional a flag indicating the ViewContainerRef case
+ * @returns LContainer
+ */
+function createLContainer(hostNative, currentView, native, tNode) {
+    ngDevMode && assertLView(currentView);
+    const lContainer = [
+        hostNative, // host native
+        true, // Boolean `true` in this position signifies that this is an `LContainer`
+        0, // flags
+        currentView, // parent
+        null, // next
+        tNode, // t_host
+        null, // dehydrated views
+        native, // native,
+        null, // view refs
+        null, // moved views
+    ];
+    ngDevMode &&
+        assertEqual(lContainer.length, CONTAINER_HEADER_OFFSET, 'Should allocate correct number of slots for LContainer header.');
+    return lContainer;
+}
+function getLViewFromLContainer(lContainer, index) {
+    const adjustedIndex = CONTAINER_HEADER_OFFSET + index;
+    // avoid reading past the array boundaries
+    if (adjustedIndex < lContainer.length) {
+        const lView = lContainer[adjustedIndex];
+        ngDevMode && assertLView(lView);
+        return lView;
+    }
+    return undefined;
+}
+function addLViewToLContainer(lContainer, lView, index, addToDOM = true) {
+    const tView = lView[TVIEW];
+    // Insert into the view tree so the new view can be change-detected
+    insertView(tView, lView, lContainer, index);
+    // Insert elements that belong to this view into the DOM tree
+    if (addToDOM) {
+        const beforeNode = getBeforeNodeForView(index, lContainer);
+        const renderer = lView[RENDERER];
+        const parentRNode = renderer.parentNode(lContainer[NATIVE]);
+        if (parentRNode !== null) {
+            addViewToDOM(tView, lContainer[T_HOST], renderer, lView, parentRNode, beforeNode);
+        }
+    }
+    // When in hydration mode, reset the pointer to the first child in
+    // the dehydrated view. This indicates that the view was hydrated and
+    // further attaching/detaching should work with this view as normal.
+    const hydrationInfo = lView[HYDRATION];
+    if (hydrationInfo !== null && hydrationInfo.firstChild !== null) {
+        hydrationInfo.firstChild = null;
+    }
+}
+function removeLViewFromLContainer(lContainer, index) {
+    const lView = detachView(lContainer, index);
+    if (lView !== undefined) {
+        destroyLView(lView[TVIEW], lView);
+    }
+    return lView;
+}
+/**
+ * Detaches a view from a container.
+ *
+ * This method removes the view from the container's array of active views. It also
+ * removes the view's elements from the DOM.
+ *
+ * @param lContainer The container from which to detach a view
+ * @param removeIndex The index of the view to detach
+ * @returns Detached LView instance.
+ */
+function detachView(lContainer, removeIndex) {
+    if (lContainer.length <= CONTAINER_HEADER_OFFSET)
+        return;
+    const indexInContainer = CONTAINER_HEADER_OFFSET + removeIndex;
+    const viewToDetach = lContainer[indexInContainer];
+    if (viewToDetach) {
+        const declarationLContainer = viewToDetach[DECLARATION_LCONTAINER];
+        if (declarationLContainer !== null && declarationLContainer !== lContainer) {
+            detachMovedView(declarationLContainer, viewToDetach);
+        }
+        if (removeIndex > 0) {
+            lContainer[indexInContainer - 1][NEXT] = viewToDetach[NEXT];
+        }
+        const removedLView = removeFromArray(lContainer, CONTAINER_HEADER_OFFSET + removeIndex);
+        removeViewFromDOM(viewToDetach[TVIEW], viewToDetach);
+        // notify query that a view has been removed
+        const lQueries = removedLView[QUERIES];
+        if (lQueries !== null) {
+            lQueries.detachView(removedLView[TVIEW]);
+        }
+        viewToDetach[PARENT] = null;
+        viewToDetach[NEXT] = null;
+        // Unsets the attached flag
+        viewToDetach[FLAGS] &= ~128 /* LViewFlags.Attached */;
+    }
+    return viewToDetach;
+}
+/**
+ * Inserts a view into a container.
+ *
+ * This adds the view to the container's array of active views in the correct
+ * position. It also adds the view's elements to the DOM if the container isn't a
+ * root node of another view (in that case, the view's elements will be added when
+ * the container's parent view is added later).
+ *
+ * @param tView The `TView' of the `LView` to insert
+ * @param lView The view to insert
+ * @param lContainer The container into which the view should be inserted
+ * @param index Which index in the container to insert the child view into
+ */
+function insertView(tView, lView, lContainer, index) {
+    ngDevMode && assertLView(lView);
+    ngDevMode && assertLContainer(lContainer);
+    const indexInContainer = CONTAINER_HEADER_OFFSET + index;
+    const containerLength = lContainer.length;
+    if (index > 0) {
+        // This is a new view, we need to add it to the children.
+        lContainer[indexInContainer - 1][NEXT] = lView;
+    }
+    if (index < containerLength - CONTAINER_HEADER_OFFSET) {
+        lView[NEXT] = lContainer[indexInContainer];
+        addToArray(lContainer, CONTAINER_HEADER_OFFSET + index, lView);
+    }
+    else {
+        lContainer.push(lView);
+        lView[NEXT] = null;
+    }
+    lView[PARENT] = lContainer;
+    // track views where declaration and insertion points are different
+    const declarationLContainer = lView[DECLARATION_LCONTAINER];
+    if (declarationLContainer !== null && lContainer !== declarationLContainer) {
+        trackMovedView(declarationLContainer, lView);
+    }
+    // notify query that a new view has been added
+    const lQueries = lView[QUERIES];
+    if (lQueries !== null) {
+        lQueries.insertView(tView);
+    }
+    updateAncestorTraversalFlagsOnAttach(lView);
+    // Sets the attached flag
+    lView[FLAGS] |= 128 /* LViewFlags.Attached */;
+}
+/**
+ * Track views created from the declaration container (TemplateRef) and inserted into a
+ * different LContainer or attached directly to ApplicationRef.
+ */
+function trackMovedView(declarationContainer, lView) {
+    ngDevMode && assertDefined(lView, 'LView required');
+    ngDevMode && assertLContainer(declarationContainer);
+    const movedViews = declarationContainer[MOVED_VIEWS];
+    const parent = lView[PARENT];
+    ngDevMode && assertDefined(parent, 'missing parent');
+    if (isLView(parent)) {
+        declarationContainer[FLAGS] |= 2 /* LContainerFlags.HasTransplantedViews */;
+    }
+    else {
+        const insertedComponentLView = parent[PARENT][DECLARATION_COMPONENT_VIEW];
+        ngDevMode && assertDefined(insertedComponentLView, 'Missing insertedComponentLView');
+        const declaredComponentLView = lView[DECLARATION_COMPONENT_VIEW];
+        ngDevMode && assertDefined(declaredComponentLView, 'Missing declaredComponentLView');
+        if (declaredComponentLView !== insertedComponentLView) {
+            // At this point the declaration-component is not same as insertion-component; this means that
+            // this is a transplanted view. Mark the declared lView as having transplanted views so that
+            // those views can participate in CD.
+            declarationContainer[FLAGS] |= 2 /* LContainerFlags.HasTransplantedViews */;
+        }
+    }
+    if (movedViews === null) {
+        declarationContainer[MOVED_VIEWS] = [lView];
+    }
+    else {
+        movedViews.push(lView);
+    }
+}
+
 class ViewRef$1 {
     _lView;
     _cdRefInjectingView;
@@ -15606,9 +15689,12 @@ function createTNode(tView, tParent, type, index, value, attrs) {
         attrs: attrs,
         mergedAttrs: null,
         localNames: null,
-        initialInputs: undefined,
+        initialInputs: null,
         inputs: null,
+        hostDirectiveInputs: null,
         outputs: null,
+        hostDirectiveOutputs: null,
+        directiveToIndex: null,
         tView: null,
         next: null,
         prev: null,
@@ -15916,7 +16002,7 @@ function createIcuIterator(tIcu, lView) {
  *  - the `b` char which indicates that the lookup should start from the `document.body`
  *  - the `h` char to start lookup from the component host node (`lView[HOST]`)
  */
-const REF_EXTRACTOR_REGEXP = new RegExp(`^(\\d+)*(${REFERENCE_NODE_BODY}|${REFERENCE_NODE_HOST})*(.*)`);
+const REF_EXTRACTOR_REGEXP = /* @__PURE__ */ new RegExp(`^(\\d+)*(${REFERENCE_NODE_BODY}|${REFERENCE_NODE_HOST})*(.*)`);
 /**
  * Helper function that takes a reference node location and a set of navigation steps
  * (from the reference node) to a target node and outputs a string that represents
@@ -16796,6 +16882,18 @@ function removeDehydratedViews(lContainer) {
     // once again in case a `ViewContainerRef` is created later).
     lContainer[DEHYDRATED_VIEWS] = retainedViews;
 }
+function removeDehydratedViewList(deferBlock) {
+    const { lContainer } = deferBlock;
+    const dehydratedViews = lContainer[DEHYDRATED_VIEWS];
+    if (dehydratedViews === null)
+        return;
+    const parentLView = lContainer[PARENT];
+    const renderer = parentLView[RENDERER];
+    for (const view of dehydratedViews) {
+        removeDehydratedView(view, renderer);
+        ngDevMode && ngDevMode.dehydratedViewsRemoved++;
+    }
+}
 /**
  * Helper function to remove all nodes from a dehydrated view.
  */
@@ -17431,46 +17529,26 @@ function ɵɵinvalidFactory() {
     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.
+    // 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);
+        let directiveDefs;
+        let hostDirectiveDefs = null;
+        let hostDirectiveRanges = null;
+        const hostDirectiveResolution = resolveHostDirectives(matchedDirectiveDefs);
+        if (hostDirectiveResolution === null) {
+            directiveDefs = matchedDirectiveDefs;
+        }
+        else {
+            [directiveDefs, hostDirectiveDefs, hostDirectiveRanges] = hostDirectiveResolution;
+        }
+        initializeDirectives(tView, lView, tNode, directiveDefs, exportsMap, hostDirectiveDefs, hostDirectiveRanges);
     }
     if (exportsMap !== null && localRefs !== null) {
         cacheMatchingLocalNames(tNode, localRefs, exportsMap);
@@ -17489,40 +17567,63 @@ function cacheMatchingLocalNames(tNode, localRefs, exportsMap) {
         localNames.push(localRefs[i], index);
     }
 }
-function resolveHostDirectives(tView, tNode, matches) {
-    const allDirectiveDefs = [];
+function resolveHostDirectives(matches) {
+    let componentDef = null;
+    let hasHostDirectives = false;
+    for (let i = 0; i < matches.length; i++) {
+        const def = matches[i];
+        if (i === 0 && isComponentDef(def)) {
+            componentDef = def;
+        }
+        if (def.findHostDirectiveDefs !== null) {
+            hasHostDirectives = true;
+            break;
+        }
+    }
+    if (!hasHostDirectives) {
+        return null;
+    }
+    let allDirectiveDefs = null;
     let hostDirectiveDefs = null;
+    let hostDirectiveRanges = null;
+    // 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 dir
     for (const def of matches) {
         if (def.findHostDirectiveDefs !== null) {
-            // TODO(pk): probably could return matches instead of taking in an array to fill in?
+            allDirectiveDefs ??= [];
             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);
+            hostDirectiveRanges ??= new Map();
+            resolveHostDirectivesForDef(def, allDirectiveDefs, hostDirectiveRanges, hostDirectiveDefs);
         }
-        if (isComponentDef(def)) {
+        // Component definition needs to be pushed early to maintain the correct ordering.
+        if (def === componentDef) {
+            allDirectiveDefs ??= [];
             allDirectiveDefs.push(def);
-            markAsComponentHost(tView, tNode, allDirectiveDefs.length - 1);
         }
     }
-    if (isComponentHost(tNode)) {
-        allDirectiveDefs.push(...matches.slice(1));
-    }
-    else {
-        allDirectiveDefs.push(...matches);
+    if (allDirectiveDefs !== null) {
+        allDirectiveDefs.push(...(componentDef === null ? matches : matches.slice(1)));
+        ngDevMode && assertNoDuplicateDirectives(allDirectiveDefs);
+        return [allDirectiveDefs, hostDirectiveDefs, hostDirectiveRanges];
     }
-    if (ngDevMode) {
-        assertNoDuplicateDirectives(allDirectiveDefs);
-    }
-    return [allDirectiveDefs, hostDirectiveDefs];
+    return null;
+}
+function resolveHostDirectivesForDef(def, allDirectiveDefs, hostDirectiveRanges, hostDirectiveDefs) {
+    ngDevMode && assertDefined(def.findHostDirectiveDefs, 'Expected host directive resolve function');
+    const start = allDirectiveDefs.length;
+    // TODO(pk): probably could return matches instead of taking in an array to fill in?
+    def.findHostDirectiveDefs(def, allDirectiveDefs, hostDirectiveDefs);
+    // Note that these indexes are within the offset by `directiveStart`. We can't do the
+    // offsetting here, because `directiveStart` hasn't been initialized on the TNode yet.
+    hostDirectiveRanges.set(def, [start, allDirectiveDefs.length - 1]);
 }
 /**
  * Marks a given TNode as a component's host. This consists of:
@@ -17536,37 +17637,62 @@ function markAsComponentHost(tView, hostTNode, 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) {
+function initializeDirectives(tView, lView, tNode, directives, exportsMap, hostDirectiveDefs, hostDirectiveRanges) {
     ngDevMode && assertFirstCreatePass(tView);
+    const directivesLength = directives.length;
+    let hasSeenComponent = false;
     // 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);
+    for (let i = 0; i < directivesLength; i++) {
+        const def = directives[i];
+        if (!hasSeenComponent && isComponentDef(def)) {
+            hasSeenComponent = true;
+            markAsComponentHost(tView, tNode, i);
+        }
+        diPublicInInjector(getOrCreateNodeInjectorForNode(tNode, lView), tView, def.type);
     }
-    initTNodeFlags(tNode, tView.data.length, directives.length);
+    initTNodeFlags(tNode, tView.data.length, directivesLength);
     // 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++) {
+    for (let i = 0; i < directivesLength; 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);
+    let directiveIdx = allocExpando(tView, lView, directivesLength, null);
     ngDevMode &&
         assertSame(directiveIdx, tNode.directiveStart, 'TNode.directiveStart should point to just allocated space');
-    for (let i = 0; i < directives.length; i++) {
+    // If there's at least one directive, we'll have to track it so initialize the map.
+    if (directivesLength > 0) {
+        tNode.directiveToIndex = new Map();
+    }
+    for (let i = 0; i < directivesLength; 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 a directive has host directives, we need to track both its index and the range within
+        // the host directives are declared. Host directives are not tracked, but should be resolved
+        // by looking up the host and getting its indexes from there.
+        if (hostDirectiveRanges !== null && hostDirectiveRanges.has(def)) {
+            const [start, end] = hostDirectiveRanges.get(def);
+            tNode.directiveToIndex.set(def.type, [
+                directiveIdx,
+                start + tNode.directiveStart,
+                end + tNode.directiveStart,
+            ]);
+        }
+        else if (hostDirectiveDefs === null || !hostDirectiveDefs.has(def)) {
+            tNode.directiveToIndex.set(def.type, directiveIdx);
+        }
         if (def.contentQueries !== null)
             tNode.flags |= 4 /* TNodeFlags.hasContentQuery */;
         if (def.hostBindings !== null || def.hostAttrs !== null || def.hostVars !== 0)
@@ -17594,102 +17720,84 @@ function initializeDirectives(tView, lView, tNode, directives, exportsMap, hostD
  * 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) {
+function initializeInputAndOutputAliases(tView, tNode, hostDirectiveDefs) {
     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 */;
+    for (let index = tNode.directiveStart; index < tNode.directiveEnd; index++) {
+        const directiveDef = tView.data[index];
+        if (hostDirectiveDefs === null || !hostDirectiveDefs.has(directiveDef)) {
+            setupSelectorMatchedInputsOrOutputs(0 /* BindingType.Inputs */, tNode, directiveDef, index);
+            setupSelectorMatchedInputsOrOutputs(1 /* BindingType.Outputs */, tNode, directiveDef, index);
+            setupInitialInputs(tNode, index, false);
         }
-        if (inputsStore.hasOwnProperty('style')) {
-            tNode.flags |= 16 /* TNodeFlags.hasStyleInput */;
+        else {
+            const hostDirectiveDef = hostDirectiveDefs.get(directiveDef);
+            setupHostDirectiveInputsOrOutputs(0 /* BindingType.Inputs */, tNode, hostDirectiveDef, index);
+            setupHostDirectiveInputsOrOutputs(1 /* BindingType.Outputs */, tNode, hostDirectiveDef, index);
+            setupInitialInputs(tNode, index, true);
         }
     }
-    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;
+/**
+ * Sets up the input/output bindings for a directive that was matched in the template through its
+ * selector. This method is called repeatedly to build up all of the available inputs on a node.
+ *
+ * @param mode Whether inputs or outputs are being contructed.
+ * @param tNode Node on which the bindings are being set up.
+ * @param def Directive definition for which the bindings are being set up.
+ * @param directiveIndex Index at which the directive instance will be stored in the LView.
+ */
+function setupSelectorMatchedInputsOrOutputs(mode, tNode, def, directiveIndex) {
+    const aliasMap = mode === 0 /* BindingType.Inputs */ ? def.inputs : def.outputs;
+    for (const publicName in aliasMap) {
+        if (aliasMap.hasOwnProperty(publicName)) {
+            let bindings;
+            if (mode === 0 /* BindingType.Inputs */) {
+                bindings = tNode.inputs ??= {};
             }
-            finalPublicName = hostDirectiveAliasMap[publicName];
-        }
-        if (mode === 0 /* CaptureNodeBindingMode.Inputs */) {
-            addPropertyBinding(bindingsResult, directiveIndex, finalPublicName, internalName, inputFlags);
-        }
-        else {
-            addPropertyBinding(bindingsResult, directiveIndex, finalPublicName, internalName);
+            else {
+                bindings = tNode.outputs ??= {};
+            }
+            bindings[publicName] ??= [];
+            bindings[publicName].push(directiveIndex);
+            setShadowStylingInputFlags(tNode, publicName);
         }
     }
-    return bindingsResult;
 }
-function addPropertyBinding(bindings, directiveIndex, publicName, internalName, inputFlags) {
-    let values;
-    if (bindings.hasOwnProperty(publicName)) {
-        (values = bindings[publicName]).push(directiveIndex, internalName);
+/**
+ * Sets up input/output bindings that were defined through host directives on a specific node.
+ * @param mode Whether inputs or outputs are being contructed.
+ * @param tNode Node on which the bindings are being set up.
+ * @param config Host directive definition that is being set up.
+ * @param directiveIndex Index at which the directive instance will be stored in the LView.
+ */
+function setupHostDirectiveInputsOrOutputs(mode, tNode, config, directiveIndex) {
+    const aliasMap = mode === 0 /* BindingType.Inputs */ ? config.inputs : config.outputs;
+    for (const initialName in aliasMap) {
+        if (aliasMap.hasOwnProperty(initialName)) {
+            const publicName = aliasMap[initialName];
+            let bindings;
+            if (mode === 0 /* BindingType.Inputs */) {
+                bindings = tNode.hostDirectiveInputs ??= {};
+            }
+            else {
+                bindings = tNode.hostDirectiveOutputs ??= {};
+            }
+            bindings[publicName] ??= [];
+            bindings[publicName].push(directiveIndex, initialName);
+            setShadowStylingInputFlags(tNode, publicName);
+        }
     }
-    else {
-        values = bindings[publicName] = [directiveIndex, internalName];
+}
+function setShadowStylingInputFlags(tNode, publicName) {
+    if (publicName === 'class') {
+        tNode.flags |= 8 /* TNodeFlags.hasClassInput */;
     }
-    if (inputFlags !== undefined) {
-        values.push(inputFlags);
+    else if (publicName === 'style') {
+        tNode.flags |= 16 /* TNodeFlags.hasStyleInput */;
     }
 }
 /**
- * Generates initialInputData for a node and stores it in the template's static storage
+ * Sets up the 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
@@ -17699,11 +17807,21 @@ function addPropertyBinding(bindings, directiveIndex, publicName, internalName,
  *
  * <my-component name="Bess"></my-component>
  *
- * @param inputs Input alias map that was generated from the directive def inputs.
+ * @param tNode TNode on which to set up the initial inputs.
  * @param directiveIndex Index of the directive that is currently being processed.
- * @param attrs Static attrs on this node.
  */
-function generateInitialInputs(inputs, directiveIndex, attrs) {
+function setupInitialInputs(tNode, directiveIndex, isHostDirective) {
+    const { attrs, inputs, hostDirectiveInputs } = tNode;
+    if (attrs === null ||
+        (!isHostDirective && inputs === null) ||
+        (isHostDirective && hostDirectiveInputs === null) ||
+        // 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">`).
+        isInlineTemplate(tNode)) {
+        tNode.initialInputs ??= [];
+        tNode.initialInputs.push(null);
+        return;
+    }
     let inputsToStore = null;
     let i = 0;
     while (i < attrs.length) {
@@ -17718,27 +17836,38 @@ function generateInitialInputs(inputs, directiveIndex, attrs) {
             i += 2;
             continue;
         }
-        // If we hit any other attribute markers, we're done anyway. None of those are valid inputs.
-        if (typeof attrName === 'number')
+        else if (typeof attrName === 'number') {
+            // If we hit any other attribute markers, we're done anyway. None of those are valid inputs.
             break;
-        if (inputs.hasOwnProperty(attrName)) {
-            if (inputsToStore === null)
-                inputsToStore = [];
+        }
+        if (!isHostDirective && inputs.hasOwnProperty(attrName)) {
             // 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]);
+            for (const index of inputConfig) {
+                if (index === directiveIndex) {
+                    inputsToStore ??= [];
+                    inputsToStore.push(attrName, attrs[i + 1]);
                     // A directive can't have multiple inputs with the same name so we can break here.
                     break;
                 }
             }
         }
+        else if (isHostDirective && hostDirectiveInputs.hasOwnProperty(attrName)) {
+            const config = hostDirectiveInputs[attrName];
+            for (let j = 0; j < config.length; j += 2) {
+                if (config[j] === directiveIndex) {
+                    inputsToStore ??= [];
+                    inputsToStore.push(config[j + 1], attrs[i + 1]);
+                    break;
+                }
+            }
+        }
         i += 2;
     }
-    return inputsToStore;
+    tNode.initialInputs ??= [];
+    tNode.initialInputs.push(inputsToStore);
 }
 /**
  * Setup directive for instantiation.
@@ -17899,34 +18028,22 @@ class ComponentFactoryResolver extends ComponentFactoryResolver$1 {
         return new ComponentFactory(componentDef, this.ngModule);
     }
 }
-function toRefArray(map, isInputMap) {
-    const array = [];
-    for (const publicName in map) {
-        if (!map.hasOwnProperty(publicName)) {
-            continue;
-        }
-        const value = map[publicName];
-        if (value === undefined) {
-            continue;
-        }
-        const isArray = Array.isArray(value);
-        const propName = isArray ? value[0] : value;
-        const flags = isArray ? value[1] : InputFlags.None;
-        if (isInputMap) {
-            array.push({
-                propName: propName,
-                templateName: publicName,
-                isSignal: (flags & InputFlags.SignalBased) !== 0,
-            });
-        }
-        else {
-            array.push({
-                propName: propName,
-                templateName: publicName,
-            });
+function toInputRefArray(map) {
+    return Object.keys(map).map((name) => {
+        const [propName, flags, transform] = map[name];
+        const inputData = {
+            propName: propName,
+            templateName: name,
+            isSignal: (flags & InputFlags.SignalBased) !== 0,
+        };
+        if (transform) {
+            inputData.transform = transform;
         }
-    }
-    return array;
+        return inputData;
+    });
+}
+function toOutputRefArray(map) {
+    return Object.keys(map).map((name) => ({ propName: map[name], templateName: name }));
 }
 function verifyNotAnOrphanComponent(componentDef) {
     // TODO(pk): create assert that verifies ngDevMode
@@ -17985,20 +18102,10 @@ class ComponentFactory extends ComponentFactory$1 {
     ngContentSelectors;
     isBoundToModule;
     get inputs() {
-        const componentDef = this.componentDef;
-        const inputTransforms = componentDef.inputTransforms;
-        const refArray = toRefArray(componentDef.inputs, true);
-        if (inputTransforms !== null) {
-            for (const input of refArray) {
-                if (inputTransforms.hasOwnProperty(input.propName)) {
-                    input.transform = inputTransforms[input.propName];
-                }
-            }
-        }
-        return refArray;
+        return toInputRefArray(this.componentDef.inputs);
     }
     get outputs() {
-        return toRefArray(this.componentDef.outputs, false);
+        return toOutputRefArray(this.componentDef.outputs);
     }
     /**
      * @param componentDef The component definition.
@@ -18020,7 +18127,7 @@ class ComponentFactory extends ComponentFactory$1 {
             const cmpDef = this.componentDef;
             ngDevMode && verifyNotAnOrphanComponent(cmpDef);
             const tAttributes = rootSelectorOrNode
-                ? ['ng-version', '19.2.0-next.3']
+                ? ['ng-version', '19.2.0']
                 : // Extract attributes and classes from the first selector only to match VE behavior.
                     extractAttrsAndClassesFromSelector(this.componentDef.selectors[0]);
             // Create the root view. Uses empty TView and ContentTemplate.
@@ -18109,29 +18216,24 @@ class ComponentRef extends ComponentRef$1 {
         this.componentType = componentType;
     }
     setInput(name, value) {
-        const inputData = this._tNode.inputs;
-        let dataValue;
-        if (inputData !== null && (dataValue = inputData[name])) {
-            this.previousInputValues ??= new Map();
-            // Do not set the input if it is the same as the last value
-            // This behavior matches `bindingUpdated` when binding inputs in templates.
-            if (this.previousInputValues.has(name) &&
-                Object.is(this.previousInputValues.get(name), value)) {
-                return;
-            }
-            const lView = this._rootLView;
-            setInputsForProperty(lView[TVIEW], lView, dataValue, name, value);
-            this.previousInputValues.set(name, value);
-            const childComponentLView = getComponentLViewByIndex(this._tNode.index, lView);
-            markViewDirty(childComponentLView, 1 /* NotificationSource.SetInput */);
+        const tNode = this._tNode;
+        this.previousInputValues ??= new Map();
+        // Do not set the input if it is the same as the last value
+        // This behavior matches `bindingUpdated` when binding inputs in templates.
+        if (this.previousInputValues.has(name) &&
+            Object.is(this.previousInputValues.get(name), value)) {
+            return;
         }
-        else {
-            if (ngDevMode) {
-                const cmpNameForError = stringifyForError(this.componentType);
-                let message = `Can't set value of the '${name}' input on the '${cmpNameForError}' component. `;
-                message += `Make sure that the '${name}' property is annotated with @Input() or a mapped @Input('${name}') exists.`;
-                reportUnknownPropertyError(message);
-            }
+        const lView = this._rootLView;
+        const hasSetInput = setAllInputsForProperty(tNode, lView[TVIEW], lView, name, value);
+        this.previousInputValues.set(name, value);
+        const childComponentLView = getComponentLViewByIndex(tNode.index, lView);
+        markViewDirty(childComponentLView, 1 /* NotificationSource.SetInput */);
+        if (ngDevMode && !hasSetInput) {
+            const cmpNameForError = stringifyForError(this.componentType);
+            let message = `Can't set value of the '${name}' input on the '${cmpNameForError}' component. `;
+            message += `Make sure that the '${name}' property is annotated with @Input() or a mapped @Input('${name}') exists.`;
+            reportUnknownPropertyError(message);
         }
     }
     get injector() {
@@ -19893,7 +19995,74 @@ function ɵɵdefineNgModule(def) {
         return res;
     });
 }
-function parseAndConvertBindingsForDefinition(obj, declaredInputs) {
+/**
+ * Converts binding objects from the `DirectiveDefinition` into more efficient
+ * lookup dictionaries that are optimized for the framework runtime.
+ *
+ * This function converts inputs or output directive information into new objects
+ * where the public name conveniently maps to the minified internal field name.
+ *
+ * For inputs, the input flags are additionally persisted into the new data structure,
+ * so that those can be quickly retrieved when needed.
+ *
+ * e.g. for
+ *
+ * ```ts
+ * class Comp {
+ *   @Input()
+ *   propName1: string;
+ *
+ *   @Input('publicName2')
+ *   declaredPropName2: number;
+ *
+ *   inputSignal = input(3);
+ * }
+ * ```
+ *
+ * will be serialized as
+ *
+ * ```ts
+ * {
+ *   propName1: 'propName1',
+ *   declaredPropName2: ['publicName2', 'declaredPropName2'],
+ *   inputSignal: [InputFlags.SignalBased, 'inputSignal'],
+ * }
+ * ```
+ *
+ * which is than translated by the minifier as:
+ *
+ * ```ts
+ * {
+ *   minifiedPropName1: 'propName1',
+ *   minifiedPropName2: ['publicName2', 'declaredPropName2'],
+ *   minifiedInputSignal: [InputFlags.SignalBased, 'inputSignal'],
+ * }
+ * ```
+ *
+ * becomes: (public name => minifiedName + isSignal if needed)
+ *
+ * ```ts
+ * {
+ *  'propName1': 'minifiedPropName1',
+ *  'publicName2': 'minifiedPropName2',
+ *  'inputSignal': ['minifiedInputSignal', InputFlags.SignalBased],
+ * }
+ * ```
+ *
+ * Optionally the function can take `declaredInputs` which will result
+ * in: (public name => declared name)
+ *
+ * ```ts
+ * {
+ *  'propName1': 'propName1',
+ *  'publicName2': 'declaredPropName2',
+ *  'inputSignal': 'inputSignal',
+ * }
+ * ```
+ *
+
+ */
+function parseAndConvertInputsForDefinition(obj, declaredInputs) {
     if (obj == null)
         return EMPTY_OBJ;
     const newLookup = {};
@@ -19902,26 +20071,33 @@ function parseAndConvertBindingsForDefinition(obj, declaredInputs) {
             const value = obj[minifiedKey];
             let publicName;
             let declaredName;
-            let inputFlags = InputFlags.None;
+            let inputFlags;
+            let transform;
             if (Array.isArray(value)) {
                 inputFlags = value[0];
                 publicName = value[1];
                 declaredName = value[2] ?? publicName; // declared name might not be set to save bytes.
+                transform = value[3] || null;
             }
             else {
                 publicName = value;
                 declaredName = value;
+                inputFlags = InputFlags.None;
+                transform = null;
             }
-            // For inputs, capture the declared name, or if some flags are set.
-            if (declaredInputs) {
-                // Perf note: An array is only allocated for the input if there are flags.
-                newLookup[publicName] =
-                    inputFlags !== InputFlags.None ? [minifiedKey, inputFlags] : minifiedKey;
-                declaredInputs[publicName] = declaredName;
-            }
-            else {
-                newLookup[publicName] = minifiedKey;
-            }
+            newLookup[publicName] = [minifiedKey, inputFlags, transform];
+            declaredInputs[publicName] = declaredName;
+        }
+    }
+    return newLookup;
+}
+function parseAndConvertOutputsForDefinition(obj) {
+    if (obj == null)
+        return EMPTY_OBJ;
+    const newLookup = {};
+    for (const minifiedKey in obj) {
+        if (obj.hasOwnProperty(minifiedKey)) {
+            newLookup[obj[minifiedKey]] = minifiedKey;
         }
     }
     return newLookup;
@@ -19986,7 +20162,6 @@ function getNgDirectiveDef(directiveDefinition) {
         hostAttrs: directiveDefinition.hostAttrs || null,
         contentQueries: directiveDefinition.contentQueries || null,
         declaredInputs: declaredInputs,
-        inputTransforms: null,
         inputConfig: directiveDefinition.inputs || EMPTY_OBJ,
         exportAs: directiveDefinition.exportAs || null,
         standalone: directiveDefinition.standalone ?? true,
@@ -19997,8 +20172,8 @@ function getNgDirectiveDef(directiveDefinition) {
         setInput: null,
         findHostDirectiveDefs: null,
         hostDirectives: null,
-        inputs: parseAndConvertBindingsForDefinition(directiveDefinition.inputs, declaredInputs),
-        outputs: parseAndConvertBindingsForDefinition(directiveDefinition.outputs),
+        inputs: parseAndConvertInputsForDefinition(directiveDefinition.inputs, declaredInputs),
+        outputs: parseAndConvertOutputsForDefinition(directiveDefinition.outputs),
         debugInfo: null,
     };
 }
@@ -20127,7 +20302,6 @@ function ɵɵInheritDefinitionFeature(definition) {
                 // would've justified object creation. Unwrap them if necessary.
                 const writeableDef = definition;
                 writeableDef.inputs = maybeUnwrapEmpty(definition.inputs);
-                writeableDef.inputTransforms = maybeUnwrapEmpty(definition.inputTransforms);
                 writeableDef.declaredInputs = maybeUnwrapEmpty(definition.declaredInputs);
                 writeableDef.outputs = maybeUnwrapEmpty(definition.outputs);
                 // Merge hostBindings
@@ -20184,23 +20358,9 @@ function mergeInputsWithTransforms(target, source) {
             continue;
         }
         const value = source.inputs[key];
-        if (value === undefined) {
-            continue;
-        }
-        target.inputs[key] = value;
-        target.declaredInputs[key] = source.declaredInputs[key];
-        // If the input is inherited, and we have a transform for it, we also inherit it.
-        // Note that transforms should not be inherited if the input has its own metadata
-        // in the `source` directive itself already (i.e. the input is re-declared/overridden).
-        if (source.inputTransforms !== null) {
-            // Note: transforms are stored with their minified names.
-            // Perf: only access the minified name when there are source transforms.
-            const minifiedName = Array.isArray(value) ? value[0] : value;
-            if (!source.inputTransforms.hasOwnProperty(minifiedName)) {
-                continue;
-            }
-            target.inputTransforms ??= {};
-            target.inputTransforms[minifiedName] = source.inputTransforms[minifiedName];
+        if (value !== undefined) {
+            target.inputs[key] = value;
+            target.declaredInputs[key] = source.declaredInputs[key];
         }
     }
 }
@@ -20514,30 +20674,6 @@ function validateMappings(bindingType, def, hostDirectiveBindings) {
     }
 }
 
-/**
- * Decorates the directive definition with support for input transform functions.
- *
- * If the directive uses inheritance, the feature should be included before the
- * `InheritDefinitionFeature` to ensure that the `inputTransforms` field is populated.
- *
- * @codeGenApi
- */
-function ɵɵInputTransformsFeature(definition) {
-    const inputs = definition.inputConfig;
-    const inputTransforms = {};
-    for (const minifiedKey in inputs) {
-        if (inputs.hasOwnProperty(minifiedKey)) {
-            // Note: the private names are used for the keys, rather than the public ones, because public
-            // names can be re-aliased in host directives which would invalidate the lookup.
-            const value = inputs[minifiedKey];
-            if (Array.isArray(value) && value[3]) {
-                inputTransforms[minifiedKey] = value[3];
-            }
-        }
-    }
-    definition.inputTransforms = inputTransforms;
-}
-
 function isIterable(obj) {
     return obj !== null && typeof obj === 'object' && obj[Symbol.iterator] !== undefined;
 }
@@ -20719,7 +20855,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);
@@ -21254,8 +21390,9 @@ function renderDeferBlockState(newState, tNode, lContainer, skipTimerScheduling
     }
 }
 function findMatchingDehydratedViewForDeferBlock(lContainer, lDetails) {
-    // Find matching view based on serialized defer block state.
-    return (lContainer[DEHYDRATED_VIEWS]?.find((view) => view.data[DEFER_BLOCK_STATE$1] === lDetails[DEFER_BLOCK_STATE]) ?? null);
+    const dehydratedViewIx = lContainer[DEHYDRATED_VIEWS]?.findIndex((view) => view.data[DEFER_BLOCK_STATE$1] === lDetails[DEFER_BLOCK_STATE]) ?? -1;
+    const dehydratedView = dehydratedViewIx > -1 ? lContainer[DEHYDRATED_VIEWS][dehydratedViewIx] : null;
+    return { dehydratedView, dehydratedViewIx };
 }
 /**
  * Applies changes to the DOM to reflect a given state.
@@ -21287,21 +21424,23 @@ function applyDeferBlockState(newState, lDetails, lContainer, tNode, hostLView)
                 injector = createDeferBlockInjector(hostLView[INJECTOR], tDetails, providers);
             }
         }
-        const dehydratedView = findMatchingDehydratedViewForDeferBlock(lContainer, lDetails);
-        // Erase dehydrated view info, so that it's not removed later
-        // by post-hydration cleanup process.
-        lContainer[DEHYDRATED_VIEWS] = null;
+        const { dehydratedView, dehydratedViewIx } = findMatchingDehydratedViewForDeferBlock(lContainer, lDetails);
         const embeddedLView = createAndRenderEmbeddedLView(hostLView, activeBlockTNode, null, {
             injector,
             dehydratedView,
         });
         addLViewToLContainer(lContainer, embeddedLView, viewIndex, shouldAddViewToDom(activeBlockTNode, dehydratedView));
         markViewDirty(embeddedLView, 2 /* NotificationSource.DeferBlockStateUpdate */);
-        // TODO(incremental-hydration):
-        // - what if we had some views in `lContainer[DEHYDRATED_VIEWS]`, but
-        //   we didn't find a view that matches the expected state?
-        // - for example, handle a situation when a block was in the "completed" state
-        //   on the server, but the loading failing on the client. How do we reconcile and cleanup?
+        if (dehydratedViewIx > -1) {
+            // Erase dehydrated view info in a given LContainer, so that the view is not
+            // removed later by post-hydration cleanup process (which iterates over all
+            // dehydrated views in component tree). This clears only the dehydrated view
+            // that was found for this render, which in most cases will be the only view.
+            // In the case that there was control flow that changed, there may be either
+            // more than one or the views would not match up due to the server rendered
+            // content being a different branch of the control flow.
+            lContainer[DEHYDRATED_VIEWS]?.splice(dehydratedViewIx, 1);
+        }
         if ((newState === DeferBlockState.Complete || newState === DeferBlockState.Error) &&
             Array.isArray(lDetails[ON_COMPLETE_FNS])) {
             for (const callback of lDetails[ON_COMPLETE_FNS]) {
@@ -24150,16 +24289,36 @@ async function triggerHydrationFromBlockName(injector, blockName, replayQueuedEv
         await parentBlockPromise;
     }
     // Actually do the triggering and hydration of the queue of blocks
-    for (const dehydratedBlockId of hydrationQueue) {
-        await triggerResourceLoadingForHydration(dehydratedBlockId, dehydratedBlockRegistry);
-        await nextRender(injector);
-        // TODO(incremental-hydration): assert (in dev mode) that a defer block is present in the dehydrated registry
-        // at this point. If not - it means that the block has not been hydrated, for example due to different
-        // `@if` conditions on the client and the server. If we detect this case, we should also do the cleanup
-        // of all child block (promises, registry state, etc).
-        // TODO(incremental-hydration): call `rejectFn` when lDetails[DEFER_BLOCK_STATE] is `DeferBlockState.Error`.
-        blocksBeingHydrated.get(dehydratedBlockId).resolve();
-        // TODO(incremental-hydration): consider adding a wait for stability here
+    for (let blockQueueIdx = 0; blockQueueIdx < hydrationQueue.length; blockQueueIdx++) {
+        const dehydratedBlockId = hydrationQueue[blockQueueIdx];
+        const dehydratedDeferBlock = dehydratedBlockRegistry.get(dehydratedBlockId);
+        if (dehydratedDeferBlock != null) {
+            // trigger the block resources and await next render for hydration. This should result
+            // in the next block ɵɵdefer instruction being called and that block being added to the dehydrated registry.
+            await triggerResourceLoadingForHydration(dehydratedDeferBlock);
+            await nextRender(injector);
+            // if the content has changed since server rendering, we need to check for the expected block
+            // being in the registry or if errors occurred. In that case, we need to clean up the remaining expected
+            // content that won't be rendered or fetched.
+            if (deferBlockHasErrored(dehydratedDeferBlock)) {
+                // Either the expected block has not yet had its ɵɵdefer instruction called or the block errored out when fetching
+                // resources. In the former case, either we're hydrating too soon or the client and server differ. In both cases,
+                // we need to clean up child content and promises.
+                removeDehydratedViewList(dehydratedDeferBlock);
+                cleanupRemainingHydrationQueue(hydrationQueue.slice(blockQueueIdx), dehydratedBlockRegistry);
+                break;
+            }
+            // The defer block has not errored and we've finished fetching resources and rendering.
+            // At this point it is safe to resolve the hydration promise.
+            blocksBeingHydrated.get(dehydratedBlockId).resolve();
+        }
+        else {
+            // The expected block has not yet had its ɵɵdefer instruction called. This is likely due to content changing between
+            // client and server. We need to clean up the dehydrated DOM in the container since it no longer is valid.
+            cleanupParentContainer(blockQueueIdx, hydrationQueue, dehydratedBlockRegistry);
+            cleanupRemainingHydrationQueue(hydrationQueue.slice(blockQueueIdx), dehydratedBlockRegistry);
+            break;
+        }
     }
     // Await hydration completion for the requested block.
     await blocksBeingHydrated.get(blockName)?.promise;
@@ -24172,6 +24331,33 @@ async function triggerHydrationFromBlockName(injector, blockName, replayQueuedEv
     // Cleanup after hydration of all affected defer blocks.
     cleanupHydratedDeferBlocks(dehydratedBlockRegistry.get(blockName), hydrationQueue, dehydratedBlockRegistry, injector.get(ApplicationRef));
 }
+function deferBlockHasErrored(deferBlock) {
+    return (getLDeferBlockDetails(deferBlock.lView, deferBlock.tNode)[DEFER_BLOCK_STATE] ===
+        DeferBlockState.Error);
+}
+/**
+ * Clean up the parent container of a block where content changed between server and client.
+ * The parent of a block going through `triggerHydrationFromBlockName` will contain the
+ * dehydrated content that needs to be cleaned up. So we have to do the clean up from that location
+ * in the tree.
+ */
+function cleanupParentContainer(currentBlockIdx, hydrationQueue, dehydratedBlockRegistry) {
+    // If a parent block exists, it's in the hydration queue in front of the current block.
+    const parentDeferBlockIdx = currentBlockIdx - 1;
+    const parentDeferBlock = parentDeferBlockIdx > -1
+        ? dehydratedBlockRegistry.get(hydrationQueue[parentDeferBlockIdx])
+        : null;
+    if (parentDeferBlock) {
+        cleanupLContainer(parentDeferBlock.lContainer);
+    }
+}
+function cleanupRemainingHydrationQueue(hydrationQueue, dehydratedBlockRegistry) {
+    const blocksBeingHydrated = dehydratedBlockRegistry.hydrating;
+    for (const dehydratedBlockId in hydrationQueue) {
+        blocksBeingHydrated.get(dehydratedBlockId)?.reject();
+    }
+    dehydratedBlockRegistry.cleanup(hydrationQueue);
+}
 /**
  * Generates a new promise for every defer block in the hydrating queue
  */
@@ -24184,18 +24370,8 @@ function populateHydratingStateForQueue(registry, queue) {
 function nextRender(injector) {
     return new Promise((resolveFn) => afterNextRender(resolveFn, { injector }));
 }
-async function triggerResourceLoadingForHydration(dehydratedBlockId, dehydratedBlockRegistry) {
-    const deferBlock = dehydratedBlockRegistry.get(dehydratedBlockId);
-    // Since we trigger hydration for nested defer blocks in a sequence (parent -> child),
-    // there is a chance that a defer block may not be present at hydration time. For example,
-    // when a nested block was in an `@if` condition, which has changed.
-    if (deferBlock === null) {
-        // TODO(incremental-hydration): handle the cleanup for cases when
-        // defer block is no longer present during hydration (e.g. `@if` condition
-        // has changed during hydration/rendering).
-        return;
-    }
-    const { tNode, lView } = deferBlock;
+async function triggerResourceLoadingForHydration(dehydratedBlock) {
+    const { tNode, lView } = dehydratedBlock;
     const lDetails = getLDeferBlockDetails(lView, tNode);
     return new Promise((resolve) => {
         onDeferBlockCompletion(lDetails, resolve);
@@ -26248,10 +26424,8 @@ function ɵɵproperty(propName, value, sanitizer) {
  * directive input.
  */
 function setDirectiveInputsWhichShadowsStyling(tView, tNode, lView, value, isClassBased) {
-    const inputs = tNode.inputs;
-    const property = isClassBased ? 'class' : 'style';
     // We support both 'class' and `className` hence the fallback.
-    setInputsForProperty(tView, lView, inputs[property], property, value);
+    setAllInputsForProperty(tNode, tView, lView, isClassBased ? 'class' : 'style', value);
 }
 
 /**
@@ -28075,12 +28249,12 @@ function ɵɵelementStart(index, name, attrsIndex, localRefsIndex) {
     // any immediate children of a component or template container must be pre-emptively
     // monkey-patched with the component view data so that the element can be inspected
     // later on using any element discovery utility methods (see `element_discovery.ts`)
-    if (getElementDepthCount() === 0) {
+    if (getElementDepthCount() === 0 || hasDirectives) {
         attachPatchData(native, lView);
     }
     increaseElementDepthCount();
     if (hasDirectives) {
-        createDirectivesInstancesInInstruction(tView, lView, tNode);
+        createDirectivesInstances(tView, lView, tNode);
         executeContentQueries(tView, tNode, lView);
     }
     if (localRefsIndex !== null) {
@@ -28252,7 +28426,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) {
@@ -30307,7 +30481,7 @@ function findExistingListener(tView, lView, eventName, tNodeIdx) {
 function listenerInternal(tView, lView, renderer, tNode, eventName, listenerFn, eventTargetResolver) {
     const isTNodeDirectiveHost = isDirectiveHost(tNode);
     const firstCreatePass = tView.firstCreatePass;
-    const tCleanup = firstCreatePass && getOrCreateTViewCleanup(tView);
+    const tCleanup = firstCreatePass ? getOrCreateTViewCleanup(tView) : null;
     const context = lView[CONTEXT];
     // When the ɵɵlistener instruction was generated and is executed we know that there is either a
     // native listener or a directive output on this element. As such we we know that we will have to
@@ -30372,29 +30546,37 @@ function listenerInternal(tView, lView, renderer, tNode, eventName, listenerFn,
         // ancestors are marked dirty when an event occurs.
         listenerFn = wrapListener(tNode, lView, context, listenerFn);
     }
-    // subscribe to directive outputs
-    const outputs = tNode.outputs;
-    let props;
-    if (processOutputs && outputs !== null && (props = outputs[eventName])) {
-        const propsLength = props.length;
-        if (propsLength) {
-            for (let i = 0; i < propsLength; i += 2) {
-                const index = props[i];
-                ngDevMode && assertIndexInRange(lView, index);
-                const minifiedName = props[i + 1];
-                const directiveInstance = lView[index];
-                const output = directiveInstance[minifiedName];
-                if (ngDevMode && !isOutputSubscribable(output)) {
-                    throw new Error(`@Output ${minifiedName} not initialized in '${directiveInstance.constructor.name}'.`);
-                }
-                const subscription = output.subscribe(listenerFn);
-                const idx = lCleanup.length;
-                lCleanup.push(listenerFn, subscription);
-                tCleanup && tCleanup.push(eventName, tNode.index, idx, -(idx + 1));
+    if (processOutputs) {
+        const outputConfig = tNode.outputs?.[eventName];
+        const hostDirectiveOutputConfig = tNode.hostDirectiveOutputs?.[eventName];
+        if (hostDirectiveOutputConfig && hostDirectiveOutputConfig.length) {
+            for (let i = 0; i < hostDirectiveOutputConfig.length; i += 2) {
+                const index = hostDirectiveOutputConfig[i];
+                const lookupName = hostDirectiveOutputConfig[i + 1];
+                listenToOutput(tNode, tView, lView, index, lookupName, eventName, listenerFn, lCleanup, tCleanup);
+            }
+        }
+        if (outputConfig && outputConfig.length) {
+            for (const index of outputConfig) {
+                listenToOutput(tNode, tView, lView, index, eventName, eventName, listenerFn, lCleanup, tCleanup);
             }
         }
     }
 }
+function listenToOutput(tNode, tView, lView, index, lookupName, eventName, listenerFn, lCleanup, tCleanup) {
+    ngDevMode && assertIndexInRange(lView, index);
+    const instance = lView[index];
+    const def = tView.data[index];
+    const propertyName = def.outputs[lookupName];
+    const output = instance[propertyName];
+    if (ngDevMode && !isOutputSubscribable(output)) {
+        throw new Error(`@Output ${propertyName} not initialized in '${instance.constructor.name}'.`);
+    }
+    const subscription = output.subscribe(listenerFn);
+    const idx = lCleanup.length;
+    lCleanup.push(listenerFn, subscription);
+    tCleanup && tCleanup.push(eventName, tNode.index, idx, -(idx + 1));
+}
 function executeListenerWithErrorHandling(lView, context, listenerFn, e) {
     const prevConsumer = setActiveConsumer$1(null);
     try {
@@ -33558,11 +33740,12 @@ function executeWithInvalidateFallback(importMeta, id, callback) {
         callback();
     }
     catch (e) {
-        const errorMessage = e.message;
+        const error = e;
         // If we have all the necessary information and APIs to send off the invalidation
         // request, send it before rethrowing so the dev server can decide what to do.
-        if (id !== null && errorMessage) {
-            importMeta?.hot?.send?.('angular:invalidate', { id, message: errorMessage, error: true });
+        if (id !== null && error.message) {
+            const toLog = error.message + (error.stack ? '\n' + error.stack : '');
+            importMeta?.hot?.send?.('angular:invalidate', { id, message: toLog, error: true });
         }
         // Throw the error in case the page doesn't get refreshed.
         throw e;
@@ -33654,7 +33837,6 @@ const angularCoreEnv = (() => ({
     'ɵɵProvidersFeature': ɵɵProvidersFeature,
     'ɵɵCopyDefinitionFeature': ɵɵCopyDefinitionFeature,
     'ɵɵInheritDefinitionFeature': ɵɵInheritDefinitionFeature,
-    'ɵɵInputTransformsFeature': ɵɵInputTransformsFeature,
     'ɵɵExternalStylesFeature': ɵɵExternalStylesFeature,
     'ɵɵnextContext': ɵɵnextContext,
     'ɵɵnamespaceHTML': ɵɵnamespaceHTML,
@@ -34993,7 +35175,7 @@ class Version {
 /**
  * @publicApi
  */
-const VERSION = new Version('19.2.0-next.3');
+const VERSION = new Version('19.2.0');
 
 /**
  * Combination of NgModuleFactory and ComponentFactories.
@@ -35827,10 +36009,9 @@ class ImagePerformanceWarning {
     window = null;
     observer = null;
     options = inject(IMAGE_CONFIG);
-    isBrowser = inject(PLATFORM_ID) === 'browser';
     lcpImageUrl;
     start() {
-        if (!this.isBrowser ||
+        if ((typeof ngServerMode !== 'undefined' && ngServerMode) ||
             typeof PerformanceObserver === 'undefined' ||
             (this.options?.disableImageSizeWarning && this.options?.disableImageLazyLoadWarning)) {
             return;
@@ -35838,7 +36019,7 @@ class ImagePerformanceWarning {
         this.observer = this.initPerformanceObserver();
         const doc = getDocument();
         const win = doc.defaultView;
-        if (typeof win !== 'undefined') {
+        if (win) {
             this.window = win;
             // Wait to avoid race conditions where LCP image triggers
             // load event before it's recorded by the performance observer
@@ -38840,8 +39021,8 @@ function defaultThrowError() {
     throw new Error();
 }
 let throwInvalidWriteToSignalErrorFn = defaultThrowError;
-function throwInvalidWriteToSignalError() {
-    throwInvalidWriteToSignalErrorFn();
+function throwInvalidWriteToSignalError(node) {
+    throwInvalidWriteToSignalErrorFn(node);
 }
 function setThrowInvalidWriteToSignalError(fn) {
     throwInvalidWriteToSignalErrorFn = fn;
@@ -38878,7 +39059,7 @@ function signalGetFn() {
 }
 function signalSetFn(node, newValue) {
     if (!producerUpdatesAllowed()) {
-        throwInvalidWriteToSignalError();
+        throwInvalidWriteToSignalError(node);
     }
     if (!node.equal(node.value, newValue)) {
         node.value = newValue;
@@ -38887,7 +39068,7 @@ function signalSetFn(node, newValue) {
 }
 function signalUpdateFn(node, updater) {
     if (!producerUpdatesAllowed()) {
-        throwInvalidWriteToSignalError();
+        throwInvalidWriteToSignalError(node);
     }
     signalSetFn(node, updater(node.value));
 }
@@ -40423,182 +40604,26 @@ function disableProfiling() {
     enablePerfLogging = false;
 }
 
-/*!
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.dev/license
- */
 /**
- * Gets the class name of the closest component to a node.
- * Warning! this function will return minified names if the name of the component is minified. The
- * consumer of the function is responsible for resolving the minified name to its original name.
- * @param node Node from which to start the search.
+ * Execute an arbitrary function in a non-reactive (non-tracking) context. The executed function
+ * can, optionally, return a value.
  */
-function getClosestComponentName(node) {
-    let currentNode = node;
-    while (currentNode) {
-        const lView = readPatchedLView(currentNode);
-        if (lView !== null) {
-            for (let i = HEADER_OFFSET; i < lView.length; i++) {
-                const current = lView[i];
-                if ((!isLView(current) && !isLContainer(current)) || current[HOST] !== currentNode) {
-                    continue;
-                }
-                const tView = lView[TVIEW];
-                const tNode = getTNode(tView, i);
-                if (isComponentHost(tNode)) {
-                    const def = tView.data[tNode.directiveStart + tNode.componentOffset];
-                    const name = def.debugInfo?.className || def.type.name;
-                    // Note: the name may be an empty string if the class name is
-                    // dropped due to minification. In such cases keep going up the tree.
-                    if (name) {
-                        return name;
-                    }
-                    else {
-                        break;
-                    }
-                }
-            }
-        }
-        currentNode = currentNode.parentNode;
+function untracked(nonReactiveReadsFn) {
+    const prevConsumer = setActiveConsumer$1(null);
+    // We are not trying to catch any particular errors here, just making sure that the consumers
+    // stack is restored in case of errors.
+    try {
+        return nonReactiveReadsFn();
     }
-    return null;
-}
-
-/**
- * Compiles a partial directive declaration object into a full directive definition object.
- *
- * @codeGenApi
- */
-function ɵɵngDeclareDirective(decl) {
-    const compiler = getCompilerFacade({
-        usage: 1 /* JitCompilerUsage.PartialDeclaration */,
-        kind: 'directive',
-        type: decl.type,
-    });
-    return compiler.compileDirectiveDeclaration(angularCoreEnv, `ng:///${decl.type.name}/ɵfac.js`, decl);
-}
-/**
- * Evaluates the class metadata declaration.
- *
- * @codeGenApi
- */
-function ɵɵngDeclareClassMetadata(decl) {
-    setClassMetadata(decl.type, decl.decorators, decl.ctorParameters ?? null, decl.propDecorators ?? null);
-}
-/**
- * Evaluates the class metadata of a component that contains deferred blocks.
- *
- * @codeGenApi
- */
-function ɵɵngDeclareClassMetadataAsync(decl) {
-    setClassMetadataAsync(decl.type, decl.resolveDeferredDeps, (...types) => {
-        const meta = decl.resolveMetadata(...types);
-        setClassMetadata(decl.type, meta.decorators, meta.ctorParameters, meta.propDecorators);
-    });
-}
-/**
- * Compiles a partial component declaration object into a full component definition object.
- *
- * @codeGenApi
- */
-function ɵɵngDeclareComponent(decl) {
-    const compiler = getCompilerFacade({
-        usage: 1 /* JitCompilerUsage.PartialDeclaration */,
-        kind: 'component',
-        type: decl.type,
-    });
-    return compiler.compileComponentDeclaration(angularCoreEnv, `ng:///${decl.type.name}/ɵcmp.js`, decl);
-}
-/**
- * Compiles a partial pipe declaration object into a full pipe definition object.
- *
- * @codeGenApi
- */
-function ɵɵngDeclareFactory(decl) {
-    const compiler = getCompilerFacade({
-        usage: 1 /* JitCompilerUsage.PartialDeclaration */,
-        kind: getFactoryKind(decl.target),
-        type: decl.type,
-    });
-    return compiler.compileFactoryDeclaration(angularCoreEnv, `ng:///${decl.type.name}/ɵfac.js`, decl);
-}
-function getFactoryKind(target) {
-    switch (target) {
-        case FactoryTarget.Directive:
-            return 'directive';
-        case FactoryTarget.Component:
-            return 'component';
-        case FactoryTarget.Injectable:
-            return 'injectable';
-        case FactoryTarget.Pipe:
-            return 'pipe';
-        case FactoryTarget.NgModule:
-            return 'NgModule';
+    finally {
+        setActiveConsumer$1(prevConsumer);
     }
 }
-/**
- * Compiles a partial injectable declaration object into a full injectable definition object.
- *
- * @codeGenApi
- */
-function ɵɵngDeclareInjectable(decl) {
-    const compiler = getCompilerFacade({
-        usage: 1 /* JitCompilerUsage.PartialDeclaration */,
-        kind: 'injectable',
-        type: decl.type,
-    });
-    return compiler.compileInjectableDeclaration(angularCoreEnv, `ng:///${decl.type.name}/ɵprov.js`, decl);
-}
-/**
- * Compiles a partial injector declaration object into a full injector definition object.
- *
- * @codeGenApi
- */
-function ɵɵngDeclareInjector(decl) {
-    const compiler = getCompilerFacade({
-        usage: 1 /* JitCompilerUsage.PartialDeclaration */,
-        kind: 'NgModule',
-        type: decl.type,
-    });
-    return compiler.compileInjectorDeclaration(angularCoreEnv, `ng:///${decl.type.name}/ɵinj.js`, decl);
-}
-/**
- * Compiles a partial NgModule declaration object into a full NgModule definition object.
- *
- * @codeGenApi
- */
-function ɵɵngDeclareNgModule(decl) {
-    const compiler = getCompilerFacade({
-        usage: 1 /* JitCompilerUsage.PartialDeclaration */,
-        kind: 'NgModule',
-        type: decl.type,
-    });
-    return compiler.compileNgModuleDeclaration(angularCoreEnv, `ng:///${decl.type.name}/ɵmod.js`, decl);
-}
-/**
- * Compiles a partial pipe declaration object into a full pipe definition object.
- *
- * @codeGenApi
- */
-function ɵɵngDeclarePipe(decl) {
-    const compiler = getCompilerFacade({
-        usage: 1 /* JitCompilerUsage.PartialDeclaration */,
-        kind: 'pipe',
-        type: decl.type,
-    });
-    return compiler.compilePipeDeclaration(angularCoreEnv, `ng:///${decl.type.name}/ɵpipe.js`, decl);
-}
-
-// we reexport these symbols just so that they are retained during the dead code elimination
 
 /**
  * Create a computed `Signal` which derives a reactive value from an expression.
  */
 function computed(computation, options) {
-    performanceMarkFeature('NgSignals');
     const getter = createComputed$1(computation);
     if (options?.equal) {
         getter[SIGNAL$1].equal = options.equal;
@@ -40610,46 +40635,6 @@ function computed(computation, options) {
     return getter;
 }
 
-const identityFn = (v) => v;
-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);
-    }
-}
-function upgradeLinkedSignalGetter(getter) {
-    if (ngDevMode) {
-        getter.toString = () => `[LinkedSignal: ${getter()}]`;
-    }
-    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;
-}
-
-/**
- * Execute an arbitrary function in a non-reactive (non-tracking) context. The executed function
- * can, optionally, return a value.
- */
-function untracked(nonReactiveReadsFn) {
-    const prevConsumer = setActiveConsumer$1(null);
-    // We are not trying to catch any particular errors here, just making sure that the consumers
-    // stack is restored in case of errors.
-    try {
-        return nonReactiveReadsFn();
-    }
-    finally {
-        setActiveConsumer$1(prevConsumer);
-    }
-}
-
 /**
  * Controls whether effects use the legacy `microtaskEffect` by default.
  */
@@ -40736,7 +40721,6 @@ function effect$1() { }
  * Create a global `Effect` for the given reactive function.
  */
 function microtaskEffect(effectFn, options) {
-    performanceMarkFeature('NgSignals');
     ngDevMode &&
         assertNotInReactiveContext(effect$1, 'Call `effect` outside of a reactive context. For example, schedule the ' +
             'effect inside the component constructor.');
@@ -40809,7 +40793,6 @@ function effect(effectFn, options) {
         }
         return microtaskEffect(effectFn, options);
     }
-    performanceMarkFeature('NgSignals');
     ngDevMode &&
         assertNotInReactiveContext(effect, 'Call `effect` outside of a reactive context. For example, schedule the ' +
             'effect inside the component constructor.');
@@ -40963,163 +40946,6 @@ function createRootEffect(fn, scheduler, notifier) {
     return node;
 }
 
-const NOT_SET = Symbol('NOT_SET');
-const EMPTY_CLEANUP_SET = new Set();
-const AFTER_RENDER_PHASE_EFFECT_NODE = /* @__PURE__ */ (() => ({
-    ...SIGNAL_NODE$1,
-    consumerIsAlwaysLive: true,
-    consumerAllowSignalWrites: true,
-    value: NOT_SET,
-    cleanup: null,
-    /** Called when the effect becomes dirty */
-    consumerMarkedDirty() {
-        if (this.sequence.impl.executing) {
-            // If hooks are in the middle of executing, then it matters whether this node has yet been
-            // executed within its sequence. If not, then we don't want to notify the scheduler since
-            // this node will be reached naturally.
-            if (this.sequence.lastPhase === null || this.sequence.lastPhase < this.phase) {
-                return;
-            }
-            // If during the execution of a later phase an earlier phase became dirty, then we should not
-            // run any further phases until the earlier one reruns.
-            this.sequence.erroredOrDestroyed = true;
-        }
-        // Either hooks are not running, or we're marking a node dirty that has already run within its
-        // sequence.
-        this.sequence.scheduler.notify(7 /* NotificationSource.RenderHook */);
-    },
-    phaseFn(previousValue) {
-        this.sequence.lastPhase = this.phase;
-        if (!this.dirty) {
-            return this.signal;
-        }
-        this.dirty = false;
-        if (this.value !== NOT_SET && !consumerPollProducersForChange$1(this)) {
-            // None of our producers report a change since the last time they were read, so no
-            // recomputation of our value is necessary.
-            return this.signal;
-        }
-        // Run any needed cleanup functions.
-        try {
-            for (const cleanupFn of this.cleanup ?? EMPTY_CLEANUP_SET) {
-                cleanupFn();
-            }
-        }
-        finally {
-            // Even if a cleanup function errors, ensure it's cleared.
-            this.cleanup?.clear();
-        }
-        // Prepare to call the user's effect callback. If there was a previous phase, then it gave us
-        // its value as a `Signal`, otherwise `previousValue` will be `undefined`.
-        const args = [];
-        if (previousValue !== undefined) {
-            args.push(previousValue);
-        }
-        args.push(this.registerCleanupFn);
-        // Call the user's callback in our reactive context.
-        const prevConsumer = consumerBeforeComputation$1(this);
-        let newValue;
-        try {
-            newValue = this.userFn.apply(null, args);
-        }
-        finally {
-            consumerAfterComputation$1(this, prevConsumer);
-        }
-        if (this.value === NOT_SET || !this.equal(this.value, newValue)) {
-            this.value = newValue;
-            this.version++;
-        }
-        return this.signal;
-    },
-}))();
-/**
- * An `AfterRenderSequence` that manages an `afterRenderEffect`'s phase effects.
- */
-class AfterRenderEffectSequence extends AfterRenderSequence {
-    scheduler;
-    /**
-     * While this sequence is executing, this tracks the last phase which was called by the
-     * `afterRender` machinery.
-     *
-     * When a phase effect is marked dirty, this is used to determine whether it's already run or not.
-     */
-    lastPhase = null;
-    /**
-     * The reactive nodes for each phase, if a phase effect is defined for that phase.
-     *
-     * These are initialized to `undefined` but set in the constructor.
-     */
-    nodes = [undefined, undefined, undefined, undefined];
-    constructor(impl, effectHooks, view, scheduler, destroyRef, snapshot = null) {
-        // Note that we also initialize the underlying `AfterRenderSequence` hooks to `undefined` and
-        // populate them as we create reactive nodes below.
-        super(impl, [undefined, undefined, undefined, undefined], view, false, destroyRef, snapshot);
-        this.scheduler = scheduler;
-        // Setup a reactive node for each phase.
-        for (const phase of AFTER_RENDER_PHASES) {
-            const effectHook = effectHooks[phase];
-            if (effectHook === undefined) {
-                continue;
-            }
-            const node = Object.create(AFTER_RENDER_PHASE_EFFECT_NODE);
-            node.sequence = this;
-            node.phase = phase;
-            node.userFn = effectHook;
-            node.dirty = true;
-            node.signal = (() => {
-                producerAccessed$1(node);
-                return node.value;
-            });
-            node.signal[SIGNAL$1] = node;
-            node.registerCleanupFn = (fn) => (node.cleanup ??= new Set()).add(fn);
-            this.nodes[phase] = node;
-            // Install the upstream hook which runs the `phaseFn` for this phase.
-            this.hooks[phase] = (value) => node.phaseFn(value);
-        }
-    }
-    afterRun() {
-        super.afterRun();
-        // We're done running this sequence, so reset `lastPhase`.
-        this.lastPhase = null;
-    }
-    destroy() {
-        super.destroy();
-        // Run the cleanup functions for each node.
-        for (const node of this.nodes) {
-            for (const fn of node?.cleanup ?? EMPTY_CLEANUP_SET) {
-                fn();
-            }
-        }
-    }
-}
-/**
- * @experimental
- */
-function afterRenderEffect(callbackOrSpec, options) {
-    ngDevMode &&
-        assertNotInReactiveContext(afterRenderEffect, 'Call `afterRenderEffect` outside of a reactive context. For example, create the render ' +
-            'effect inside the component constructor`.');
-    !options?.injector && assertInInjectionContext(afterRenderEffect);
-    if (typeof ngServerMode !== 'undefined' && ngServerMode) {
-        return NOOP_AFTER_RENDER_REF;
-    }
-    const injector = options?.injector ?? inject(Injector);
-    const scheduler = injector.get(ChangeDetectionScheduler);
-    const manager = injector.get(AfterRenderManager);
-    const tracing = injector.get(TracingService, null, { optional: true });
-    manager.impl ??= injector.get(AfterRenderImpl);
-    let spec = callbackOrSpec;
-    if (typeof spec === 'function') {
-        spec = { mixedReadWrite: callbackOrSpec };
-    }
-    const viewContext = injector.get(ViewContext, null, { optional: true });
-    const sequence = new AfterRenderEffectSequence(manager.impl, [spec.earlyRead, spec.write, spec.mixedReadWrite, spec.read], viewContext?.view, scheduler, injector.get(DestroyRef), tracing?.snapshot(null));
-    manager.impl.register(sequence);
-    return sequence;
-}
-
-// This file exists to allow the set of reactivity exports to be modified in g3, as these APIs are
-
 /**
  * Status of a `Resource`.
  *
@@ -41161,6 +40987,29 @@ var ResourceStatus;
     ResourceStatus[ResourceStatus["Local"] = 5] = "Local";
 })(ResourceStatus || (ResourceStatus = {}));
 
+const identityFn = (v) => v;
+function linkedSignal(optionsOrComputation, options) {
+    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);
+    }
+}
+function upgradeLinkedSignalGetter(getter) {
+    if (ngDevMode) {
+        getter.toString = () => `[LinkedSignal: ${getter()}]`;
+    }
+    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;
+}
+
 function resource(options) {
     options?.injector || assertInInjectionContext(resource);
     const request = (options.request ?? (() => null));
@@ -41429,6 +41278,334 @@ function isResolved(state) {
     return state.error === undefined;
 }
 
+/*!
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+/**
+ * Gets the class name of the closest component to a node.
+ * Warning! this function will return minified names if the name of the component is minified. The
+ * consumer of the function is responsible for resolving the minified name to its original name.
+ * @param node Node from which to start the search.
+ */
+function getClosestComponentName(node) {
+    let currentNode = node;
+    while (currentNode) {
+        const lView = readPatchedLView(currentNode);
+        if (lView !== null) {
+            for (let i = HEADER_OFFSET; i < lView.length; i++) {
+                const current = lView[i];
+                if ((!isLView(current) && !isLContainer(current)) || current[HOST] !== currentNode) {
+                    continue;
+                }
+                const tView = lView[TVIEW];
+                const tNode = getTNode(tView, i);
+                if (isComponentHost(tNode)) {
+                    const def = tView.data[tNode.directiveStart + tNode.componentOffset];
+                    const name = def.debugInfo?.className || def.type.name;
+                    // Note: the name may be an empty string if the class name is
+                    // dropped due to minification. In such cases keep going up the tree.
+                    if (name) {
+                        return name;
+                    }
+                    else {
+                        break;
+                    }
+                }
+            }
+        }
+        currentNode = currentNode.parentNode;
+    }
+    return null;
+}
+
+/**
+ * Compiles a partial directive declaration object into a full directive definition object.
+ *
+ * @codeGenApi
+ */
+function ɵɵngDeclareDirective(decl) {
+    const compiler = getCompilerFacade({
+        usage: 1 /* JitCompilerUsage.PartialDeclaration */,
+        kind: 'directive',
+        type: decl.type,
+    });
+    return compiler.compileDirectiveDeclaration(angularCoreEnv, `ng:///${decl.type.name}/ɵfac.js`, decl);
+}
+/**
+ * Evaluates the class metadata declaration.
+ *
+ * @codeGenApi
+ */
+function ɵɵngDeclareClassMetadata(decl) {
+    setClassMetadata(decl.type, decl.decorators, decl.ctorParameters ?? null, decl.propDecorators ?? null);
+}
+/**
+ * Evaluates the class metadata of a component that contains deferred blocks.
+ *
+ * @codeGenApi
+ */
+function ɵɵngDeclareClassMetadataAsync(decl) {
+    setClassMetadataAsync(decl.type, decl.resolveDeferredDeps, (...types) => {
+        const meta = decl.resolveMetadata(...types);
+        setClassMetadata(decl.type, meta.decorators, meta.ctorParameters, meta.propDecorators);
+    });
+}
+/**
+ * Compiles a partial component declaration object into a full component definition object.
+ *
+ * @codeGenApi
+ */
+function ɵɵngDeclareComponent(decl) {
+    const compiler = getCompilerFacade({
+        usage: 1 /* JitCompilerUsage.PartialDeclaration */,
+        kind: 'component',
+        type: decl.type,
+    });
+    return compiler.compileComponentDeclaration(angularCoreEnv, `ng:///${decl.type.name}/ɵcmp.js`, decl);
+}
+/**
+ * Compiles a partial pipe declaration object into a full pipe definition object.
+ *
+ * @codeGenApi
+ */
+function ɵɵngDeclareFactory(decl) {
+    const compiler = getCompilerFacade({
+        usage: 1 /* JitCompilerUsage.PartialDeclaration */,
+        kind: getFactoryKind(decl.target),
+        type: decl.type,
+    });
+    return compiler.compileFactoryDeclaration(angularCoreEnv, `ng:///${decl.type.name}/ɵfac.js`, decl);
+}
+function getFactoryKind(target) {
+    switch (target) {
+        case FactoryTarget.Directive:
+            return 'directive';
+        case FactoryTarget.Component:
+            return 'component';
+        case FactoryTarget.Injectable:
+            return 'injectable';
+        case FactoryTarget.Pipe:
+            return 'pipe';
+        case FactoryTarget.NgModule:
+            return 'NgModule';
+    }
+}
+/**
+ * Compiles a partial injectable declaration object into a full injectable definition object.
+ *
+ * @codeGenApi
+ */
+function ɵɵngDeclareInjectable(decl) {
+    const compiler = getCompilerFacade({
+        usage: 1 /* JitCompilerUsage.PartialDeclaration */,
+        kind: 'injectable',
+        type: decl.type,
+    });
+    return compiler.compileInjectableDeclaration(angularCoreEnv, `ng:///${decl.type.name}/ɵprov.js`, decl);
+}
+/**
+ * Compiles a partial injector declaration object into a full injector definition object.
+ *
+ * @codeGenApi
+ */
+function ɵɵngDeclareInjector(decl) {
+    const compiler = getCompilerFacade({
+        usage: 1 /* JitCompilerUsage.PartialDeclaration */,
+        kind: 'NgModule',
+        type: decl.type,
+    });
+    return compiler.compileInjectorDeclaration(angularCoreEnv, `ng:///${decl.type.name}/ɵinj.js`, decl);
+}
+/**
+ * Compiles a partial NgModule declaration object into a full NgModule definition object.
+ *
+ * @codeGenApi
+ */
+function ɵɵngDeclareNgModule(decl) {
+    const compiler = getCompilerFacade({
+        usage: 1 /* JitCompilerUsage.PartialDeclaration */,
+        kind: 'NgModule',
+        type: decl.type,
+    });
+    return compiler.compileNgModuleDeclaration(angularCoreEnv, `ng:///${decl.type.name}/ɵmod.js`, decl);
+}
+/**
+ * Compiles a partial pipe declaration object into a full pipe definition object.
+ *
+ * @codeGenApi
+ */
+function ɵɵngDeclarePipe(decl) {
+    const compiler = getCompilerFacade({
+        usage: 1 /* JitCompilerUsage.PartialDeclaration */,
+        kind: 'pipe',
+        type: decl.type,
+    });
+    return compiler.compilePipeDeclaration(angularCoreEnv, `ng:///${decl.type.name}/ɵpipe.js`, decl);
+}
+
+// we reexport these symbols just so that they are retained during the dead code elimination
+
+const NOT_SET = Symbol('NOT_SET');
+const EMPTY_CLEANUP_SET = new Set();
+const AFTER_RENDER_PHASE_EFFECT_NODE = /* @__PURE__ */ (() => ({
+    ...SIGNAL_NODE$1,
+    consumerIsAlwaysLive: true,
+    consumerAllowSignalWrites: true,
+    value: NOT_SET,
+    cleanup: null,
+    /** Called when the effect becomes dirty */
+    consumerMarkedDirty() {
+        if (this.sequence.impl.executing) {
+            // If hooks are in the middle of executing, then it matters whether this node has yet been
+            // executed within its sequence. If not, then we don't want to notify the scheduler since
+            // this node will be reached naturally.
+            if (this.sequence.lastPhase === null || this.sequence.lastPhase < this.phase) {
+                return;
+            }
+            // If during the execution of a later phase an earlier phase became dirty, then we should not
+            // run any further phases until the earlier one reruns.
+            this.sequence.erroredOrDestroyed = true;
+        }
+        // Either hooks are not running, or we're marking a node dirty that has already run within its
+        // sequence.
+        this.sequence.scheduler.notify(7 /* NotificationSource.RenderHook */);
+    },
+    phaseFn(previousValue) {
+        this.sequence.lastPhase = this.phase;
+        if (!this.dirty) {
+            return this.signal;
+        }
+        this.dirty = false;
+        if (this.value !== NOT_SET && !consumerPollProducersForChange$1(this)) {
+            // None of our producers report a change since the last time they were read, so no
+            // recomputation of our value is necessary.
+            return this.signal;
+        }
+        // Run any needed cleanup functions.
+        try {
+            for (const cleanupFn of this.cleanup ?? EMPTY_CLEANUP_SET) {
+                cleanupFn();
+            }
+        }
+        finally {
+            // Even if a cleanup function errors, ensure it's cleared.
+            this.cleanup?.clear();
+        }
+        // Prepare to call the user's effect callback. If there was a previous phase, then it gave us
+        // its value as a `Signal`, otherwise `previousValue` will be `undefined`.
+        const args = [];
+        if (previousValue !== undefined) {
+            args.push(previousValue);
+        }
+        args.push(this.registerCleanupFn);
+        // Call the user's callback in our reactive context.
+        const prevConsumer = consumerBeforeComputation$1(this);
+        let newValue;
+        try {
+            newValue = this.userFn.apply(null, args);
+        }
+        finally {
+            consumerAfterComputation$1(this, prevConsumer);
+        }
+        if (this.value === NOT_SET || !this.equal(this.value, newValue)) {
+            this.value = newValue;
+            this.version++;
+        }
+        return this.signal;
+    },
+}))();
+/**
+ * An `AfterRenderSequence` that manages an `afterRenderEffect`'s phase effects.
+ */
+class AfterRenderEffectSequence extends AfterRenderSequence {
+    scheduler;
+    /**
+     * While this sequence is executing, this tracks the last phase which was called by the
+     * `afterRender` machinery.
+     *
+     * When a phase effect is marked dirty, this is used to determine whether it's already run or not.
+     */
+    lastPhase = null;
+    /**
+     * The reactive nodes for each phase, if a phase effect is defined for that phase.
+     *
+     * These are initialized to `undefined` but set in the constructor.
+     */
+    nodes = [undefined, undefined, undefined, undefined];
+    constructor(impl, effectHooks, view, scheduler, destroyRef, snapshot = null) {
+        // Note that we also initialize the underlying `AfterRenderSequence` hooks to `undefined` and
+        // populate them as we create reactive nodes below.
+        super(impl, [undefined, undefined, undefined, undefined], view, false, destroyRef, snapshot);
+        this.scheduler = scheduler;
+        // Setup a reactive node for each phase.
+        for (const phase of AFTER_RENDER_PHASES) {
+            const effectHook = effectHooks[phase];
+            if (effectHook === undefined) {
+                continue;
+            }
+            const node = Object.create(AFTER_RENDER_PHASE_EFFECT_NODE);
+            node.sequence = this;
+            node.phase = phase;
+            node.userFn = effectHook;
+            node.dirty = true;
+            node.signal = (() => {
+                producerAccessed$1(node);
+                return node.value;
+            });
+            node.signal[SIGNAL$1] = node;
+            node.registerCleanupFn = (fn) => (node.cleanup ??= new Set()).add(fn);
+            this.nodes[phase] = node;
+            // Install the upstream hook which runs the `phaseFn` for this phase.
+            this.hooks[phase] = (value) => node.phaseFn(value);
+        }
+    }
+    afterRun() {
+        super.afterRun();
+        // We're done running this sequence, so reset `lastPhase`.
+        this.lastPhase = null;
+    }
+    destroy() {
+        super.destroy();
+        // Run the cleanup functions for each node.
+        for (const node of this.nodes) {
+            for (const fn of node?.cleanup ?? EMPTY_CLEANUP_SET) {
+                fn();
+            }
+        }
+    }
+}
+/**
+ * @experimental
+ */
+function afterRenderEffect(callbackOrSpec, options) {
+    ngDevMode &&
+        assertNotInReactiveContext(afterRenderEffect, 'Call `afterRenderEffect` outside of a reactive context. For example, create the render ' +
+            'effect inside the component constructor`.');
+    !options?.injector && assertInInjectionContext(afterRenderEffect);
+    if (typeof ngServerMode !== 'undefined' && ngServerMode) {
+        return NOOP_AFTER_RENDER_REF;
+    }
+    const injector = options?.injector ?? inject(Injector);
+    const scheduler = injector.get(ChangeDetectionScheduler);
+    const manager = injector.get(AfterRenderManager);
+    const tracing = injector.get(TracingService, null, { optional: true });
+    manager.impl ??= injector.get(AfterRenderImpl);
+    let spec = callbackOrSpec;
+    if (typeof spec === 'function') {
+        spec = { mixedReadWrite: callbackOrSpec };
+    }
+    const viewContext = injector.get(ViewContext, null, { optional: true });
+    const sequence = new AfterRenderEffectSequence(manager.impl, [spec.earlyRead, spec.write, spec.mixedReadWrite, spec.read], viewContext?.view, scheduler, injector.get(DestroyRef), tracing?.snapshot(null));
+    manager.impl.register(sequence);
+    return sequence;
+}
+
+// This file exists to allow the set of reactivity exports to be modified in g3, as these APIs are
+
 /**
  * Creates a `ComponentRef` instance based on provided component type and a set of options.
  *
@@ -41675,5 +41852,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, 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, ResourceImpl as ɵResourceImpl, 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, ɵɵ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