@angular/core 22.0.0-next.9 → 22.0.0-rc.0

package/fesm2022/_debug_node-chunk.mjs

@@ -1,10 +1,10 @@
 /**
- * @license Angular v22.0.0-next.9
+ * @license Angular v22.0.0-rc.0
  * (c) 2010-2026 Google LLC. https://angular.dev/
  * License: MIT
  */
 
-import { attachInjectFlag, _global, resolveForwardRef, ɵɵinvalidFactoryDep as __invalidFactoryDep, ɵɵinject as __inject, ɵɵdefineInjector as __defineInjector, ɵɵdefineInjectable as __defineInjectable, newArray, assertString, EMPTY_OBJ, assertFirstCreatePass, assertDefined, assertNotEqual, FLAGS, assertEqual, isInCheckNoChangesMode, PREORDER_HOOK_FLAGS, throwError, assertNumber, assertGreaterThan, HEADER_OFFSET, DECLARATION_VIEW, NG_FACTORY_DEF, isForwardRef, getFactoryDef, convertToBitFlags, isRootView, assertTNodeForLView, enterDI, runInInjectorProfilerContext, getCurrentTNode, getLView, emitInjectorToCreateInstanceEvent, emitInstanceCreatedByInjectorEvent, throwProviderNotFoundError, leaveDI, assertNodeInjector, setInjectImplementation, injectRootLimpMode, stringifyForError, cyclicDependencyErrorWithDetails, cyclicDependencyError, setInjectorProfilerContext, assertDirectiveDef, EMBEDDED_VIEW_INJECTOR, T_HOST, NG_ELEMENT_ID, assertIndexInRange, INJECTOR, TVIEW, isComponentDef, isComponentHost, DECLARATION_COMPONENT_VIEW, RuntimeError, NG_PROV_DEF, getClosureSafeProperty, getNativeByTNode, flatten, arrayEquals, ID, isLView, assertDomNode, EMPTY_ARRAY, getComponentLViewByIndex, CONTEXT, unwrapRNode, assertLView, HOST, getLViewParent, isLContainer, CONTAINER_HEADER_OFFSET, CHILD_HEAD, NEXT, Injector, CLEANUP, getComponentDef, getDirectiveDef, InjectionToken, inject, ENVIRONMENT_INITIALIZER, DOCUMENT as DOCUMENT$1, formatRuntimeError, isInSkipHydrationBlock as isInSkipHydrationBlock$1, HYDRATION, isContentQueryHost, setCurrentQueryIndex, isDirectiveHost, XSS_SECURITY_URL, RENDERER, renderStringify, getSelectedTNode, ENVIRONMENT, makeEnvironmentProviders, resetPreOrderHookFlags, PARENT, CHILD_TAIL, assertSame, assertFirstUpdatePass, getSelectedIndex, getTView, assertIndexInDeclRange, setSelectedIndex, stringify, ANIMATIONS, AFTER_RENDER_SEQUENCES_TO_ADD, markAncestorsForTraversal, NgZone, ChangeDetectionScheduler, ErrorHandler, assertNotInReactiveContext, assertInInjectionContext, DestroyRef, ViewContext, EnvironmentInjector, INJECTOR$1, isDestroyed, assertLContainer, MOVED_VIEWS, assertProjectionSlots, NATIVE, REACTIVE_TEMPLATE_CONSUMER, DECLARATION_LCONTAINER, QUERIES, assertParentView, assertNotReactive, ON_DESTROY_HOOKS, assertFunction, EFFECTS, INTERNAL_APPLICATION_ERROR_HANDLER, assertNotSame, isCurrentTNodeParent, setCurrentTNodeAsNotParent, assertHasParent, setCurrentTNode, getElementDepthCount, increaseElementDepthCount, wasLastNodeCreated, setCurrentDirectiveIndex, getCurrentDirectiveIndex, unwrapLView, enterView, leaveView, isCreationMode, markViewForRefresh, setIsInCheckNoChangesMode, setIsRefreshingViews, isExhaustiveCheckNoChanges, requiresRefreshOrTraversal, setBindingIndex, EFFECTS_TO_SCHEDULE, setBindingRootForHostBindings, viewAttachedToChangeDetector, CheckNoChangesMode, isRefreshingViews, removeFromArray, addToArray, updateAncestorTraversalFlagsOnAttach, storeLViewOnDestroy, VIEW_REFS, DOC_PAGE_BASE_URL, assertGreaterThanOrEqual, isInI18nBlock, assertTNodeForTView, getCurrentParentTNode, getCurrentTNodePlaceholderOk, assertTNode, assertTIcu, assertNumberInRange, DEHYDRATED_VIEWS, getNgModuleDef, getPipeDef as getPipeDef$1, getNgModuleDefOrThrow, isStandalone, getTNode, assertLessThan, getOrCreateTViewCleanup, getOrCreateLViewCleanup, debugStringifyTypeForError, assertNotDefined, nextBindingIndex, concatStringsWithSpace, assertInjectImplementationNotEqual, emitInjectEvent, getConstant, getDirectiveDefOrThrow, SVG_NAMESPACE, MATH_ML_NAMESPACE, viewAttachedToContainer, storeCleanupWithContext, signal, createInjectorWithoutInjectorInstances, R3Injector, getNullInjector, internalImportProvidersFrom, initNgDevMode, runInInjectionContext, fillProperties, getBindingsEnabled, lastNodeWasCreated, removeLViewOnDestroy, walkUpViews, getNativeByIndex, assertElement, setInjectorProfiler, EffectRefImpl, NullInjector, INJECTOR_DEF_TYPES, walkProviderTree, getInjectorDef, deepForEach, isTypeProvider, VERSION, isSignal, isInInjectionContext, PendingTasksInternal, ZONELESS_ENABLED, EffectScheduler, arrayInsert2, arraySplice, PendingTasks, decreaseElementDepthCount, assertTNodeCreationIndex, getNamespace, enterSkipHydrationBlock, isSkipHydrationRootTNode, leaveSkipHydrationBlock, getCurrentDirectiveDef, assertIndexInExpandoRange, getBindingIndex, assertOneOf, setInI18nBlock, nextContextImpl, getCurrentQueryIndex, getContextLView, load, keyValueArrayIndexOf, incrementBindingIndex, keyValueArrayGet, keyValueArraySet, isWritableSignal, store, getBindingRoot, providerToFactory, emitProviderConfiguredEvent, isClassProvider, NG_COMP_DEF, forwardRef, ɵɵrestoreView as __restoreView, ɵɵdisableBindings as __disableBindings, ɵɵenableBindings as __enableBindings, ɵɵnamespaceSVG as __namespaceSVG, ɵɵnamespaceMathML as __namespaceMathML, ɵɵnamespaceHTML as __namespaceHTML, ɵɵresetView as __resetView, NG_MOD_DEF, NG_INJ_DEF, NG_DIR_DEF, NG_PIPE_DEF, PROVIDED_ZONELESS, NoopNgZone, angularZoneInstanceIdProperty, scheduleCallbackWithMicrotask, scheduleCallbackWithRafRace, SCHEDULE_IN_ROOT_ZONE, getNativeByTNodeOrNull } from './_pending_tasks-chunk.mjs';
+import { assertString, EMPTY_OBJ, assertFirstCreatePass, assertDefined, assertNotEqual, FLAGS, assertEqual, isInCheckNoChangesMode, PREORDER_HOOK_FLAGS, throwError, assertNumber, assertGreaterThan, HEADER_OFFSET, DECLARATION_VIEW, NG_FACTORY_DEF, isForwardRef, resolveForwardRef, getFactoryDef, convertToBitFlags, isRootView, assertTNodeForLView, enterDI, runInInjectorProfilerContext, getCurrentTNode, getLView, emitInjectorToCreateInstanceEvent, emitInstanceCreatedByInjectorEvent, throwProviderNotFoundError, leaveDI, assertNodeInjector, setInjectImplementation, injectRootLimpMode, stringifyForError, cyclicDependencyErrorWithDetails, cyclicDependencyError, setInjectorProfilerContext, assertDirectiveDef, EMBEDDED_VIEW_INJECTOR, T_HOST, NG_ELEMENT_ID, assertIndexInRange, INJECTOR, TVIEW, isComponentDef, isComponentHost, DECLARATION_COMPONENT_VIEW, makeEnvironmentProviders, InjectionToken, _global, ɵɵinvalidFactoryDep as __invalidFactoryDep, ɵɵinject as __inject, ɵɵdefineInjector as __defineInjector, ɵɵdefineInjectable as __defineInjectable, newArray, attachInjectFlag, RuntimeError, NG_PROV_DEF, getClosureSafeProperty, getNativeByTNode, registerSpecialProvider, flatten, arrayEquals, ID, isLView, assertDomNode, EMPTY_ARRAY, getComponentLViewByIndex, CONTEXT, unwrapRNode, assertLView, HOST, getLViewParent, isLContainer, CONTAINER_HEADER_OFFSET, CHILD_HEAD, NEXT, Injector, CLEANUP, getComponentDef, getDirectiveDef, APP_ID, inject, makeStateKey, formatRuntimeError, TransferState, isInSkipHydrationBlock as isInSkipHydrationBlock$1, HYDRATION, isContentQueryHost, setCurrentQueryIndex, isDirectiveHost, XSS_SECURITY_URL, RENDERER, renderStringify, getSelectedTNode, ENVIRONMENT, resetPreOrderHookFlags, PARENT, CHILD_TAIL, assertSame, assertFirstUpdatePass, getSelectedIndex, getTView, assertIndexInDeclRange, setSelectedIndex, stringify, ANIMATIONS, AFTER_RENDER_SEQUENCES_TO_ADD, markAncestorsForTraversal, NgZone, ChangeDetectionScheduler, ErrorHandler, assertNotInReactiveContext, assertInInjectionContext, DestroyRef, ViewContext, EnvironmentInjector, INJECTOR$1, isDestroyed, assertLContainer, MOVED_VIEWS, assertProjectionSlots, NATIVE, REACTIVE_TEMPLATE_CONSUMER, DECLARATION_LCONTAINER, QUERIES, assertParentView, assertNotReactive, ON_DESTROY_HOOKS, assertFunction, EFFECTS, INTERNAL_APPLICATION_ERROR_HANDLER, assertNotSame, isCurrentTNodeParent, setCurrentTNodeAsNotParent, assertHasParent, setCurrentTNode, getElementDepthCount, increaseElementDepthCount, wasLastNodeCreated, setCurrentDirectiveIndex, getCurrentDirectiveIndex, unwrapLView, enterView, leaveView, isCreationMode, markViewForRefresh, setIsInCheckNoChangesMode, setIsRefreshingViews, isExhaustiveCheckNoChanges, requiresRefreshOrTraversal, setBindingIndex, EFFECTS_TO_SCHEDULE, setBindingRootForHostBindings, viewAttachedToChangeDetector, CheckNoChangesMode, isRefreshingViews, removeFromArray, addToArray, updateAncestorTraversalFlagsOnAttach, storeLViewOnDestroy, VIEW_REFS, DOC_PAGE_BASE_URL, assertGreaterThanOrEqual, isInI18nBlock, assertTNodeForTView, getCurrentParentTNode, getCurrentTNodePlaceholderOk, assertTIcu, assertTNode, assertNumberInRange, DEHYDRATED_VIEWS, getNgModuleDef, getPipeDef as getPipeDef$1, getNgModuleDefOrThrow, isStandalone, getTNode, assertLessThan, getOrCreateTViewCleanup, getOrCreateLViewCleanup, debugStringifyTypeForError, assertNotDefined, nextBindingIndex, concatStringsWithSpace, assertInjectImplementationNotEqual, emitInjectEvent, getConstant, getDirectiveDefOrThrow, DOCUMENT as DOCUMENT$1, SVG_NAMESPACE, MATH_ML_NAMESPACE, viewAttachedToContainer, storeCleanupWithContext, signal, createInjectorWithoutInjectorInstances, R3Injector, getNullInjector, internalImportProvidersFrom, initNgDevMode, runInInjectionContext, fillProperties, getBindingsEnabled, lastNodeWasCreated, removeLViewOnDestroy, walkUpViews, getNativeByIndex, assertElement, setInjectorProfiler, EffectRefImpl, NullInjector, getAllSpecialProviders, ENVIRONMENT_INITIALIZER, INJECTOR_DEF_TYPES, walkProviderTree, getInjectorDef, deepForEach, isTypeProvider, VERSION, retrieveTransferredState, isSignal, isInInjectionContext, PendingTasksInternal, ZONELESS_ENABLED, EffectScheduler, arrayInsert2, arraySplice, PendingTasks, decreaseElementDepthCount, assertTNodeCreationIndex, getNamespace, enterSkipHydrationBlock, isSkipHydrationRootTNode, leaveSkipHydrationBlock, getCurrentDirectiveDef, getBindingIndex, assertIndexInExpandoRange, assertOneOf, setInI18nBlock, nextContextImpl, getCurrentQueryIndex, getContextLView, load, keyValueArrayIndexOf, incrementBindingIndex, keyValueArrayGet, keyValueArraySet, isWritableSignal, store, getBindingRoot, providerToFactory, emitProviderConfiguredEvent, isClassProvider, NG_COMP_DEF, forwardRef, ɵɵrestoreView as __restoreView, ɵɵdisableBindings as __disableBindings, ɵɵenableBindings as __enableBindings, ɵɵnamespaceSVG as __namespaceSVG, ɵɵnamespaceMathML as __namespaceMathML, ɵɵnamespaceHTML as __namespaceHTML, ɵɵresetView as __resetView, NG_MOD_DEF, NG_INJ_DEF, NG_DIR_DEF, NG_PIPE_DEF, PROVIDED_ZONELESS, NoopNgZone, angularZoneInstanceIdProperty, scheduleCallbackWithMicrotask, scheduleCallbackWithRafRace, SCHEDULE_IN_ROOT_ZONE, getNativeByTNodeOrNull } from './_pending_tasks-chunk.mjs';
 import { setActiveConsumer as setActiveConsumer$1 } from '@angular/core/primitives/signals';
 import { setActiveConsumer, SIGNAL, consumerDestroy, REACTIVE_NODE, consumerPollProducersForChange, consumerBeforeComputation, getActiveConsumer, consumerAfterComputation, createComputed, setThrowInvalidWriteToSignalError } from './_effect-chunk.mjs';
 import { Subject, Subscription } from 'rxjs';
@@ -17,1168 +17,1204 @@ function noSideEffects(fn) {
   }.toString();
 }
 
-const ANNOTATIONS = '__annotations__';
-const PARAMETERS = '__parameters__';
-const PROP_METADATA = '__prop__metadata__';
-function makeDecorator(name, props, parentClass, additionalProcessing, typeFn) {
-  return noSideEffects(() => {
-    const metaCtor = makeMetadataCtor(props);
-    function DecoratorFactory(...args) {
-      if (this instanceof DecoratorFactory) {
-        metaCtor.call(this, ...args);
-        return this;
-      }
-      const annotationInstance = new DecoratorFactory(...args);
-      return function TypeDecorator(cls) {
-        if (typeFn) typeFn(cls, ...args);
-        const annotations = cls.hasOwnProperty(ANNOTATIONS) ? cls[ANNOTATIONS] : Object.defineProperty(cls, ANNOTATIONS, {
-          value: []
-        })[ANNOTATIONS];
-        annotations.push(annotationInstance);
-        return cls;
-      };
-    }
-    if (parentClass) {
-      DecoratorFactory.prototype = Object.create(parentClass.prototype);
-    }
-    DecoratorFactory.prototype.ngMetadataName = name;
-    DecoratorFactory.annotationCls = DecoratorFactory;
-    return DecoratorFactory;
-  });
+function applyValueToInputField(instance, inputSignalNode, privateName, value) {
+  if (inputSignalNode !== null) {
+    inputSignalNode.applyValueToInputSignal(inputSignalNode, value);
+  } else {
+    instance[privateName] = value;
+  }
 }
-function makeMetadataCtor(props) {
-  return function ctor(...args) {
-    if (props) {
-      const values = props(...args);
-      for (const propName in values) {
-        this[propName] = values[propName];
-      }
-    }
-  };
+
+class SimpleChange {
+  previousValue;
+  currentValue;
+  firstChange;
+  constructor(previousValue, currentValue, firstChange) {
+    this.previousValue = previousValue;
+    this.currentValue = currentValue;
+    this.firstChange = firstChange;
+  }
+  isFirstChange() {
+    return this.firstChange;
+  }
 }
-function makeParamDecorator(name, props, parentClass) {
-  return noSideEffects(() => {
-    const metaCtor = makeMetadataCtor(props);
-    function ParamDecoratorFactory(...args) {
-      if (this instanceof ParamDecoratorFactory) {
-        metaCtor.apply(this, args);
-        return this;
-      }
-      const annotationInstance = new ParamDecoratorFactory(...args);
-      ParamDecorator.annotation = annotationInstance;
-      return ParamDecorator;
-      function ParamDecorator(cls, unusedKey, index) {
-        const parameters = cls.hasOwnProperty(PARAMETERS) ? cls[PARAMETERS] : Object.defineProperty(cls, PARAMETERS, {
-          value: []
-        })[PARAMETERS];
-        while (parameters.length <= index) {
-          parameters.push(null);
-        }
-        (parameters[index] = parameters[index] || []).push(annotationInstance);
-        return cls;
-      }
-    }
-    ParamDecoratorFactory.prototype.ngMetadataName = name;
-    ParamDecoratorFactory.annotationCls = ParamDecoratorFactory;
-    return ParamDecoratorFactory;
-  });
+
+const ɵɵNgOnChangesFeature = /* @__PURE__ */(() => {
+  const ɵɵNgOnChangesFeatureImpl = () => NgOnChangesFeatureImpl;
+  ɵɵNgOnChangesFeatureImpl.ngInherit = true;
+  return ɵɵNgOnChangesFeatureImpl;
+})();
+function NgOnChangesFeatureImpl(definition) {
+  if (definition.type.prototype.ngOnChanges) {
+    definition.setInput = ngOnChangesSetInput;
+  }
+  return rememberChangeHistoryAndInvokeOnChangesHook;
 }
-function makePropDecorator(name, props, parentClass, additionalProcessing) {
-  return noSideEffects(() => {
-    const metaCtor = makeMetadataCtor(props);
-    function PropDecoratorFactory(...args) {
-      if (this instanceof PropDecoratorFactory) {
-        metaCtor.apply(this, args);
-        return this;
-      }
-      const decoratorInstance = new PropDecoratorFactory(...args);
-      function PropDecorator(target, name) {
-        if (target === undefined) {
-          throw new Error('Standard Angular field decorators are not supported in JIT mode.');
-        }
-        const constructor = target.constructor;
-        const meta = constructor.hasOwnProperty(PROP_METADATA) ? constructor[PROP_METADATA] : Object.defineProperty(constructor, PROP_METADATA, {
-          value: {}
-        })[PROP_METADATA];
-        meta[name] = meta.hasOwnProperty(name) && meta[name] || [];
-        meta[name].unshift(decoratorInstance);
+function rememberChangeHistoryAndInvokeOnChangesHook() {
+  const simpleChangesStore = getSimpleChangesStore(this);
+  const current = simpleChangesStore?.current;
+  if (current) {
+    const previous = simpleChangesStore.previous;
+    if (previous === EMPTY_OBJ) {
+      simpleChangesStore.previous = current;
+    } else {
+      for (let key in current) {
+        previous[key] = current[key];
       }
-      return PropDecorator;
     }
-    if (parentClass) {
-      PropDecoratorFactory.prototype = Object.create(parentClass.prototype);
-    }
-    PropDecoratorFactory.prototype.ngMetadataName = name;
-    PropDecoratorFactory.annotationCls = PropDecoratorFactory;
-    return PropDecoratorFactory;
+    simpleChangesStore.current = null;
+    this.ngOnChanges(current);
+  }
+}
+function ngOnChangesSetInput(instance, inputSignalNode, value, publicName, privateName) {
+  const declaredName = this.declaredInputs[publicName];
+  ngDevMode && assertString(declaredName, 'Name of input in ngOnChanges has to be a string');
+  const simpleChangesStore = getSimpleChangesStore(instance) || setSimpleChangesStore(instance, {
+    previous: EMPTY_OBJ,
+    current: null
   });
+  const current = simpleChangesStore.current || (simpleChangesStore.current = {});
+  const previous = simpleChangesStore.previous;
+  const previousChange = previous[declaredName];
+  current[declaredName] = new SimpleChange(previousChange && previousChange.currentValue, value, previous === EMPTY_OBJ);
+  applyValueToInputField(instance, inputSignalNode, privateName, value);
+}
+const SIMPLE_CHANGES_STORE = '__ngSimpleChanges__';
+function getSimpleChangesStore(instance) {
+  return instance[SIMPLE_CHANGES_STORE] || null;
+}
+function setSimpleChangesStore(instance, store) {
+  return instance[SIMPLE_CHANGES_STORE] = store;
 }
 
-const Inject = attachInjectFlag(makeParamDecorator('Inject', token => ({
-  token
-})), -1);
-const Optional = attachInjectFlag(makeParamDecorator('Optional'), 8);
-const Self = attachInjectFlag(makeParamDecorator('Self'), 2);
-const SkipSelf = attachInjectFlag(makeParamDecorator('SkipSelf'), 4);
-const Host = attachInjectFlag(makeParamDecorator('Host'), 1);
-
-function getCompilerFacade(request) {
-  const globalNg = _global['ng'];
-  if (globalNg && globalNg.ɵcompilerFacade) {
-    return globalNg.ɵcompilerFacade;
+const profilerCallbacks = [];
+const NOOP_PROFILER_REMOVAL = () => {};
+function removeProfiler(profiler) {
+  const profilerIdx = profilerCallbacks.indexOf(profiler);
+  if (profilerIdx !== -1) {
+    profilerCallbacks.splice(profilerIdx, 1);
   }
-  if (typeof ngDevMode === 'undefined' || ngDevMode) {
-    console.error(`JIT compilation failed for ${request.kind}`, request.type);
-    let message = `The ${request.kind} '${request.type.name}' needs to be compiled using the JIT compiler, but '@angular/compiler' is not available.\n\n`;
-    if (request.usage === 1) {
-      message += `The ${request.kind} is part of a library that has been partially compiled.\n`;
-      message += `However, the Angular Linker has not processed the library such that JIT compilation is used as fallback.\n`;
-      message += '\n';
-      message += `Ideally, the library is processed using the Angular Linker to become fully AOT compiled.\n`;
-    } else {
-      message += `JIT compilation is discouraged for production use-cases! Consider using AOT mode instead.\n`;
+}
+function setProfiler(profiler) {
+  if (profiler !== null) {
+    if (!profilerCallbacks.includes(profiler)) {
+      profilerCallbacks.push(profiler);
     }
-    message += `Alternatively, the JIT compiler should be loaded by bootstrapping using '@angular/platform-browser-dynamic' or '@angular/platform-server',\n`;
-    message += `or manually provide the compiler with 'import "@angular/compiler";' before bootstrapping.`;
-    throw new Error(message);
+    return () => removeProfiler(profiler);
   } else {
-    throw new Error('JIT compiler unavailable');
+    profilerCallbacks.length = 0;
+    return NOOP_PROFILER_REMOVAL;
   }
 }
-
-function ɵɵdefineService(opts) {
-  return {
-    token: opts.token,
-    providedIn: opts.autoProvided === false ? null : 'root',
-    factory: opts.factory,
-    value: undefined
-  };
-}
-
-const angularCoreDiEnv = {
-  'ɵɵdefineInjectable': __defineInjectable,
-  'ɵɵdefineInjector': __defineInjector,
-  'ɵɵdefineService': ɵɵdefineService,
-  'ɵɵinject': __inject,
-  'ɵɵinvalidFactoryDep': __invalidFactoryDep,
-  'resolveForwardRef': resolveForwardRef
+const profiler = function (event, instance = null, eventFn) {
+  for (let i = 0; i < profilerCallbacks.length; i++) {
+    const profilerCallback = profilerCallbacks[i];
+    profilerCallback(event, instance, eventFn);
+  }
 };
 
-const Type = Function;
-function isType(v) {
-  return typeof v === 'function';
-}
+var ProfilerEvent;
+(function (ProfilerEvent) {
+  ProfilerEvent[ProfilerEvent["TemplateCreateStart"] = 0] = "TemplateCreateStart";
+  ProfilerEvent[ProfilerEvent["TemplateCreateEnd"] = 1] = "TemplateCreateEnd";
+  ProfilerEvent[ProfilerEvent["TemplateUpdateStart"] = 2] = "TemplateUpdateStart";
+  ProfilerEvent[ProfilerEvent["TemplateUpdateEnd"] = 3] = "TemplateUpdateEnd";
+  ProfilerEvent[ProfilerEvent["LifecycleHookStart"] = 4] = "LifecycleHookStart";
+  ProfilerEvent[ProfilerEvent["LifecycleHookEnd"] = 5] = "LifecycleHookEnd";
+  ProfilerEvent[ProfilerEvent["OutputStart"] = 6] = "OutputStart";
+  ProfilerEvent[ProfilerEvent["OutputEnd"] = 7] = "OutputEnd";
+  ProfilerEvent[ProfilerEvent["BootstrapApplicationStart"] = 8] = "BootstrapApplicationStart";
+  ProfilerEvent[ProfilerEvent["BootstrapApplicationEnd"] = 9] = "BootstrapApplicationEnd";
+  ProfilerEvent[ProfilerEvent["BootstrapComponentStart"] = 10] = "BootstrapComponentStart";
+  ProfilerEvent[ProfilerEvent["BootstrapComponentEnd"] = 11] = "BootstrapComponentEnd";
+  ProfilerEvent[ProfilerEvent["ChangeDetectionStart"] = 12] = "ChangeDetectionStart";
+  ProfilerEvent[ProfilerEvent["ChangeDetectionEnd"] = 13] = "ChangeDetectionEnd";
+  ProfilerEvent[ProfilerEvent["ChangeDetectionSyncStart"] = 14] = "ChangeDetectionSyncStart";
+  ProfilerEvent[ProfilerEvent["ChangeDetectionSyncEnd"] = 15] = "ChangeDetectionSyncEnd";
+  ProfilerEvent[ProfilerEvent["AfterRenderHooksStart"] = 16] = "AfterRenderHooksStart";
+  ProfilerEvent[ProfilerEvent["AfterRenderHooksEnd"] = 17] = "AfterRenderHooksEnd";
+  ProfilerEvent[ProfilerEvent["ComponentStart"] = 18] = "ComponentStart";
+  ProfilerEvent[ProfilerEvent["ComponentEnd"] = 19] = "ComponentEnd";
+  ProfilerEvent[ProfilerEvent["DeferBlockStateStart"] = 20] = "DeferBlockStateStart";
+  ProfilerEvent[ProfilerEvent["DeferBlockStateEnd"] = 21] = "DeferBlockStateEnd";
+  ProfilerEvent[ProfilerEvent["DynamicComponentStart"] = 22] = "DynamicComponentStart";
+  ProfilerEvent[ProfilerEvent["DynamicComponentEnd"] = 23] = "DynamicComponentEnd";
+  ProfilerEvent[ProfilerEvent["HostBindingsUpdateStart"] = 24] = "HostBindingsUpdateStart";
+  ProfilerEvent[ProfilerEvent["HostBindingsUpdateEnd"] = 25] = "HostBindingsUpdateEnd";
+})(ProfilerEvent || (ProfilerEvent = {}));
 
-const ES5_DELEGATE_CTOR = /^function\s+\S+\(\)\s*{[\s\S]+\.apply\(this,\s*(arguments|(?:[^()]+\(\[\],)?[^()]+\(arguments\).*)\)/;
-const ES2015_INHERITED_CLASS = /^class\s+[A-Za-z\d$_]*\s*extends\s+[^{]+{/;
-const ES2015_INHERITED_CLASS_WITH_CTOR = /^class\s+[A-Za-z\d$_]*\s*extends\s+[^{]+{[\s\S]*constructor\s*\(/;
-const ES2015_INHERITED_CLASS_WITH_DELEGATE_CTOR = /^class\s+[A-Za-z\d$_]*\s*extends\s+[^{]+{[\s\S]*constructor\s*\(\)\s*{[^}]*super\(\.\.\.arguments\)/;
-function isDelegateCtor(typeStr) {
-  return ES5_DELEGATE_CTOR.test(typeStr) || ES2015_INHERITED_CLASS_WITH_DELEGATE_CTOR.test(typeStr) || ES2015_INHERITED_CLASS.test(typeStr) && !ES2015_INHERITED_CLASS_WITH_CTOR.test(typeStr);
-}
-class ReflectionCapabilities {
-  _reflect;
-  constructor(reflect) {
-    this._reflect = reflect || _global['Reflect'];
-  }
-  factory(t) {
-    return (...args) => new t(...args);
-  }
-  _zipTypesAndAnnotations(paramTypes, paramAnnotations) {
-    let result;
-    if (typeof paramTypes === 'undefined') {
-      result = newArray(paramAnnotations.length);
-    } else {
-      result = newArray(paramTypes.length);
-    }
-    for (let i = 0; i < result.length; i++) {
-      if (typeof paramTypes === 'undefined') {
-        result[i] = [];
-      } else if (paramTypes[i] && paramTypes[i] != Object) {
-        result[i] = [paramTypes[i]];
-      } else {
-        result[i] = [];
-      }
-      if (paramAnnotations && paramAnnotations[i] != null) {
-        result[i] = result[i].concat(paramAnnotations[i]);
-      }
-    }
-    return result;
+function registerPreOrderHooks(directiveIndex, directiveDef, tView) {
+  ngDevMode && assertFirstCreatePass(tView);
+  const {
+    ngOnChanges,
+    ngOnInit,
+    ngDoCheck
+  } = directiveDef.type.prototype;
+  if (ngOnChanges) {
+    const wrappedOnChanges = NgOnChangesFeatureImpl(directiveDef);
+    (tView.preOrderHooks ??= []).push(directiveIndex, wrappedOnChanges);
+    (tView.preOrderCheckHooks ??= []).push(directiveIndex, wrappedOnChanges);
   }
-  _ownParameters(type, parentCtor) {
-    const typeStr = type.toString();
-    if (isDelegateCtor(typeStr)) {
-      return null;
-    }
-    if (type.parameters && type.parameters !== parentCtor.parameters) {
-      return type.parameters;
-    }
-    const tsickleCtorParams = type.ctorParameters;
-    if (tsickleCtorParams && tsickleCtorParams !== parentCtor.ctorParameters) {
-      const ctorParameters = typeof tsickleCtorParams === 'function' ? tsickleCtorParams() : tsickleCtorParams;
-      const paramTypes = ctorParameters.map(ctorParam => ctorParam && ctorParam.type);
-      const paramAnnotations = ctorParameters.map(ctorParam => ctorParam && convertTsickleDecoratorIntoMetadata(ctorParam.decorators));
-      return this._zipTypesAndAnnotations(paramTypes, paramAnnotations);
-    }
-    const paramAnnotations = type.hasOwnProperty(PARAMETERS) && type[PARAMETERS];
-    const paramTypes = this._reflect && this._reflect.getOwnMetadata && this._reflect.getOwnMetadata('design:paramtypes', type);
-    if (paramTypes || paramAnnotations) {
-      return this._zipTypesAndAnnotations(paramTypes, paramAnnotations);
-    }
-    return newArray(type.length);
+  if (ngOnInit) {
+    (tView.preOrderHooks ??= []).push(0 - directiveIndex, ngOnInit);
   }
-  parameters(type) {
-    if (!isType(type)) {
-      return [];
-    }
-    const parentCtor = getParentCtor(type);
-    let parameters = this._ownParameters(type, parentCtor);
-    if (!parameters && parentCtor !== Object) {
-      parameters = this.parameters(parentCtor);
-    }
-    return parameters || [];
+  if (ngDoCheck) {
+    (tView.preOrderHooks ??= []).push(directiveIndex, ngDoCheck);
+    (tView.preOrderCheckHooks ??= []).push(directiveIndex, ngDoCheck);
   }
-  _ownAnnotations(typeOrFunc, parentCtor) {
-    if (typeOrFunc.annotations && typeOrFunc.annotations !== parentCtor.annotations) {
-      let annotations = typeOrFunc.annotations;
-      if (typeof annotations === 'function' && annotations.annotations) {
-        annotations = annotations.annotations;
-      }
-      return annotations;
-    }
-    if (typeOrFunc.decorators && typeOrFunc.decorators !== parentCtor.decorators) {
-      return convertTsickleDecoratorIntoMetadata(typeOrFunc.decorators);
-    }
-    if (typeOrFunc.hasOwnProperty(ANNOTATIONS)) {
-      return typeOrFunc[ANNOTATIONS];
+}
+function registerPostOrderHooks(tView, tNode) {
+  ngDevMode && assertFirstCreatePass(tView);
+  for (let i = tNode.directiveStart, end = tNode.directiveEnd; i < end; i++) {
+    const directiveDef = tView.data[i];
+    ngDevMode && assertDefined(directiveDef, 'Expecting DirectiveDef');
+    const lifecycleHooks = directiveDef.type.prototype;
+    const {
+      ngAfterContentInit,
+      ngAfterContentChecked,
+      ngAfterViewInit,
+      ngAfterViewChecked,
+      ngOnDestroy
+    } = lifecycleHooks;
+    if (ngAfterContentInit) {
+      (tView.contentHooks ??= []).push(-i, ngAfterContentInit);
     }
-    return null;
-  }
-  annotations(typeOrFunc) {
-    if (!isType(typeOrFunc)) {
-      return [];
+    if (ngAfterContentChecked) {
+      (tView.contentHooks ??= []).push(i, ngAfterContentChecked);
+      (tView.contentCheckHooks ??= []).push(i, ngAfterContentChecked);
     }
-    const parentCtor = getParentCtor(typeOrFunc);
-    const ownAnnotations = this._ownAnnotations(typeOrFunc, parentCtor) || [];
-    const parentAnnotations = parentCtor !== Object ? this.annotations(parentCtor) : [];
-    return parentAnnotations.concat(ownAnnotations);
-  }
-  _ownPropMetadata(typeOrFunc, parentCtor) {
-    if (typeOrFunc.propMetadata && typeOrFunc.propMetadata !== parentCtor.propMetadata) {
-      let propMetadata = typeOrFunc.propMetadata;
-      if (typeof propMetadata === 'function' && propMetadata.propMetadata) {
-        propMetadata = propMetadata.propMetadata;
-      }
-      return propMetadata;
+    if (ngAfterViewInit) {
+      (tView.viewHooks ??= []).push(-i, ngAfterViewInit);
     }
-    if (typeOrFunc.propDecorators && typeOrFunc.propDecorators !== parentCtor.propDecorators) {
-      const propDecorators = typeOrFunc.propDecorators;
-      const propMetadata = {};
-      Object.keys(propDecorators).forEach(prop => {
-        propMetadata[prop] = convertTsickleDecoratorIntoMetadata(propDecorators[prop]);
-      });
-      return propMetadata;
+    if (ngAfterViewChecked) {
+      (tView.viewHooks ??= []).push(i, ngAfterViewChecked);
+      (tView.viewCheckHooks ??= []).push(i, ngAfterViewChecked);
     }
-    if (typeOrFunc.hasOwnProperty(PROP_METADATA)) {
-      return typeOrFunc[PROP_METADATA];
+    if (ngOnDestroy != null) {
+      (tView.destroyHooks ??= []).push(i, ngOnDestroy);
     }
-    return null;
   }
-  propMetadata(typeOrFunc) {
-    if (!isType(typeOrFunc)) {
-      return {};
-    }
-    const parentCtor = getParentCtor(typeOrFunc);
-    const propMetadata = {};
-    if (parentCtor !== Object) {
-      const parentPropMetadata = this.propMetadata(parentCtor);
-      Object.keys(parentPropMetadata).forEach(propName => {
-        propMetadata[propName] = parentPropMetadata[propName];
-      });
-    }
-    const ownPropMetadata = this._ownPropMetadata(typeOrFunc, parentCtor);
-    if (ownPropMetadata) {
-      Object.keys(ownPropMetadata).forEach(propName => {
-        const decorators = [];
-        if (propMetadata.hasOwnProperty(propName)) {
-          decorators.push(...propMetadata[propName]);
-        }
-        decorators.push(...ownPropMetadata[propName]);
-        propMetadata[propName] = decorators;
-      });
-    }
-    return propMetadata;
+}
+function executeCheckHooks(lView, hooks, nodeIndex) {
+  callHooks(lView, hooks, 3, nodeIndex);
+}
+function executeInitAndCheckHooks(lView, hooks, initPhase, nodeIndex) {
+  ngDevMode && assertNotEqual(initPhase, 3, 'Init pre-order hooks should not be called more than once');
+  if ((lView[FLAGS] & 3) === initPhase) {
+    callHooks(lView, hooks, initPhase, nodeIndex);
   }
-  ownPropMetadata(typeOrFunc) {
-    if (!isType(typeOrFunc)) {
-      return {};
-    }
-    return this._ownPropMetadata(typeOrFunc, getParentCtor(typeOrFunc)) || {};
+}
+function incrementInitPhaseFlags(lView, initPhase) {
+  ngDevMode && assertNotEqual(initPhase, 3, 'Init hooks phase should not be incremented after all init hooks have been run.');
+  let flags = lView[FLAGS];
+  if ((flags & 3) === initPhase) {
+    flags &= 16383;
+    flags += 1;
+    lView[FLAGS] = flags;
   }
-  hasLifecycleHook(type, lcProperty) {
-    return type instanceof Type && lcProperty in type.prototype;
+}
+function callHooks(currentView, arr, initPhase, currentNodeIndex) {
+  ngDevMode && assertEqual(isInCheckNoChangesMode(), false, 'Hooks should never be run when in check no changes mode.');
+  const startIndex = currentNodeIndex !== undefined ? currentView[PREORDER_HOOK_FLAGS] & 65535 : 0;
+  const nodeIndexLimit = currentNodeIndex != null ? currentNodeIndex : -1;
+  const max = arr.length - 1;
+  let lastNodeIndexFound = 0;
+  for (let i = startIndex; i < max; i++) {
+    const hook = arr[i + 1];
+    if (typeof hook === 'number') {
+      lastNodeIndexFound = arr[i];
+      if (currentNodeIndex != null && lastNodeIndexFound >= currentNodeIndex) {
+        break;
+      }
+    } else {
+      const isInitHook = arr[i] < 0;
+      if (isInitHook) {
+        currentView[PREORDER_HOOK_FLAGS] += 65536;
+      }
+      if (lastNodeIndexFound < nodeIndexLimit || nodeIndexLimit == -1) {
+        callHook(currentView, initPhase, arr, i);
+        currentView[PREORDER_HOOK_FLAGS] = (currentView[PREORDER_HOOK_FLAGS] & 4294901760) + i + 2;
+      }
+      i++;
+    }
   }
 }
-function convertTsickleDecoratorIntoMetadata(decoratorInvocations) {
-  if (!decoratorInvocations) {
-    return [];
+function callHookInternal(directive, hook) {
+  profiler(ProfilerEvent.LifecycleHookStart, directive, hook);
+  const prevConsumer = setActiveConsumer(null);
+  try {
+    hook.call(directive);
+  } finally {
+    setActiveConsumer(prevConsumer);
+    profiler(ProfilerEvent.LifecycleHookEnd, directive, hook);
   }
-  return decoratorInvocations.map(decoratorInvocation => {
-    const decoratorType = decoratorInvocation.type;
-    const annotationCls = decoratorType.annotationCls;
-    const annotationArgs = decoratorInvocation.args ? decoratorInvocation.args : [];
-    return new annotationCls(...annotationArgs);
-  });
 }
-function getParentCtor(ctor) {
-  const parentProto = ctor.prototype ? Object.getPrototypeOf(ctor.prototype) : null;
-  const parentCtor = parentProto ? parentProto.constructor : null;
-  return parentCtor || Object;
+function callHook(currentView, initPhase, arr, i) {
+  const isInitHook = arr[i] < 0;
+  const hook = arr[i + 1];
+  const directiveIndex = isInitHook ? -arr[i] : arr[i];
+  const directive = currentView[directiveIndex];
+  if (isInitHook) {
+    const indexWithintInitPhase = currentView[FLAGS] >> 14;
+    if (indexWithintInitPhase < currentView[PREORDER_HOOK_FLAGS] >> 16 && (currentView[FLAGS] & 3) === initPhase) {
+      currentView[FLAGS] += 16384;
+      callHookInternal(directive, hook);
+    }
+  } else {
+    callHookInternal(directive, hook);
+  }
 }
 
-function applyValueToInputField(instance, inputSignalNode, privateName, value) {
-  if (inputSignalNode !== null) {
-    inputSignalNode.applyValueToInputSignal(inputSignalNode, value);
-  } else {
-    instance[privateName] = value;
+const NO_PARENT_INJECTOR = -1;
+class NodeInjectorFactory {
+  factory;
+  name;
+  injectImpl;
+  resolving = false;
+  canSeeViewProviders;
+  multi;
+  componentProviders;
+  index;
+  providerFactory;
+  constructor(factory, isViewProvider, injectImplementation, name) {
+    this.factory = factory;
+    this.name = name;
+    ngDevMode && assertDefined(factory, 'Factory not specified');
+    ngDevMode && assertEqual(typeof factory, 'function', 'Expected factory function.');
+    this.canSeeViewProviders = isViewProvider;
+    this.injectImpl = injectImplementation;
   }
 }
 
-class SimpleChange {
-  previousValue;
-  currentValue;
-  firstChange;
-  constructor(previousValue, currentValue, firstChange) {
-    this.previousValue = previousValue;
-    this.currentValue = currentValue;
-    this.firstChange = firstChange;
+function toTNodeTypeAsString(tNodeType) {
+  let text = '';
+  tNodeType & 1 && (text += '|Text');
+  tNodeType & 2 && (text += '|Element');
+  tNodeType & 4 && (text += '|Container');
+  tNodeType & 8 && (text += '|ElementContainer');
+  tNodeType & 16 && (text += '|Projection');
+  tNodeType & 32 && (text += '|IcuContainer');
+  tNodeType & 64 && (text += '|Placeholder');
+  tNodeType & 128 && (text += '|LetDeclaration');
+  return text.length > 0 ? text.substring(1) : text;
+}
+function isTNodeShape(value) {
+  return value != null && typeof value === 'object' && (value.insertBeforeIndex === null || typeof value.insertBeforeIndex === 'number' || Array.isArray(value.insertBeforeIndex));
+}
+function isLetDeclaration(tNode) {
+  return !!(tNode.type & 128);
+}
+function hasClassInput(tNode) {
+  return (tNode.flags & 8) !== 0;
+}
+function hasStyleInput(tNode) {
+  return (tNode.flags & 16) !== 0;
+}
+
+function assertTNodeType(tNode, expectedTypes, message) {
+  assertDefined(tNode, 'should be called with a TNode');
+  if ((tNode.type & expectedTypes) === 0) {
+    throwError(message || `Expected [${toTNodeTypeAsString(expectedTypes)}] but got ${toTNodeTypeAsString(tNode.type)}.`);
   }
-  isFirstChange() {
-    return this.firstChange;
+}
+function assertPureTNodeType(type) {
+  if (!(type === 2 || type === 1 || type === 4 || type === 8 || type === 32 || type === 16 || type === 64 || type === 128)) {
+    throwError(`Expected TNodeType to have only a single type selected, but got ${toTNodeTypeAsString(type)}.`);
   }
 }
 
-const ɵɵNgOnChangesFeature = /* @__PURE__ */(() => {
-  const ɵɵNgOnChangesFeatureImpl = () => NgOnChangesFeatureImpl;
-  ɵɵNgOnChangesFeatureImpl.ngInherit = true;
-  return ɵɵNgOnChangesFeatureImpl;
-})();
-function NgOnChangesFeatureImpl(definition) {
-  if (definition.type.prototype.ngOnChanges) {
-    definition.setInput = ngOnChangesSetInput;
+function setUpAttributes(renderer, native, attrs) {
+  let i = 0;
+  while (i < attrs.length) {
+    const value = attrs[i];
+    if (typeof value === 'number') {
+      if (value !== 0) {
+        break;
+      }
+      i++;
+      const namespaceURI = attrs[i++];
+      const attrName = attrs[i++];
+      const attrVal = attrs[i++];
+      renderer.setAttribute(native, attrName, attrVal, namespaceURI);
+    } else {
+      const attrName = value;
+      const attrVal = attrs[++i];
+      if (isAnimationProp(attrName)) {
+        renderer.setProperty(native, attrName, attrVal);
+      } else {
+        renderer.setAttribute(native, attrName, attrVal);
+      }
+      i++;
+    }
   }
-  return rememberChangeHistoryAndInvokeOnChangesHook;
+  return i;
 }
-function rememberChangeHistoryAndInvokeOnChangesHook() {
-  const simpleChangesStore = getSimpleChangesStore(this);
-  const current = simpleChangesStore?.current;
-  if (current) {
-    const previous = simpleChangesStore.previous;
-    if (previous === EMPTY_OBJ) {
-      simpleChangesStore.previous = current;
-    } else {
-      for (let key in current) {
-        previous[key] = current[key];
+function isNameOnlyAttributeMarker(marker) {
+  return marker === 3 || marker === 4 || marker === 6;
+}
+function isAnimationProp(name) {
+  return name.charCodeAt(0) === 64;
+}
+function mergeHostAttrs(dst, src) {
+  if (src === null || src.length === 0) ; else if (dst === null || dst.length === 0) {
+    dst = src.slice();
+  } else {
+    let srcMarker = -1;
+    for (let i = 0; i < src.length; i++) {
+      const item = src[i];
+      if (typeof item === 'number') {
+        srcMarker = item;
+      } else {
+        if (srcMarker === 0) ; else if (srcMarker === -1 || srcMarker === 2) {
+          mergeHostAttribute(dst, srcMarker, item, null, src[++i]);
+        } else {
+          mergeHostAttribute(dst, srcMarker, item, null, null);
+        }
       }
     }
-    simpleChangesStore.current = null;
-    this.ngOnChanges(current);
+  }
+  return dst;
+}
+function mergeHostAttribute(dst, marker, key1, key2, value) {
+  let i = 0;
+  let markerInsertPosition = dst.length;
+  if (marker === -1) {
+    markerInsertPosition = -1;
+  } else {
+    while (i < dst.length) {
+      const dstValue = dst[i++];
+      if (typeof dstValue === 'number') {
+        if (dstValue === marker) {
+          markerInsertPosition = -1;
+          break;
+        } else if (dstValue > marker) {
+          markerInsertPosition = i - 1;
+          break;
+        }
+      }
+    }
+  }
+  while (i < dst.length) {
+    const item = dst[i];
+    if (typeof item === 'number') {
+      break;
+    } else if (item === key1) {
+      {
+        if (value !== null) {
+          dst[i + 1] = value;
+        }
+        return;
+      }
+    }
+    i++;
+    if (value !== null) i++;
+  }
+  if (markerInsertPosition !== -1) {
+    dst.splice(markerInsertPosition, 0, marker);
+    i = markerInsertPosition + 1;
+  }
+  dst.splice(i++, 0, key1);
+  if (value !== null) {
+    dst.splice(i++, 0, value);
   }
 }
-function ngOnChangesSetInput(instance, inputSignalNode, value, publicName, privateName) {
-  const declaredName = this.declaredInputs[publicName];
-  ngDevMode && assertString(declaredName, 'Name of input in ngOnChanges has to be a string');
-  const simpleChangesStore = getSimpleChangesStore(instance) || setSimpleChangesStore(instance, {
-    previous: EMPTY_OBJ,
-    current: null
-  });
-  const current = simpleChangesStore.current || (simpleChangesStore.current = {});
-  const previous = simpleChangesStore.previous;
-  const previousChange = previous[declaredName];
-  current[declaredName] = new SimpleChange(previousChange && previousChange.currentValue, value, previous === EMPTY_OBJ);
-  applyValueToInputField(instance, inputSignalNode, privateName, value);
+
+function hasParentInjector(parentLocation) {
+  return parentLocation !== NO_PARENT_INJECTOR;
 }
-const SIMPLE_CHANGES_STORE = '__ngSimpleChanges__';
-function getSimpleChangesStore(instance) {
-  return instance[SIMPLE_CHANGES_STORE] || null;
+function getParentInjectorIndex(parentLocation) {
+  if (ngDevMode) {
+    assertNumber(parentLocation, 'Number expected');
+    assertNotEqual(parentLocation, -1, 'Not a valid state.');
+    const parentInjectorIndex = parentLocation & 32767;
+    assertGreaterThan(parentInjectorIndex, HEADER_OFFSET, 'Parent injector must be pointing past HEADER_OFFSET.');
+  }
+  return parentLocation & 32767;
 }
-function setSimpleChangesStore(instance, store) {
-  return instance[SIMPLE_CHANGES_STORE] = store;
+function getParentInjectorViewOffset(parentLocation) {
+  return parentLocation >> 16;
 }
-
-const profilerCallbacks = [];
-const NOOP_PROFILER_REMOVAL = () => {};
-function removeProfiler(profiler) {
-  const profilerIdx = profilerCallbacks.indexOf(profiler);
-  if (profilerIdx !== -1) {
-    profilerCallbacks.splice(profilerIdx, 1);
+function getParentInjectorView(location, startView) {
+  let viewOffset = getParentInjectorViewOffset(location);
+  let parentView = startView;
+  while (viewOffset > 0) {
+    parentView = parentView[DECLARATION_VIEW];
+    viewOffset--;
   }
+  return parentView;
 }
-function setProfiler(profiler) {
-  if (profiler !== null) {
-    if (!profilerCallbacks.includes(profiler)) {
-      profilerCallbacks.push(profiler);
-    }
-    return () => removeProfiler(profiler);
-  } else {
-    profilerCallbacks.length = 0;
-    return NOOP_PROFILER_REMOVAL;
+
+let includeViewProviders = true;
+function setIncludeViewProviders(v) {
+  const oldValue = includeViewProviders;
+  includeViewProviders = v;
+  return oldValue;
+}
+const BLOOM_SIZE = 256;
+const BLOOM_MASK = BLOOM_SIZE - 1;
+const BLOOM_BUCKET_BITS = 5;
+let nextNgElementId = 0;
+const NOT_FOUND = {};
+function bloomAdd(injectorIndex, tView, type) {
+  ngDevMode && assertEqual(tView.firstCreatePass, true, 'expected firstCreatePass to be true');
+  let id;
+  if (typeof type === 'string') {
+    id = type.charCodeAt(0) || 0;
+  } else if (type.hasOwnProperty(NG_ELEMENT_ID)) {
+    id = type[NG_ELEMENT_ID];
   }
+  if (id == null) {
+    id = type[NG_ELEMENT_ID] = nextNgElementId++;
+  }
+  const bloomHash = id & BLOOM_MASK;
+  const mask = 1 << bloomHash;
+  tView.data[injectorIndex + (bloomHash >> BLOOM_BUCKET_BITS)] |= mask;
 }
-const profiler = function (event, instance = null, eventFn) {
-  for (let i = 0; i < profilerCallbacks.length; i++) {
-    const profilerCallback = profilerCallbacks[i];
-    profilerCallback(event, instance, eventFn);
+function getOrCreateNodeInjectorForNode(tNode, lView) {
+  const existingInjectorIndex = getInjectorIndex(tNode, lView);
+  if (existingInjectorIndex !== -1) {
+    return existingInjectorIndex;
   }
-};
-
-var ProfilerEvent;
-(function (ProfilerEvent) {
-  ProfilerEvent[ProfilerEvent["TemplateCreateStart"] = 0] = "TemplateCreateStart";
-  ProfilerEvent[ProfilerEvent["TemplateCreateEnd"] = 1] = "TemplateCreateEnd";
-  ProfilerEvent[ProfilerEvent["TemplateUpdateStart"] = 2] = "TemplateUpdateStart";
-  ProfilerEvent[ProfilerEvent["TemplateUpdateEnd"] = 3] = "TemplateUpdateEnd";
-  ProfilerEvent[ProfilerEvent["LifecycleHookStart"] = 4] = "LifecycleHookStart";
-  ProfilerEvent[ProfilerEvent["LifecycleHookEnd"] = 5] = "LifecycleHookEnd";
-  ProfilerEvent[ProfilerEvent["OutputStart"] = 6] = "OutputStart";
-  ProfilerEvent[ProfilerEvent["OutputEnd"] = 7] = "OutputEnd";
-  ProfilerEvent[ProfilerEvent["BootstrapApplicationStart"] = 8] = "BootstrapApplicationStart";
-  ProfilerEvent[ProfilerEvent["BootstrapApplicationEnd"] = 9] = "BootstrapApplicationEnd";
-  ProfilerEvent[ProfilerEvent["BootstrapComponentStart"] = 10] = "BootstrapComponentStart";
-  ProfilerEvent[ProfilerEvent["BootstrapComponentEnd"] = 11] = "BootstrapComponentEnd";
-  ProfilerEvent[ProfilerEvent["ChangeDetectionStart"] = 12] = "ChangeDetectionStart";
-  ProfilerEvent[ProfilerEvent["ChangeDetectionEnd"] = 13] = "ChangeDetectionEnd";
-  ProfilerEvent[ProfilerEvent["ChangeDetectionSyncStart"] = 14] = "ChangeDetectionSyncStart";
-  ProfilerEvent[ProfilerEvent["ChangeDetectionSyncEnd"] = 15] = "ChangeDetectionSyncEnd";
-  ProfilerEvent[ProfilerEvent["AfterRenderHooksStart"] = 16] = "AfterRenderHooksStart";
-  ProfilerEvent[ProfilerEvent["AfterRenderHooksEnd"] = 17] = "AfterRenderHooksEnd";
-  ProfilerEvent[ProfilerEvent["ComponentStart"] = 18] = "ComponentStart";
-  ProfilerEvent[ProfilerEvent["ComponentEnd"] = 19] = "ComponentEnd";
-  ProfilerEvent[ProfilerEvent["DeferBlockStateStart"] = 20] = "DeferBlockStateStart";
-  ProfilerEvent[ProfilerEvent["DeferBlockStateEnd"] = 21] = "DeferBlockStateEnd";
-  ProfilerEvent[ProfilerEvent["DynamicComponentStart"] = 22] = "DynamicComponentStart";
-  ProfilerEvent[ProfilerEvent["DynamicComponentEnd"] = 23] = "DynamicComponentEnd";
-  ProfilerEvent[ProfilerEvent["HostBindingsUpdateStart"] = 24] = "HostBindingsUpdateStart";
-  ProfilerEvent[ProfilerEvent["HostBindingsUpdateEnd"] = 25] = "HostBindingsUpdateEnd";
-})(ProfilerEvent || (ProfilerEvent = {}));
-
-function registerPreOrderHooks(directiveIndex, directiveDef, tView) {
-  ngDevMode && assertFirstCreatePass(tView);
-  const {
-    ngOnChanges,
-    ngOnInit,
-    ngDoCheck
-  } = directiveDef.type.prototype;
-  if (ngOnChanges) {
-    const wrappedOnChanges = NgOnChangesFeatureImpl(directiveDef);
-    (tView.preOrderHooks ??= []).push(directiveIndex, wrappedOnChanges);
-    (tView.preOrderCheckHooks ??= []).push(directiveIndex, wrappedOnChanges);
+  const tView = lView[TVIEW];
+  if (tView.firstCreatePass) {
+    tNode.injectorIndex = lView.length;
+    insertBloom(tView.data, tNode);
+    insertBloom(lView, null);
+    insertBloom(tView.blueprint, null);
   }
-  if (ngOnInit) {
-    (tView.preOrderHooks ??= []).push(0 - directiveIndex, ngOnInit);
+  const parentLoc = getParentInjectorLocation(tNode, lView);
+  const injectorIndex = tNode.injectorIndex;
+  if (hasParentInjector(parentLoc)) {
+    const parentIndex = getParentInjectorIndex(parentLoc);
+    const parentLView = getParentInjectorView(parentLoc, lView);
+    const parentData = parentLView[TVIEW].data;
+    for (let i = 0; i < 8; i++) {
+      lView[injectorIndex + i] = parentLView[parentIndex + i] | parentData[parentIndex + i];
+    }
   }
-  if (ngDoCheck) {
-    (tView.preOrderHooks ??= []).push(directiveIndex, ngDoCheck);
-    (tView.preOrderCheckHooks ??= []).push(directiveIndex, ngDoCheck);
+  lView[injectorIndex + 8] = parentLoc;
+  return injectorIndex;
+}
+function insertBloom(arr, footer) {
+  arr.push(0, 0, 0, 0, 0, 0, 0, 0, footer);
+}
+function getInjectorIndex(tNode, lView) {
+  if (tNode.injectorIndex === -1 || tNode.parent && tNode.parent.injectorIndex === tNode.injectorIndex || lView[tNode.injectorIndex + 8] === null) {
+    return -1;
+  } else {
+    ngDevMode && assertIndexInRange(lView, tNode.injectorIndex);
+    return tNode.injectorIndex;
   }
 }
-function registerPostOrderHooks(tView, tNode) {
-  ngDevMode && assertFirstCreatePass(tView);
-  for (let i = tNode.directiveStart, end = tNode.directiveEnd; i < end; i++) {
-    const directiveDef = tView.data[i];
-    ngDevMode && assertDefined(directiveDef, 'Expecting DirectiveDef');
-    const lifecycleHooks = directiveDef.type.prototype;
-    const {
-      ngAfterContentInit,
-      ngAfterContentChecked,
-      ngAfterViewInit,
-      ngAfterViewChecked,
-      ngOnDestroy
-    } = lifecycleHooks;
-    if (ngAfterContentInit) {
-      (tView.contentHooks ??= []).push(-i, ngAfterContentInit);
-    }
-    if (ngAfterContentChecked) {
-      (tView.contentHooks ??= []).push(i, ngAfterContentChecked);
-      (tView.contentCheckHooks ??= []).push(i, ngAfterContentChecked);
-    }
-    if (ngAfterViewInit) {
-      (tView.viewHooks ??= []).push(-i, ngAfterViewInit);
-    }
-    if (ngAfterViewChecked) {
-      (tView.viewHooks ??= []).push(i, ngAfterViewChecked);
-      (tView.viewCheckHooks ??= []).push(i, ngAfterViewChecked);
+function getParentInjectorLocation(tNode, lView) {
+  if (tNode.parent && tNode.parent.injectorIndex !== -1) {
+    return tNode.parent.injectorIndex;
+  }
+  let declarationViewOffset = 0;
+  let parentTNode = null;
+  let lViewCursor = lView;
+  while (lViewCursor !== null) {
+    parentTNode = getTNodeFromLView(lViewCursor);
+    if (parentTNode === null) {
+      return NO_PARENT_INJECTOR;
     }
-    if (ngOnDestroy != null) {
-      (tView.destroyHooks ??= []).push(i, ngOnDestroy);
+    ngDevMode && parentTNode && assertTNodeForLView(parentTNode, lViewCursor[DECLARATION_VIEW]);
+    declarationViewOffset++;
+    lViewCursor = lViewCursor[DECLARATION_VIEW];
+    if (parentTNode.injectorIndex !== -1) {
+      return parentTNode.injectorIndex | declarationViewOffset << 16;
     }
   }
+  return NO_PARENT_INJECTOR;
 }
-function executeCheckHooks(lView, hooks, nodeIndex) {
-  callHooks(lView, hooks, 3, nodeIndex);
+function diPublicInInjector(injectorIndex, tView, token) {
+  bloomAdd(injectorIndex, tView, token);
 }
-function executeInitAndCheckHooks(lView, hooks, initPhase, nodeIndex) {
-  ngDevMode && assertNotEqual(initPhase, 3, 'Init pre-order hooks should not be called more than once');
-  if ((lView[FLAGS] & 3) === initPhase) {
-    callHooks(lView, hooks, initPhase, nodeIndex);
+function injectAttributeImpl(tNode, attrNameToInject) {
+  ngDevMode && assertTNodeType(tNode, 12 | 3);
+  ngDevMode && assertDefined(tNode, 'expecting tNode');
+  if (attrNameToInject === 'class') {
+    return tNode.classes;
   }
-}
-function incrementInitPhaseFlags(lView, initPhase) {
-  ngDevMode && assertNotEqual(initPhase, 3, 'Init hooks phase should not be incremented after all init hooks have been run.');
-  let flags = lView[FLAGS];
-  if ((flags & 3) === initPhase) {
-    flags &= 16383;
-    flags += 1;
-    lView[FLAGS] = flags;
+  if (attrNameToInject === 'style') {
+    return tNode.styles;
   }
-}
-function callHooks(currentView, arr, initPhase, currentNodeIndex) {
-  ngDevMode && assertEqual(isInCheckNoChangesMode(), false, 'Hooks should never be run when in check no changes mode.');
-  const startIndex = currentNodeIndex !== undefined ? currentView[PREORDER_HOOK_FLAGS] & 65535 : 0;
-  const nodeIndexLimit = currentNodeIndex != null ? currentNodeIndex : -1;
-  const max = arr.length - 1;
-  let lastNodeIndexFound = 0;
-  for (let i = startIndex; i < max; i++) {
-    const hook = arr[i + 1];
-    if (typeof hook === 'number') {
-      lastNodeIndexFound = arr[i];
-      if (currentNodeIndex != null && lastNodeIndexFound >= currentNodeIndex) {
-        break;
-      }
-    } else {
-      const isInitHook = arr[i] < 0;
-      if (isInitHook) {
-        currentView[PREORDER_HOOK_FLAGS] += 65536;
-      }
-      if (lastNodeIndexFound < nodeIndexLimit || nodeIndexLimit == -1) {
-        callHook(currentView, initPhase, arr, i);
-        currentView[PREORDER_HOOK_FLAGS] = (currentView[PREORDER_HOOK_FLAGS] & 4294901760) + i + 2;
+  const attrs = tNode.attrs;
+  if (attrs) {
+    const attrsLength = attrs.length;
+    let i = 0;
+    while (i < attrsLength) {
+      const value = attrs[i];
+      if (isNameOnlyAttributeMarker(value)) break;
+      if (value === 0) {
+        i = i + 2;
+      } else if (typeof value === 'number') {
+        i++;
+        while (i < attrsLength && typeof attrs[i] === 'string') {
+          i++;
+        }
+      } else if (value === attrNameToInject) {
+        return attrs[i + 1];
+      } else {
+        i = i + 2;
       }
-      i++;
     }
   }
+  return null;
 }
-function callHookInternal(directive, hook) {
-  profiler(ProfilerEvent.LifecycleHookStart, directive, hook);
-  const prevConsumer = setActiveConsumer(null);
-  try {
-    hook.call(directive);
-  } finally {
-    setActiveConsumer(prevConsumer);
-    profiler(ProfilerEvent.LifecycleHookEnd, directive, hook);
-  }
-}
-function callHook(currentView, initPhase, arr, i) {
-  const isInitHook = arr[i] < 0;
-  const hook = arr[i + 1];
-  const directiveIndex = isInitHook ? -arr[i] : arr[i];
-  const directive = currentView[directiveIndex];
-  if (isInitHook) {
-    const indexWithintInitPhase = currentView[FLAGS] >> 14;
-    if (indexWithintInitPhase < currentView[PREORDER_HOOK_FLAGS] >> 16 && (currentView[FLAGS] & 3) === initPhase) {
-      currentView[FLAGS] += 16384;
-      callHookInternal(directive, hook);
-    }
+function notFoundValueOrThrow(notFoundValue, token, flags) {
+  if (flags & 8 || notFoundValue !== undefined) {
+    return notFoundValue;
   } else {
-    callHookInternal(directive, hook);
+    throwProviderNotFoundError(token, 'NodeInjector');
   }
 }
-
-const NO_PARENT_INJECTOR = -1;
-class NodeInjectorFactory {
-  factory;
-  name;
-  injectImpl;
-  resolving = false;
-  canSeeViewProviders;
-  multi;
-  componentProviders;
-  index;
-  providerFactory;
-  constructor(factory, isViewProvider, injectImplementation, name) {
-    this.factory = factory;
-    this.name = name;
-    ngDevMode && assertDefined(factory, 'Factory not specified');
-    ngDevMode && assertEqual(typeof factory, 'function', 'Expected factory function.');
-    this.canSeeViewProviders = isViewProvider;
-    this.injectImpl = injectImplementation;
+function lookupTokenUsingModuleInjector(lView, token, flags, notFoundValue) {
+  if (flags & 8 && notFoundValue === undefined) {
+    notFoundValue = null;
   }
-}
-
-function toTNodeTypeAsString(tNodeType) {
-  let text = '';
-  tNodeType & 1 && (text += '|Text');
-  tNodeType & 2 && (text += '|Element');
-  tNodeType & 4 && (text += '|Container');
-  tNodeType & 8 && (text += '|ElementContainer');
-  tNodeType & 16 && (text += '|Projection');
-  tNodeType & 32 && (text += '|IcuContainer');
-  tNodeType & 64 && (text += '|Placeholder');
-  tNodeType & 128 && (text += '|LetDeclaration');
-  return text.length > 0 ? text.substring(1) : text;
-}
-function isTNodeShape(value) {
-  return value != null && typeof value === 'object' && (value.insertBeforeIndex === null || typeof value.insertBeforeIndex === 'number' || Array.isArray(value.insertBeforeIndex));
-}
-function isLetDeclaration(tNode) {
-  return !!(tNode.type & 128);
-}
-function hasClassInput(tNode) {
-  return (tNode.flags & 8) !== 0;
-}
-function hasStyleInput(tNode) {
-  return (tNode.flags & 16) !== 0;
-}
-
-function assertTNodeType(tNode, expectedTypes, message) {
-  assertDefined(tNode, 'should be called with a TNode');
-  if ((tNode.type & expectedTypes) === 0) {
-    throwError(message || `Expected [${toTNodeTypeAsString(expectedTypes)}] but got ${toTNodeTypeAsString(tNode.type)}.`);
+  if ((flags & (2 | 1)) === 0) {
+    const moduleInjector = lView[INJECTOR];
+    const previousInjectImplementation = setInjectImplementation(undefined);
+    try {
+      if (moduleInjector) {
+        return moduleInjector.get(token, notFoundValue, flags & 8);
+      } else {
+        return injectRootLimpMode(token, notFoundValue, flags & 8);
+      }
+    } finally {
+      setInjectImplementation(previousInjectImplementation);
+    }
   }
+  return notFoundValueOrThrow(notFoundValue, token, flags);
 }
-function assertPureTNodeType(type) {
-  if (!(type === 2 || type === 1 || type === 4 || type === 8 || type === 32 || type === 16 || type === 64 || type === 128)) {
-    throwError(`Expected TNodeType to have only a single type selected, but got ${toTNodeTypeAsString(type)}.`);
+function getOrCreateInjectable(tNode, lView, token, flags = 0, notFoundValue) {
+  if (tNode !== null) {
+    if (lView[FLAGS] & 2048 && !(flags & 2)) {
+      const embeddedInjectorValue = lookupTokenUsingEmbeddedInjector(tNode, lView, token, flags, NOT_FOUND);
+      if (embeddedInjectorValue !== NOT_FOUND) {
+        return embeddedInjectorValue;
+      }
+    }
+    const value = lookupTokenUsingNodeInjector(tNode, lView, token, flags, NOT_FOUND);
+    if (value !== NOT_FOUND) {
+      return value;
+    }
   }
+  return lookupTokenUsingModuleInjector(lView, token, flags, notFoundValue);
 }
-
-function setUpAttributes(renderer, native, attrs) {
-  let i = 0;
-  while (i < attrs.length) {
-    const value = attrs[i];
-    if (typeof value === 'number') {
-      if (value !== 0) {
-        break;
+function lookupTokenUsingNodeInjector(tNode, lView, token, flags, notFoundValue) {
+  const bloomHash = bloomHashBitOrFactory(token);
+  if (typeof bloomHash === 'function') {
+    if (!enterDI(lView, tNode, flags)) {
+      return flags & 1 ? notFoundValueOrThrow(notFoundValue, token, flags) : lookupTokenUsingModuleInjector(lView, token, flags, notFoundValue);
+    }
+    try {
+      let value;
+      if (ngDevMode) {
+        runInInjectorProfilerContext(new NodeInjector(getCurrentTNode(), getLView()), token, () => {
+          emitInjectorToCreateInstanceEvent(token);
+          value = bloomHash(flags);
+          emitInstanceCreatedByInjectorEvent(value);
+        });
+      } else {
+        value = bloomHash(flags);
       }
-      i++;
-      const namespaceURI = attrs[i++];
-      const attrName = attrs[i++];
-      const attrVal = attrs[i++];
-      renderer.setAttribute(native, attrName, attrVal, namespaceURI);
-    } else {
-      const attrName = value;
-      const attrVal = attrs[++i];
-      if (isAnimationProp(attrName)) {
-        renderer.setProperty(native, attrName, attrVal);
+      if (value == null && !(flags & 8)) {
+        throwProviderNotFoundError(token);
       } else {
-        renderer.setAttribute(native, attrName, attrVal);
+        return value;
+      }
+    } finally {
+      leaveDI();
+    }
+  } else if (typeof bloomHash === 'number') {
+    let previousTView = null;
+    let injectorIndex = getInjectorIndex(tNode, lView);
+    let parentLocation = NO_PARENT_INJECTOR;
+    let hostTElementNode = flags & 1 ? lView[DECLARATION_COMPONENT_VIEW][T_HOST] : null;
+    if (injectorIndex === -1 || flags & 4) {
+      parentLocation = injectorIndex === -1 ? getParentInjectorLocation(tNode, lView) : lView[injectorIndex + 8];
+      if (parentLocation === NO_PARENT_INJECTOR || !shouldSearchParent(flags, false)) {
+        injectorIndex = -1;
+      } else {
+        previousTView = lView[TVIEW];
+        injectorIndex = getParentInjectorIndex(parentLocation);
+        lView = getParentInjectorView(parentLocation, lView);
+      }
+    }
+    while (injectorIndex !== -1) {
+      ngDevMode && assertNodeInjector(lView, injectorIndex);
+      const tView = lView[TVIEW];
+      ngDevMode && assertTNodeForLView(tView.data[injectorIndex + 8], lView);
+      if (bloomHasToken(bloomHash, injectorIndex, tView.data)) {
+        const instance = searchTokensOnInjector(injectorIndex, lView, token, previousTView, flags, hostTElementNode);
+        if (instance !== NOT_FOUND) {
+          return instance;
+        }
+      }
+      parentLocation = lView[injectorIndex + 8];
+      if (parentLocation !== NO_PARENT_INJECTOR && shouldSearchParent(flags, lView[TVIEW].data[injectorIndex + 8] === hostTElementNode) && bloomHasToken(bloomHash, injectorIndex, lView)) {
+        previousTView = tView;
+        injectorIndex = getParentInjectorIndex(parentLocation);
+        lView = getParentInjectorView(parentLocation, lView);
+      } else {
+        injectorIndex = -1;
       }
-      i++;
     }
   }
-  return i;
+  return notFoundValue;
 }
-function isNameOnlyAttributeMarker(marker) {
-  return marker === 3 || marker === 4 || marker === 6;
+function searchTokensOnInjector(injectorIndex, lView, token, previousTView, flags, hostTElementNode) {
+  const currentTView = lView[TVIEW];
+  const tNode = currentTView.data[injectorIndex + 8];
+  const canAccessViewProviders = previousTView == null ? isComponentHost(tNode) && includeViewProviders : previousTView != currentTView && (tNode.type & 3) !== 0;
+  const isHostSpecialCase = flags & 1 && hostTElementNode === tNode;
+  const injectableIdx = locateDirectiveOrProvider(tNode, currentTView, token, canAccessViewProviders, isHostSpecialCase);
+  if (injectableIdx !== null) {
+    return getNodeInjectable(lView, currentTView, injectableIdx, tNode, flags);
+  } else {
+    return NOT_FOUND;
+  }
 }
-function isAnimationProp(name) {
-  return name.charCodeAt(0) === 64;
+function locateDirectiveOrProvider(tNode, tView, token, canAccessViewProviders, isHostSpecialCase) {
+  const nodeProviderIndexes = tNode.providerIndexes;
+  const tInjectables = tView.data;
+  const injectablesStart = nodeProviderIndexes & 1048575;
+  const directivesStart = tNode.directiveStart;
+  const directiveEnd = tNode.directiveEnd;
+  const cptViewProvidersCount = nodeProviderIndexes >> 20;
+  const startingIndex = canAccessViewProviders ? injectablesStart : injectablesStart + cptViewProvidersCount;
+  const endIndex = isHostSpecialCase ? injectablesStart + cptViewProvidersCount : directiveEnd;
+  for (let i = startingIndex; i < endIndex; i++) {
+    const providerTokenOrDef = tInjectables[i];
+    if (i < directivesStart && token === providerTokenOrDef || i >= directivesStart && providerTokenOrDef.type === token) {
+      return i;
+    }
+  }
+  if (isHostSpecialCase) {
+    const dirDef = tInjectables[directivesStart];
+    if (dirDef && isComponentDef(dirDef) && dirDef.type === token) {
+      return directivesStart;
+    }
+  }
+  return null;
 }
-function mergeHostAttrs(dst, src) {
-  if (src === null || src.length === 0) ; else if (dst === null || dst.length === 0) {
-    dst = src.slice();
-  } else {
-    let srcMarker = -1;
-    for (let i = 0; i < src.length; i++) {
-      const item = src[i];
-      if (typeof item === 'number') {
-        srcMarker = item;
+let injectionPath = [];
+function getNodeInjectable(lView, tView, index, tNode, flags) {
+  let value = lView[index];
+  const tData = tView.data;
+  if (value instanceof NodeInjectorFactory) {
+    const factory = value;
+    ngDevMode && injectionPath.push(factory.name ?? 'unknown');
+    if (factory.resolving) {
+      let token = '';
+      if (ngDevMode) {
+        token = stringifyForError(tData[index]);
+        throw cyclicDependencyErrorWithDetails(token, injectionPath);
       } else {
-        if (srcMarker === 0) ; else if (srcMarker === -1 || srcMarker === 2) {
-          mergeHostAttribute(dst, srcMarker, item, null, src[++i]);
-        } else {
-          mergeHostAttribute(dst, srcMarker, item, null, null);
-        }
+        throw cyclicDependencyError(token);
       }
     }
-  }
-  return dst;
-}
-function mergeHostAttribute(dst, marker, key1, key2, value) {
-  let i = 0;
-  let markerInsertPosition = dst.length;
-  if (marker === -1) {
-    markerInsertPosition = -1;
-  } else {
-    while (i < dst.length) {
-      const dstValue = dst[i++];
-      if (typeof dstValue === 'number') {
-        if (dstValue === marker) {
-          markerInsertPosition = -1;
-          break;
-        } else if (dstValue > marker) {
-          markerInsertPosition = i - 1;
-          break;
-        }
-      }
+    const previousIncludeViewProviders = setIncludeViewProviders(factory.canSeeViewProviders);
+    factory.resolving = true;
+    const token = tData[index].type || tData[index];
+    let prevInjectContext;
+    if (ngDevMode) {
+      const injector = new NodeInjector(tNode, lView);
+      prevInjectContext = setInjectorProfilerContext({
+        injector,
+        token
+      });
     }
-  }
-  while (i < dst.length) {
-    const item = dst[i];
-    if (typeof item === 'number') {
-      break;
-    } else if (item === key1) {
-      {
-        if (value !== null) {
-          dst[i + 1] = value;
-        }
-        return;
+    const previousInjectImplementation = factory.injectImpl ? setInjectImplementation(factory.injectImpl) : null;
+    const success = enterDI(lView, tNode, 0);
+    ngDevMode && assertEqual(success, true, "Because flags do not contain `SkipSelf' we expect this to always succeed.");
+    try {
+      ngDevMode && emitInjectorToCreateInstanceEvent(token);
+      value = lView[index] = factory.factory(undefined, flags, tData, lView, tNode);
+      ngDevMode && emitInstanceCreatedByInjectorEvent(value);
+      if (tView.firstCreatePass && index >= tNode.directiveStart) {
+        ngDevMode && assertDirectiveDef(tData[index]);
+        registerPreOrderHooks(index, tData[index], tView);
       }
+    } finally {
+      ngDevMode && setInjectorProfilerContext(prevInjectContext);
+      previousInjectImplementation !== null && setInjectImplementation(previousInjectImplementation);
+      setIncludeViewProviders(previousIncludeViewProviders);
+      factory.resolving = false;
+      leaveDI();
+      ngDevMode && (injectionPath = []);
     }
-    i++;
-    if (value !== null) i++;
   }
-  if (markerInsertPosition !== -1) {
-    dst.splice(markerInsertPosition, 0, marker);
-    i = markerInsertPosition + 1;
+  return value;
+}
+function bloomHashBitOrFactory(token) {
+  ngDevMode && assertDefined(token, 'token must be defined');
+  if (typeof token === 'string') {
+    return token.charCodeAt(0) || 0;
   }
-  dst.splice(i++, 0, key1);
-  if (value !== null) {
-    dst.splice(i++, 0, value);
+  const tokenId = token.hasOwnProperty(NG_ELEMENT_ID) ? token[NG_ELEMENT_ID] : undefined;
+  if (typeof tokenId === 'number') {
+    if (tokenId >= 0) {
+      return tokenId & BLOOM_MASK;
+    } else {
+      ngDevMode && assertEqual(tokenId, -1, 'Expecting to get Special Injector Id');
+      return createNodeInjector;
+    }
+  } else {
+    return tokenId;
   }
 }
-
-function hasParentInjector(parentLocation) {
-  return parentLocation !== NO_PARENT_INJECTOR;
-}
-function getParentInjectorIndex(parentLocation) {
-  if (ngDevMode) {
-    assertNumber(parentLocation, 'Number expected');
-    assertNotEqual(parentLocation, -1, 'Not a valid state.');
-    const parentInjectorIndex = parentLocation & 32767;
-    assertGreaterThan(parentInjectorIndex, HEADER_OFFSET, 'Parent injector must be pointing past HEADER_OFFSET.');
-  }
-  return parentLocation & 32767;
+function bloomHasToken(bloomHash, injectorIndex, injectorView) {
+  const mask = 1 << bloomHash;
+  const value = injectorView[injectorIndex + (bloomHash >> BLOOM_BUCKET_BITS)];
+  return !!(value & mask);
 }
-function getParentInjectorViewOffset(parentLocation) {
-  return parentLocation >> 16;
+function shouldSearchParent(flags, isFirstHostTNode) {
+  return !(flags & 2) && !(flags & 1 && isFirstHostTNode);
 }
-function getParentInjectorView(location, startView) {
-  let viewOffset = getParentInjectorViewOffset(location);
-  let parentView = startView;
-  while (viewOffset > 0) {
-    parentView = parentView[DECLARATION_VIEW];
-    viewOffset--;
-  }
-  return parentView;
+function getNodeInjectorLView(nodeInjector) {
+  return nodeInjector._lView;
 }
-
-let includeViewProviders = true;
-function setIncludeViewProviders(v) {
-  const oldValue = includeViewProviders;
-  includeViewProviders = v;
-  return oldValue;
+function getNodeInjectorTNode(nodeInjector) {
+  return nodeInjector._tNode;
 }
-const BLOOM_SIZE = 256;
-const BLOOM_MASK = BLOOM_SIZE - 1;
-const BLOOM_BUCKET_BITS = 5;
-let nextNgElementId = 0;
-const NOT_FOUND = {};
-function bloomAdd(injectorIndex, tView, type) {
-  ngDevMode && assertEqual(tView.firstCreatePass, true, 'expected firstCreatePass to be true');
-  let id;
-  if (typeof type === 'string') {
-    id = type.charCodeAt(0) || 0;
-  } else if (type.hasOwnProperty(NG_ELEMENT_ID)) {
-    id = type[NG_ELEMENT_ID];
+class NodeInjector {
+  _tNode;
+  _lView;
+  constructor(_tNode, _lView) {
+    this._tNode = _tNode;
+    this._lView = _lView;
   }
-  if (id == null) {
-    id = type[NG_ELEMENT_ID] = nextNgElementId++;
+  get(token, notFoundValue, flags) {
+    return getOrCreateInjectable(this._tNode, this._lView, token, convertToBitFlags(flags), notFoundValue);
   }
-  const bloomHash = id & BLOOM_MASK;
-  const mask = 1 << bloomHash;
-  tView.data[injectorIndex + (bloomHash >> BLOOM_BUCKET_BITS)] |= mask;
 }
-function getOrCreateNodeInjectorForNode(tNode, lView) {
-  const existingInjectorIndex = getInjectorIndex(tNode, lView);
-  if (existingInjectorIndex !== -1) {
-    return existingInjectorIndex;
-  }
-  const tView = lView[TVIEW];
-  if (tView.firstCreatePass) {
-    tNode.injectorIndex = lView.length;
-    insertBloom(tView.data, tNode);
-    insertBloom(lView, null);
-    insertBloom(tView.blueprint, null);
-  }
-  const parentLoc = getParentInjectorLocation(tNode, lView);
-  const injectorIndex = tNode.injectorIndex;
-  if (hasParentInjector(parentLoc)) {
-    const parentIndex = getParentInjectorIndex(parentLoc);
-    const parentLView = getParentInjectorView(parentLoc, lView);
-    const parentData = parentLView[TVIEW].data;
-    for (let i = 0; i < 8; i++) {
-      lView[injectorIndex + i] = parentLView[parentIndex + i] | parentData[parentIndex + i];
-    }
-  }
-  lView[injectorIndex + 8] = parentLoc;
-  return injectorIndex;
+function createNodeInjector() {
+  return new NodeInjector(getCurrentTNode(), getLView());
 }
-function insertBloom(arr, footer) {
-  arr.push(0, 0, 0, 0, 0, 0, 0, 0, footer);
+function ɵɵgetInheritedFactory(type) {
+  return noSideEffects(() => {
+    const ownConstructor = type.prototype.constructor;
+    const ownFactory = ownConstructor[NG_FACTORY_DEF] || getFactoryOf(ownConstructor);
+    const objectPrototype = Object.prototype;
+    let parent = Object.getPrototypeOf(type.prototype).constructor;
+    while (parent && parent !== objectPrototype) {
+      const factory = parent[NG_FACTORY_DEF] || getFactoryOf(parent);
+      if (factory && factory !== ownFactory) {
+        return factory;
+      }
+      parent = Object.getPrototypeOf(parent);
+    }
+    return t => new t();
+  });
 }
-function getInjectorIndex(tNode, lView) {
-  if (tNode.injectorIndex === -1 || tNode.parent && tNode.parent.injectorIndex === tNode.injectorIndex || lView[tNode.injectorIndex + 8] === null) {
-    return -1;
-  } else {
-    ngDevMode && assertIndexInRange(lView, tNode.injectorIndex);
-    return tNode.injectorIndex;
+function getFactoryOf(type) {
+  if (isForwardRef(type)) {
+    return () => {
+      const factory = getFactoryOf(resolveForwardRef(type));
+      return factory && factory();
+    };
   }
+  return getFactoryDef(type);
 }
-function getParentInjectorLocation(tNode, lView) {
-  if (tNode.parent && tNode.parent.injectorIndex !== -1) {
-    return tNode.parent.injectorIndex;
-  }
-  let declarationViewOffset = 0;
-  let parentTNode = null;
-  let lViewCursor = lView;
-  while (lViewCursor !== null) {
-    parentTNode = getTNodeFromLView(lViewCursor);
-    if (parentTNode === null) {
-      return NO_PARENT_INJECTOR;
+function lookupTokenUsingEmbeddedInjector(tNode, lView, token, flags, notFoundValue) {
+  let currentTNode = tNode;
+  let currentLView = lView;
+  while (currentTNode !== null && currentLView !== null && currentLView[FLAGS] & 2048 && !isRootView(currentLView)) {
+    ngDevMode && assertTNodeForLView(currentTNode, currentLView);
+    const nodeInjectorValue = lookupTokenUsingNodeInjector(currentTNode, currentLView, token, flags | 2, NOT_FOUND);
+    if (nodeInjectorValue !== NOT_FOUND) {
+      return nodeInjectorValue;
     }
-    ngDevMode && parentTNode && assertTNodeForLView(parentTNode, lViewCursor[DECLARATION_VIEW]);
-    declarationViewOffset++;
-    lViewCursor = lViewCursor[DECLARATION_VIEW];
-    if (parentTNode.injectorIndex !== -1) {
-      return parentTNode.injectorIndex | declarationViewOffset << 16;
+    let parentTNode = currentTNode.parent;
+    if (!parentTNode) {
+      const embeddedViewInjector = currentLView[EMBEDDED_VIEW_INJECTOR];
+      if (embeddedViewInjector) {
+        const embeddedViewInjectorValue = embeddedViewInjector.get(token, NOT_FOUND, flags & -5);
+        if (embeddedViewInjectorValue !== NOT_FOUND) {
+          return embeddedViewInjectorValue;
+        }
+      }
+      parentTNode = getTNodeFromLView(currentLView);
+      currentLView = currentLView[DECLARATION_VIEW];
     }
+    currentTNode = parentTNode;
+  }
+  return notFoundValue;
+}
+function getTNodeFromLView(lView) {
+  const tView = lView[TVIEW];
+  const tViewType = tView.type;
+  if (tViewType === 2) {
+    ngDevMode && assertDefined(tView.declTNode, 'Embedded TNodes should have declaration parents.');
+    return tView.declTNode;
+  } else if (tViewType === 1) {
+    return lView[T_HOST];
   }
-  return NO_PARENT_INJECTOR;
+  return null;
 }
-function diPublicInInjector(injectorIndex, tView, token) {
-  bloomAdd(injectorIndex, tView, token);
+
+function ɵɵinjectAttribute(attrNameToInject) {
+  return injectAttributeImpl(getCurrentTNode(), attrNameToInject);
 }
-function injectAttributeImpl(tNode, attrNameToInject) {
-  ngDevMode && assertTNodeType(tNode, 12 | 3);
-  ngDevMode && assertDefined(tNode, 'expecting tNode');
-  if (attrNameToInject === 'class') {
-    return tNode.classes;
+
+const _requestIdleCallback = () => (typeof requestIdleCallback !== 'undefined' ? requestIdleCallback : cb => setTimeout(cb)).bind(globalThis);
+const _cancelIdleCallback = () => (typeof requestIdleCallback !== 'undefined' ? cancelIdleCallback : clearTimeout).bind(globalThis);
+const IDLE_SERVICE = new InjectionToken(ngDevMode ? 'IDLE_SERVICE' : '', {
+  factory: () => new RequestIdleCallbackService()
+});
+function provideIdleServiceWith(useExisting) {
+  return makeEnvironmentProviders([{
+    provide: IDLE_SERVICE,
+    useExisting
+  }]);
+}
+class RequestIdleCallbackService {
+  requestIdleCallback = _requestIdleCallback();
+  cancelIdleCallback = _cancelIdleCallback();
+  requestOnIdle(callback, options) {
+    return this.requestIdleCallback(callback, options);
   }
-  if (attrNameToInject === 'style') {
-    return tNode.styles;
+  cancelOnIdle(id) {
+    return this.cancelIdleCallback(id);
   }
-  const attrs = tNode.attrs;
-  if (attrs) {
-    const attrsLength = attrs.length;
-    let i = 0;
-    while (i < attrsLength) {
-      const value = attrs[i];
-      if (isNameOnlyAttributeMarker(value)) break;
-      if (value === 0) {
-        i = i + 2;
-      } else if (typeof value === 'number') {
-        i++;
-        while (i < attrsLength && typeof attrs[i] === 'string') {
-          i++;
-        }
-      } else if (value === attrNameToInject) {
-        return attrs[i + 1];
-      } else {
-        i = i + 2;
+}
+
+function promiseWithResolvers() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return {
+    promise,
+    resolve,
+    reject
+  };
+}
+
+const ANNOTATIONS = '__annotations__';
+const PARAMETERS = '__parameters__';
+const PROP_METADATA = '__prop__metadata__';
+function makeDecorator(name, props, parentClass, additionalProcessing, typeFn) {
+  return noSideEffects(() => {
+    const metaCtor = makeMetadataCtor(props);
+    function DecoratorFactory(...args) {
+      if (this instanceof DecoratorFactory) {
+        metaCtor.call(this, ...args);
+        return this;
       }
+      const annotationInstance = new DecoratorFactory(...args);
+      return function TypeDecorator(cls) {
+        if (typeFn) typeFn(cls, ...args);
+        const annotations = cls.hasOwnProperty(ANNOTATIONS) ? cls[ANNOTATIONS] : Object.defineProperty(cls, ANNOTATIONS, {
+          value: []
+        })[ANNOTATIONS];
+        annotations.push(annotationInstance);
+        return cls;
+      };
     }
-  }
-  return null;
+    if (parentClass) {
+      DecoratorFactory.prototype = Object.create(parentClass.prototype);
+    }
+    DecoratorFactory.prototype.ngMetadataName = name;
+    DecoratorFactory.annotationCls = DecoratorFactory;
+    return DecoratorFactory;
+  });
 }
-function notFoundValueOrThrow(notFoundValue, token, flags) {
-  if (flags & 8 || notFoundValue !== undefined) {
-    return notFoundValue;
-  } else {
-    throwProviderNotFoundError(token, 'NodeInjector');
-  }
+function makeMetadataCtor(props) {
+  return function ctor(...args) {
+    if (props) {
+      const values = props(...args);
+      for (const propName in values) {
+        this[propName] = values[propName];
+      }
+    }
+  };
 }
-function lookupTokenUsingModuleInjector(lView, token, flags, notFoundValue) {
-  if (flags & 8 && notFoundValue === undefined) {
-    notFoundValue = null;
-  }
-  if ((flags & (2 | 1)) === 0) {
-    const moduleInjector = lView[INJECTOR];
-    const previousInjectImplementation = setInjectImplementation(undefined);
-    try {
-      if (moduleInjector) {
-        return moduleInjector.get(token, notFoundValue, flags & 8);
-      } else {
-        return injectRootLimpMode(token, notFoundValue, flags & 8);
+function makeParamDecorator(name, props, parentClass) {
+  return noSideEffects(() => {
+    const metaCtor = makeMetadataCtor(props);
+    function ParamDecoratorFactory(...args) {
+      if (this instanceof ParamDecoratorFactory) {
+        metaCtor.apply(this, args);
+        return this;
+      }
+      const annotationInstance = new ParamDecoratorFactory(...args);
+      ParamDecorator.annotation = annotationInstance;
+      return ParamDecorator;
+      function ParamDecorator(cls, unusedKey, index) {
+        const parameters = cls.hasOwnProperty(PARAMETERS) ? cls[PARAMETERS] : Object.defineProperty(cls, PARAMETERS, {
+          value: []
+        })[PARAMETERS];
+        while (parameters.length <= index) {
+          parameters.push(null);
+        }
+        (parameters[index] = parameters[index] || []).push(annotationInstance);
+        return cls;
       }
-    } finally {
-      setInjectImplementation(previousInjectImplementation);
     }
-  }
-  return notFoundValueOrThrow(notFoundValue, token, flags);
+    ParamDecoratorFactory.prototype.ngMetadataName = name;
+    ParamDecoratorFactory.annotationCls = ParamDecoratorFactory;
+    return ParamDecoratorFactory;
+  });
 }
-function getOrCreateInjectable(tNode, lView, token, flags = 0, notFoundValue) {
-  if (tNode !== null) {
-    if (lView[FLAGS] & 2048 && !(flags & 2)) {
-      const embeddedInjectorValue = lookupTokenUsingEmbeddedInjector(tNode, lView, token, flags, NOT_FOUND);
-      if (embeddedInjectorValue !== NOT_FOUND) {
-        return embeddedInjectorValue;
+function makePropDecorator(name, props, parentClass, additionalProcessing) {
+  return noSideEffects(() => {
+    const metaCtor = makeMetadataCtor(props);
+    function PropDecoratorFactory(...args) {
+      if (this instanceof PropDecoratorFactory) {
+        metaCtor.apply(this, args);
+        return this;
+      }
+      const decoratorInstance = new PropDecoratorFactory(...args);
+      function PropDecorator(target, name) {
+        if (target === undefined) {
+          throw new Error('Standard Angular field decorators are not supported in JIT mode.');
+        }
+        const constructor = target.constructor;
+        const meta = constructor.hasOwnProperty(PROP_METADATA) ? constructor[PROP_METADATA] : Object.defineProperty(constructor, PROP_METADATA, {
+          value: {}
+        })[PROP_METADATA];
+        meta[name] = meta.hasOwnProperty(name) && meta[name] || [];
+        meta[name].unshift(decoratorInstance);
       }
+      return PropDecorator;
     }
-    const value = lookupTokenUsingNodeInjector(tNode, lView, token, flags, NOT_FOUND);
-    if (value !== NOT_FOUND) {
-      return value;
+    if (parentClass) {
+      PropDecoratorFactory.prototype = Object.create(parentClass.prototype);
     }
+    PropDecoratorFactory.prototype.ngMetadataName = name;
+    PropDecoratorFactory.annotationCls = PropDecoratorFactory;
+    return PropDecoratorFactory;
+  });
+}
+
+function getCompilerFacade(request) {
+  const globalNg = _global['ng'];
+  if (globalNg && globalNg.ɵcompilerFacade) {
+    return globalNg.ɵcompilerFacade;
+  }
+  if (typeof ngDevMode === 'undefined' || ngDevMode) {
+    console.error(`JIT compilation failed for ${request.kind}`, request.type);
+    let message = `The ${request.kind} '${request.type.name}' needs to be compiled using the JIT compiler, but '@angular/compiler' is not available.\n\n`;
+    if (request.usage === 1) {
+      message += `The ${request.kind} is part of a library that has been partially compiled.\n`;
+      message += `However, the Angular Linker has not processed the library such that JIT compilation is used as fallback.\n`;
+      message += '\n';
+      message += `Ideally, the library is processed using the Angular Linker to become fully AOT compiled.\n`;
+    } else {
+      message += `JIT compilation is discouraged for production use-cases! Consider using AOT mode instead.\n`;
+    }
+    message += `Alternatively, the JIT compiler should be loaded by bootstrapping using '@angular/platform-browser-dynamic' or '@angular/platform-server',\n`;
+    message += `or manually provide the compiler with 'import "@angular/compiler";' before bootstrapping.`;
+    throw new Error(message);
+  } else {
+    throw new Error('JIT compiler unavailable');
   }
-  return lookupTokenUsingModuleInjector(lView, token, flags, notFoundValue);
 }
-function lookupTokenUsingNodeInjector(tNode, lView, token, flags, notFoundValue) {
-  const bloomHash = bloomHashBitOrFactory(token);
-  if (typeof bloomHash === 'function') {
-    if (!enterDI(lView, tNode, flags)) {
-      return flags & 1 ? notFoundValueOrThrow(notFoundValue, token, flags) : lookupTokenUsingModuleInjector(lView, token, flags, notFoundValue);
+
+function ɵɵdefineService(opts) {
+  return {
+    token: opts.token,
+    providedIn: opts.autoProvided === false ? null : 'root',
+    factory: opts.factory,
+    value: undefined
+  };
+}
+
+const angularCoreDiEnv = {
+  'ɵɵdefineInjectable': __defineInjectable,
+  'ɵɵdefineInjector': __defineInjector,
+  'ɵɵdefineService': ɵɵdefineService,
+  'ɵɵinject': __inject,
+  'ɵɵinvalidFactoryDep': __invalidFactoryDep,
+  'resolveForwardRef': resolveForwardRef
+};
+
+const Type = Function;
+function isType(v) {
+  return typeof v === 'function';
+}
+
+const ES5_DELEGATE_CTOR = /^function\s+\S+\(\)\s*{[\s\S]+\.apply\(this,\s*(arguments|(?:[^()]+\(\[\],)?[^()]+\(arguments\).*)\)/;
+const ES2015_INHERITED_CLASS = /^class\s+[A-Za-z\d$_]*\s*extends\s+[^{]+{/;
+const ES2015_INHERITED_CLASS_WITH_CTOR = /^class\s+[A-Za-z\d$_]*\s*extends\s+[^{]+{[\s\S]*constructor\s*\(/;
+const ES2015_INHERITED_CLASS_WITH_DELEGATE_CTOR = /^class\s+[A-Za-z\d$_]*\s*extends\s+[^{]+{[\s\S]*constructor\s*\(\)\s*{[^}]*super\(\.\.\.arguments\)/;
+function isDelegateCtor(typeStr) {
+  return ES5_DELEGATE_CTOR.test(typeStr) || ES2015_INHERITED_CLASS_WITH_DELEGATE_CTOR.test(typeStr) || ES2015_INHERITED_CLASS.test(typeStr) && !ES2015_INHERITED_CLASS_WITH_CTOR.test(typeStr);
+}
+class ReflectionCapabilities {
+  _reflect;
+  constructor(reflect) {
+    this._reflect = reflect || _global['Reflect'];
+  }
+  factory(t) {
+    return (...args) => new t(...args);
+  }
+  _zipTypesAndAnnotations(paramTypes, paramAnnotations) {
+    let result;
+    if (typeof paramTypes === 'undefined') {
+      result = newArray(paramAnnotations.length);
+    } else {
+      result = newArray(paramTypes.length);
     }
-    try {
-      let value;
-      if (ngDevMode) {
-        runInInjectorProfilerContext(new NodeInjector(getCurrentTNode(), getLView()), token, () => {
-          emitInjectorToCreateInstanceEvent(token);
-          value = bloomHash(flags);
-          emitInstanceCreatedByInjectorEvent(value);
-        });
+    for (let i = 0; i < result.length; i++) {
+      if (typeof paramTypes === 'undefined') {
+        result[i] = [];
+      } else if (paramTypes[i] && paramTypes[i] != Object) {
+        result[i] = [paramTypes[i]];
       } else {
-        value = bloomHash(flags);
+        result[i] = [];
       }
-      if (value == null && !(flags & 8)) {
-        throwProviderNotFoundError(token);
-      } else {
-        return value;
+      if (paramAnnotations && paramAnnotations[i] != null) {
+        result[i] = result[i].concat(paramAnnotations[i]);
       }
-    } finally {
-      leaveDI();
     }
-  } else if (typeof bloomHash === 'number') {
-    let previousTView = null;
-    let injectorIndex = getInjectorIndex(tNode, lView);
-    let parentLocation = NO_PARENT_INJECTOR;
-    let hostTElementNode = flags & 1 ? lView[DECLARATION_COMPONENT_VIEW][T_HOST] : null;
-    if (injectorIndex === -1 || flags & 4) {
-      parentLocation = injectorIndex === -1 ? getParentInjectorLocation(tNode, lView) : lView[injectorIndex + 8];
-      if (parentLocation === NO_PARENT_INJECTOR || !shouldSearchParent(flags, false)) {
-        injectorIndex = -1;
-      } else {
-        previousTView = lView[TVIEW];
-        injectorIndex = getParentInjectorIndex(parentLocation);
-        lView = getParentInjectorView(parentLocation, lView);
-      }
+    return result;
+  }
+  _ownParameters(type, parentCtor) {
+    const typeStr = type.toString();
+    if (isDelegateCtor(typeStr)) {
+      return null;
     }
-    while (injectorIndex !== -1) {
-      ngDevMode && assertNodeInjector(lView, injectorIndex);
-      const tView = lView[TVIEW];
-      ngDevMode && assertTNodeForLView(tView.data[injectorIndex + 8], lView);
-      if (bloomHasToken(bloomHash, injectorIndex, tView.data)) {
-        const instance = searchTokensOnInjector(injectorIndex, lView, token, previousTView, flags, hostTElementNode);
-        if (instance !== NOT_FOUND) {
-          return instance;
-        }
-      }
-      parentLocation = lView[injectorIndex + 8];
-      if (parentLocation !== NO_PARENT_INJECTOR && shouldSearchParent(flags, lView[TVIEW].data[injectorIndex + 8] === hostTElementNode) && bloomHasToken(bloomHash, injectorIndex, lView)) {
-        previousTView = tView;
-        injectorIndex = getParentInjectorIndex(parentLocation);
-        lView = getParentInjectorView(parentLocation, lView);
-      } else {
-        injectorIndex = -1;
-      }
+    if (type.parameters && type.parameters !== parentCtor.parameters) {
+      return type.parameters;
     }
-  }
-  return notFoundValue;
-}
-function searchTokensOnInjector(injectorIndex, lView, token, previousTView, flags, hostTElementNode) {
-  const currentTView = lView[TVIEW];
-  const tNode = currentTView.data[injectorIndex + 8];
-  const canAccessViewProviders = previousTView == null ? isComponentHost(tNode) && includeViewProviders : previousTView != currentTView && (tNode.type & 3) !== 0;
-  const isHostSpecialCase = flags & 1 && hostTElementNode === tNode;
-  const injectableIdx = locateDirectiveOrProvider(tNode, currentTView, token, canAccessViewProviders, isHostSpecialCase);
-  if (injectableIdx !== null) {
-    return getNodeInjectable(lView, currentTView, injectableIdx, tNode, flags);
-  } else {
-    return NOT_FOUND;
-  }
-}
-function locateDirectiveOrProvider(tNode, tView, token, canAccessViewProviders, isHostSpecialCase) {
-  const nodeProviderIndexes = tNode.providerIndexes;
-  const tInjectables = tView.data;
-  const injectablesStart = nodeProviderIndexes & 1048575;
-  const directivesStart = tNode.directiveStart;
-  const directiveEnd = tNode.directiveEnd;
-  const cptViewProvidersCount = nodeProviderIndexes >> 20;
-  const startingIndex = canAccessViewProviders ? injectablesStart : injectablesStart + cptViewProvidersCount;
-  const endIndex = isHostSpecialCase ? injectablesStart + cptViewProvidersCount : directiveEnd;
-  for (let i = startingIndex; i < endIndex; i++) {
-    const providerTokenOrDef = tInjectables[i];
-    if (i < directivesStart && token === providerTokenOrDef || i >= directivesStart && providerTokenOrDef.type === token) {
-      return i;
+    const tsickleCtorParams = type.ctorParameters;
+    if (tsickleCtorParams && tsickleCtorParams !== parentCtor.ctorParameters) {
+      const ctorParameters = typeof tsickleCtorParams === 'function' ? tsickleCtorParams() : tsickleCtorParams;
+      const paramTypes = ctorParameters.map(ctorParam => ctorParam && ctorParam.type);
+      const paramAnnotations = ctorParameters.map(ctorParam => ctorParam && convertTsickleDecoratorIntoMetadata(ctorParam.decorators));
+      return this._zipTypesAndAnnotations(paramTypes, paramAnnotations);
+    }
+    const paramAnnotations = type.hasOwnProperty(PARAMETERS) && type[PARAMETERS];
+    const paramTypes = this._reflect && this._reflect.getOwnMetadata && this._reflect.getOwnMetadata('design:paramtypes', type);
+    if (paramTypes || paramAnnotations) {
+      return this._zipTypesAndAnnotations(paramTypes, paramAnnotations);
     }
+    return newArray(type.length);
   }
-  if (isHostSpecialCase) {
-    const dirDef = tInjectables[directivesStart];
-    if (dirDef && isComponentDef(dirDef) && dirDef.type === token) {
-      return directivesStart;
+  parameters(type) {
+    if (!isType(type)) {
+      return [];
+    }
+    const parentCtor = getParentCtor(type);
+    let parameters = this._ownParameters(type, parentCtor);
+    if (!parameters && parentCtor !== Object) {
+      parameters = this.parameters(parentCtor);
     }
+    return parameters || [];
   }
-  return null;
-}
-let injectionPath = [];
-function getNodeInjectable(lView, tView, index, tNode, flags) {
-  let value = lView[index];
-  const tData = tView.data;
-  if (value instanceof NodeInjectorFactory) {
-    const factory = value;
-    ngDevMode && injectionPath.push(factory.name ?? 'unknown');
-    if (factory.resolving) {
-      let token = '';
-      if (ngDevMode) {
-        token = stringifyForError(tData[index]);
-        throw cyclicDependencyErrorWithDetails(token, injectionPath);
-      } else {
-        throw cyclicDependencyError(token);
+  _ownAnnotations(typeOrFunc, parentCtor) {
+    if (typeOrFunc.annotations && typeOrFunc.annotations !== parentCtor.annotations) {
+      let annotations = typeOrFunc.annotations;
+      if (typeof annotations === 'function' && annotations.annotations) {
+        annotations = annotations.annotations;
       }
+      return annotations;
     }
-    const previousIncludeViewProviders = setIncludeViewProviders(factory.canSeeViewProviders);
-    factory.resolving = true;
-    const token = tData[index].type || tData[index];
-    let prevInjectContext;
-    if (ngDevMode) {
-      const injector = new NodeInjector(tNode, lView);
-      prevInjectContext = setInjectorProfilerContext({
-        injector,
-        token
-      });
+    if (typeOrFunc.decorators && typeOrFunc.decorators !== parentCtor.decorators) {
+      return convertTsickleDecoratorIntoMetadata(typeOrFunc.decorators);
     }
-    const previousInjectImplementation = factory.injectImpl ? setInjectImplementation(factory.injectImpl) : null;
-    const success = enterDI(lView, tNode, 0);
-    ngDevMode && assertEqual(success, true, "Because flags do not contain `SkipSelf' we expect this to always succeed.");
-    try {
-      ngDevMode && emitInjectorToCreateInstanceEvent(token);
-      value = lView[index] = factory.factory(undefined, flags, tData, lView, tNode);
-      ngDevMode && emitInstanceCreatedByInjectorEvent(value);
-      if (tView.firstCreatePass && index >= tNode.directiveStart) {
-        ngDevMode && assertDirectiveDef(tData[index]);
-        registerPreOrderHooks(index, tData[index], tView);
-      }
-    } finally {
-      ngDevMode && setInjectorProfilerContext(prevInjectContext);
-      previousInjectImplementation !== null && setInjectImplementation(previousInjectImplementation);
-      setIncludeViewProviders(previousIncludeViewProviders);
-      factory.resolving = false;
-      leaveDI();
-      ngDevMode && (injectionPath = []);
+    if (typeOrFunc.hasOwnProperty(ANNOTATIONS)) {
+      return typeOrFunc[ANNOTATIONS];
     }
+    return null;
   }
-  return value;
-}
-function bloomHashBitOrFactory(token) {
-  ngDevMode && assertDefined(token, 'token must be defined');
-  if (typeof token === 'string') {
-    return token.charCodeAt(0) || 0;
-  }
-  const tokenId = token.hasOwnProperty(NG_ELEMENT_ID) ? token[NG_ELEMENT_ID] : undefined;
-  if (typeof tokenId === 'number') {
-    if (tokenId >= 0) {
-      return tokenId & BLOOM_MASK;
-    } else {
-      ngDevMode && assertEqual(tokenId, -1, 'Expecting to get Special Injector Id');
-      return createNodeInjector;
+  annotations(typeOrFunc) {
+    if (!isType(typeOrFunc)) {
+      return [];
     }
-  } else {
-    return tokenId;
-  }
-}
-function bloomHasToken(bloomHash, injectorIndex, injectorView) {
-  const mask = 1 << bloomHash;
-  const value = injectorView[injectorIndex + (bloomHash >> BLOOM_BUCKET_BITS)];
-  return !!(value & mask);
-}
-function shouldSearchParent(flags, isFirstHostTNode) {
-  return !(flags & 2) && !(flags & 1 && isFirstHostTNode);
-}
-function getNodeInjectorLView(nodeInjector) {
-  return nodeInjector._lView;
-}
-function getNodeInjectorTNode(nodeInjector) {
-  return nodeInjector._tNode;
-}
-class NodeInjector {
-  _tNode;
-  _lView;
-  constructor(_tNode, _lView) {
-    this._tNode = _tNode;
-    this._lView = _lView;
-  }
-  get(token, notFoundValue, flags) {
-    return getOrCreateInjectable(this._tNode, this._lView, token, convertToBitFlags(flags), notFoundValue);
+    const parentCtor = getParentCtor(typeOrFunc);
+    const ownAnnotations = this._ownAnnotations(typeOrFunc, parentCtor) || [];
+    const parentAnnotations = parentCtor !== Object ? this.annotations(parentCtor) : [];
+    return parentAnnotations.concat(ownAnnotations);
   }
-}
-function createNodeInjector() {
-  return new NodeInjector(getCurrentTNode(), getLView());
-}
-function ɵɵgetInheritedFactory(type) {
-  return noSideEffects(() => {
-    const ownConstructor = type.prototype.constructor;
-    const ownFactory = ownConstructor[NG_FACTORY_DEF] || getFactoryOf(ownConstructor);
-    const objectPrototype = Object.prototype;
-    let parent = Object.getPrototypeOf(type.prototype).constructor;
-    while (parent && parent !== objectPrototype) {
-      const factory = parent[NG_FACTORY_DEF] || getFactoryOf(parent);
-      if (factory && factory !== ownFactory) {
-        return factory;
+  _ownPropMetadata(typeOrFunc, parentCtor) {
+    if (typeOrFunc.propMetadata && typeOrFunc.propMetadata !== parentCtor.propMetadata) {
+      let propMetadata = typeOrFunc.propMetadata;
+      if (typeof propMetadata === 'function' && propMetadata.propMetadata) {
+        propMetadata = propMetadata.propMetadata;
       }
-      parent = Object.getPrototypeOf(parent);
+      return propMetadata;
     }
-    return t => new t();
-  });
-}
-function getFactoryOf(type) {
-  if (isForwardRef(type)) {
-    return () => {
-      const factory = getFactoryOf(resolveForwardRef(type));
-      return factory && factory();
-    };
+    if (typeOrFunc.propDecorators && typeOrFunc.propDecorators !== parentCtor.propDecorators) {
+      const propDecorators = typeOrFunc.propDecorators;
+      const propMetadata = {};
+      Object.keys(propDecorators).forEach(prop => {
+        propMetadata[prop] = convertTsickleDecoratorIntoMetadata(propDecorators[prop]);
+      });
+      return propMetadata;
+    }
+    if (typeOrFunc.hasOwnProperty(PROP_METADATA)) {
+      return typeOrFunc[PROP_METADATA];
+    }
+    return null;
   }
-  return getFactoryDef(type);
-}
-function lookupTokenUsingEmbeddedInjector(tNode, lView, token, flags, notFoundValue) {
-  let currentTNode = tNode;
-  let currentLView = lView;
-  while (currentTNode !== null && currentLView !== null && currentLView[FLAGS] & 2048 && !isRootView(currentLView)) {
-    ngDevMode && assertTNodeForLView(currentTNode, currentLView);
-    const nodeInjectorValue = lookupTokenUsingNodeInjector(currentTNode, currentLView, token, flags | 2, NOT_FOUND);
-    if (nodeInjectorValue !== NOT_FOUND) {
-      return nodeInjectorValue;
+  propMetadata(typeOrFunc) {
+    if (!isType(typeOrFunc)) {
+      return {};
     }
-    let parentTNode = currentTNode.parent;
-    if (!parentTNode) {
-      const embeddedViewInjector = currentLView[EMBEDDED_VIEW_INJECTOR];
-      if (embeddedViewInjector) {
-        const embeddedViewInjectorValue = embeddedViewInjector.get(token, NOT_FOUND, flags & -5);
-        if (embeddedViewInjectorValue !== NOT_FOUND) {
-          return embeddedViewInjectorValue;
+    const parentCtor = getParentCtor(typeOrFunc);
+    const propMetadata = {};
+    if (parentCtor !== Object) {
+      const parentPropMetadata = this.propMetadata(parentCtor);
+      Object.keys(parentPropMetadata).forEach(propName => {
+        propMetadata[propName] = parentPropMetadata[propName];
+      });
+    }
+    const ownPropMetadata = this._ownPropMetadata(typeOrFunc, parentCtor);
+    if (ownPropMetadata) {
+      Object.keys(ownPropMetadata).forEach(propName => {
+        const decorators = [];
+        if (propMetadata.hasOwnProperty(propName)) {
+          decorators.push(...propMetadata[propName]);
         }
-      }
-      parentTNode = getTNodeFromLView(currentLView);
-      currentLView = currentLView[DECLARATION_VIEW];
+        decorators.push(...ownPropMetadata[propName]);
+        propMetadata[propName] = decorators;
+      });
     }
-    currentTNode = parentTNode;
+    return propMetadata;
+  }
+  ownPropMetadata(typeOrFunc) {
+    if (!isType(typeOrFunc)) {
+      return {};
+    }
+    return this._ownPropMetadata(typeOrFunc, getParentCtor(typeOrFunc)) || {};
+  }
+  hasLifecycleHook(type, lcProperty) {
+    return type instanceof Type && lcProperty in type.prototype;
   }
-  return notFoundValue;
 }
-function getTNodeFromLView(lView) {
-  const tView = lView[TVIEW];
-  const tViewType = tView.type;
-  if (tViewType === 2) {
-    ngDevMode && assertDefined(tView.declTNode, 'Embedded TNodes should have declaration parents.');
-    return tView.declTNode;
-  } else if (tViewType === 1) {
-    return lView[T_HOST];
+function convertTsickleDecoratorIntoMetadata(decoratorInvocations) {
+  if (!decoratorInvocations) {
+    return [];
   }
-  return null;
+  return decoratorInvocations.map(decoratorInvocation => {
+    const decoratorType = decoratorInvocation.type;
+    const annotationCls = decoratorType.annotationCls;
+    const annotationArgs = decoratorInvocation.args ? decoratorInvocation.args : [];
+    return new annotationCls(...annotationArgs);
+  });
 }
-
-function ɵɵinjectAttribute(attrNameToInject) {
-  return injectAttributeImpl(getCurrentTNode(), attrNameToInject);
+function getParentCtor(ctor) {
+  const parentProto = ctor.prototype ? Object.getPrototypeOf(ctor.prototype) : null;
+  const parentCtor = parentProto ? parentProto.constructor : null;
+  return parentCtor || Object;
 }
 
+const Inject = attachInjectFlag(makeParamDecorator('Inject', token => ({
+  token
+})), -1);
+const Optional = attachInjectFlag(makeParamDecorator('Optional'), 8);
+const Self = attachInjectFlag(makeParamDecorator('Self'), 2);
+const SkipSelf = attachInjectFlag(makeParamDecorator('SkipSelf'), 4);
+const Host = attachInjectFlag(makeParamDecorator('Host'), 1);
+
 const Attribute = makeParamDecorator('Attribute', attributeName => ({
   attributeName,
   __NG_ELEMENT_ID__: () => ɵɵinjectAttribute(attributeName)
@@ -1321,6 +1357,60 @@ function getInjectableMetadata(type, srcMeta) {
 
 const Injectable = makeDecorator('Injectable', undefined, undefined, undefined, (type, meta) => compileInjectable(type, meta));
 
+function compileService(type, meta) {
+  let def = null;
+  let factoryDef = null;
+  if (!type.hasOwnProperty(NG_PROV_DEF)) {
+    Object.defineProperty(type, NG_PROV_DEF, {
+      get: () => {
+        if (def === null) {
+          const compiler = getCompilerFacade({
+            usage: 0,
+            kind: 'service',
+            type
+          });
+          def = compiler.compileService(angularCoreDiEnv, `ng:///${type.name}/ɵprov.js`, getServiceMetadata(type, meta));
+        }
+        return def;
+      }
+    });
+  }
+  if (!type.hasOwnProperty(NG_FACTORY_DEF)) {
+    Object.defineProperty(type, NG_FACTORY_DEF, {
+      get: () => {
+        if (factoryDef === null) {
+          const compiler = getCompilerFacade({
+            usage: 0,
+            kind: 'service',
+            type
+          });
+          factoryDef = compiler.compileFactory(angularCoreDiEnv, `ng:///${type.name}/ɵfac.js`, {
+            name: type.name,
+            type,
+            typeArgumentCount: 0,
+            deps: reflectDependencies(type),
+            target: compiler.FactoryTarget.Service
+          });
+        }
+        return factoryDef;
+      },
+      configurable: true
+    });
+  }
+}
+function getServiceMetadata(type, srcMeta) {
+  const compilerMeta = {
+    name: type.name,
+    type: type,
+    typeArgumentCount: 0,
+    autoProvided: srcMeta?.autoProvided,
+    factory: srcMeta?.factory
+  };
+  return compilerMeta;
+}
+
+const Service = makeDecorator('Service', undefined, undefined, undefined, (type, meta) => compileService(type, meta));
+
 function injectElementRef() {
   return createElementRef(getCurrentTNode(), getLView());
 }
@@ -1334,6 +1424,9 @@ class ElementRef {
   }
   static __NG_ELEMENT_ID__ = injectElementRef;
 }
+if (typeof ngDevMode === 'undefined' || ngDevMode) {
+  registerSpecialProvider(ElementRef);
+}
 function unwrapElementRef(value) {
   return value instanceof ElementRef ? value.nativeElement : value;
 }
@@ -1975,104 +2068,6 @@ function getDocument() {
   throw new RuntimeError(210, (typeof ngDevMode === 'undefined' || ngDevMode) && `The document object is not available in this context. Make sure the DOCUMENT injection token is provided.`);
 }
 
-const APP_ID = new InjectionToken(typeof ngDevMode !== 'undefined' && ngDevMode ? 'AppId' : '', {
-  factory: () => DEFAULT_APP_ID
-});
-const DEFAULT_APP_ID = 'ng';
-const validAppIdInitializer = {
-  provide: ENVIRONMENT_INITIALIZER,
-  multi: true,
-  useValue: () => {
-    const appId = inject(APP_ID);
-    const isAlphanumeric = /^[a-zA-Z0-9\-_]+$/.test(appId);
-    if (!isAlphanumeric) {
-      throw new RuntimeError(211, `APP_ID value "${appId}" is not alphanumeric. ` + `The APP_ID must be a string of alphanumeric characters. (a-zA-Z0-9), hyphens (-) and underscores (_) are allowed.`);
-    }
-  }
-};
-const PLATFORM_INITIALIZER = new InjectionToken(typeof ngDevMode !== 'undefined' && ngDevMode ? 'Platform Initializer' : '');
-const PLATFORM_ID = new InjectionToken(typeof ngDevMode !== 'undefined' && ngDevMode ? 'Platform ID' : '', {
-  providedIn: 'platform',
-  factory: () => 'unknown'
-});
-const ANIMATION_MODULE_TYPE = new InjectionToken(typeof ngDevMode !== 'undefined' && ngDevMode ? 'AnimationModuleType' : '');
-const CSP_NONCE = new InjectionToken(typeof ngDevMode !== 'undefined' && ngDevMode ? 'CSP nonce' : '', {
-  factory: () => {
-    return inject(DOCUMENT$1).body?.querySelector('[ngCspNonce]')?.getAttribute('ngCspNonce') || null;
-  }
-});
-const IMAGE_CONFIG_DEFAULTS = {
-  breakpoints: [16, 32, 48, 64, 96, 128, 256, 384, 640, 750, 828, 1080, 1200, 1920, 2048, 3840],
-  placeholderResolution: 30,
-  disableImageSizeWarning: false,
-  disableImageLazyLoadWarning: false
-};
-const IMAGE_CONFIG = new InjectionToken(typeof ngDevMode !== 'undefined' && ngDevMode ? 'ImageConfig' : '', {
-  factory: () => IMAGE_CONFIG_DEFAULTS
-});
-
-function makeStateKey(key) {
-  return key;
-}
-class TransferState {
-  static ɵprov =
-  /* @__PURE__ */
-  __defineInjectable({
-    token: TransferState,
-    providedIn: 'root',
-    factory: () => {
-      const transferState = new TransferState();
-      if (typeof ngServerMode === 'undefined' || !ngServerMode) {
-        transferState.store = retrieveTransferredState(inject(DOCUMENT$1), inject(APP_ID));
-      }
-      return transferState;
-    }
-  });
-  store = {};
-  onSerializeCallbacks = {};
-  get(key, defaultValue) {
-    return this.store[key] !== undefined ? this.store[key] : defaultValue;
-  }
-  set(key, value) {
-    this.store[key] = value;
-  }
-  remove(key) {
-    delete this.store[key];
-  }
-  hasKey(key) {
-    return this.store.hasOwnProperty(key);
-  }
-  get isEmpty() {
-    return Object.keys(this.store).length === 0;
-  }
-  onSerialize(key, callback) {
-    this.onSerializeCallbacks[key] = callback;
-  }
-  toJson() {
-    for (const key in this.onSerializeCallbacks) {
-      if (this.onSerializeCallbacks.hasOwnProperty(key)) {
-        try {
-          this.store[key] = this.onSerializeCallbacks[key]();
-        } catch (e) {
-          console.warn('Exception in onSerialize callback: ', e);
-        }
-      }
-    }
-    return JSON.stringify(this.store).replace(/</g, '\\u003C').replace(/\//g, '\\u002F');
-  }
-}
-function retrieveTransferredState(doc, appId) {
-  const script = doc.getElementById(appId + '-state');
-  if (script?.textContent) {
-    try {
-      return JSON.parse(script.textContent);
-    } catch (e) {
-      console.warn('Exception while restoring TransferState for app ' + appId, e);
-    }
-  }
-  return {};
-}
-
 const REFERENCE_NODE_HOST = 'h';
 const REFERENCE_NODE_BODY = 'b';
 const NODE_NAVIGATION_STEP_FIRST_CHILD = 'f';
@@ -2289,11 +2284,24 @@ const removeListeners = el => {
 const JSACTION_EVENT_CONTRACT = new InjectionToken(typeof ngDevMode !== 'undefined' && ngDevMode ? 'EVENT_CONTRACT_DETAILS' : '', {
   factory: () => ({})
 });
+const handledEventElements = new WeakMap();
+function markEventHandledForElement(event, element) {
+  if (event == null || typeof event !== 'object') return;
+  let elements = handledEventElements.get(event);
+  if (!elements) {
+    elements = new WeakSet();
+    handledEventElements.set(event, elements);
+  }
+  elements.add(element);
+}
 function invokeListeners(event, currentTarget) {
   const handlerFns = currentTarget?.__jsaction_fns?.get(event.type);
   if (!handlerFns || !currentTarget?.isConnected) {
     return;
   }
+  if (currentTarget && handledEventElements.get(event)?.has(currentTarget)) {
+    return;
+  }
   for (const handler of handlerFns) {
     handler(event);
   }
@@ -3457,12 +3465,6 @@ function validateAgainstEventProperties(name) {
     throw new RuntimeError(306, errorMessage);
   }
 }
-function validateAgainstEventAttributes(name) {
-  if (name.toLowerCase().startsWith('on')) {
-    const errorMessage = `Binding to event attribute '${name}' is disallowed for security reasons, ` + `please use (${name.slice(2)})=...`;
-    throw new RuntimeError(306, errorMessage);
-  }
-}
 function getSanitizer() {
   const lView = getLView();
   return lView && lView[ENVIRONMENT].sanitizer;
@@ -5316,7 +5318,9 @@ function setDomProperty(tNode, lView, propName, value, renderer, sanitizer) {
   if (tNode.type & 3) {
     const element = getNativeByTNode(tNode, lView);
     if (ngDevMode) {
-      validateAgainstEventProperties(propName);
+      if (lView[TVIEW].firstUpdatePass) {
+        validateAgainstEventProperties(propName);
+      }
       if (!isPropertyValid(element, propName, tNode.value, lView[TVIEW].schemas)) {
         handleUnknownPropertyError(propName, tNode.value, tNode.type, lView);
       }
@@ -5458,7 +5462,6 @@ function findDirectiveDefMatches(tView, tNode) {
 function elementAttributeInternal(tNode, lView, name, value, sanitizer, namespace) {
   if (ngDevMode) {
     assertNotSame(value, NO_CHANGE, 'Incoming value should never be NO_CHANGE.');
-    validateAgainstEventAttributes(name);
     assertTNodeType(tNode, 2, `Attempted to set attribute \`${name}\` on a container node. ` + `Host bindings are not valid on ng-container or ng-template.`);
   }
   const element = getNativeByTNode(tNode, lView);
@@ -7641,6 +7644,9 @@ class Renderer2 {
   destroyNode = null;
   static __NG_ELEMENT_ID__ = () => injectRenderer2();
 }
+if (typeof ngDevMode === 'undefined' || ngDevMode) {
+  registerSpecialProvider(Renderer2);
+}
 function injectRenderer2() {
   const lView = getLView();
   const tNode = getCurrentTNode();
@@ -8034,6 +8040,10 @@ function bindingUpdated4(lView, bindingIndex, exp1, exp2, exp3, exp4) {
 
 function wrapListener(tNode, lView, listenerFn) {
   return function wrapListenerIn_markDirtyAndPreventDefault(event) {
+    const nativeEl = wrapListenerIn_markDirtyAndPreventDefault.__ngNativeEl__;
+    if (nativeEl !== undefined) {
+      markEventHandledForElement(event, nativeEl);
+    }
     const startView = isComponentHost(tNode) ? getComponentLViewByIndex(tNode.index, lView) : lView;
     markViewDirty(startView, 5);
     const context = lView[CONTEXT];
@@ -8076,6 +8086,9 @@ function listenToDomEvent(tNode, tView, lView, eventTargetResolver, renderer, ev
     const native = getNativeByTNode(tNode, lView);
     const target = eventTargetResolver ? eventTargetResolver(native) : native;
     stashEventListenerImpl(lView, target, eventName, wrappedListener);
+    if (!eventTargetResolver) {
+      wrappedListener.__ngNativeEl__ = native;
+    }
     const cleanupFn = renderer.listen(target, eventName, wrappedListener);
     if (!isAnimationEventType(eventName)) {
       const idxOrTargetGetter = eventTargetResolver ? _lView => eventTargetResolver(unwrapRNode(_lView[tNode.index])) : tNode.index;
@@ -9010,7 +9023,7 @@ class ComponentFactory {
   }
 }
 function createRootTView(rootSelectorOrNode, componentDef, componentBindings, directives) {
-  const tAttributes = rootSelectorOrNode ? ['ng-version', '22.0.0-next.9'] : extractAttrsAndClassesFromSelector(componentDef.selectors[0]);
+  const tAttributes = rootSelectorOrNode ? ['ng-version', '22.0.0-rc.0'] : extractAttrsAndClassesFromSelector(componentDef.selectors[0]);
   let creationBindings = null;
   let updateBindings = null;
   let varsToAllocate = 0;
@@ -9155,6 +9168,9 @@ function projectNodes(tNode, ngContentSelectors, projectableNodes) {
 class ViewContainerRef {
   static __NG_ELEMENT_ID__ = injectViewContainerRef;
 }
+if (typeof ngDevMode === 'undefined' || ngDevMode) {
+  registerSpecialProvider(ViewContainerRef);
+}
 function injectViewContainerRef() {
   const previousTNode = getCurrentTNode();
   return createContainerRef(previousTNode, getLView());
@@ -10110,15 +10126,19 @@ function getComponentId(componentDef) {
 }
 
 const ASYNC_COMPONENT_METADATA_FN = '__ngAsyncComponentMetadataFn__';
+const ASYNC_METADATA_LOADED = '__ngAsyncMetadataLoaded__';
 function getAsyncClassMetadataFn(type) {
   const componentClass = type;
+  if (componentClass[ASYNC_COMPONENT_METADATA_FN] === ASYNC_METADATA_LOADED) {
+    return null;
+  }
   return componentClass[ASYNC_COMPONENT_METADATA_FN] ?? null;
 }
 function setClassMetadataAsync(type, dependencyLoaderFn, metadataSetterFn) {
   const componentClass = type;
   componentClass[ASYNC_COMPONENT_METADATA_FN] = () => Promise.all(dependencyLoaderFn()).then(dependencies => {
     metadataSetterFn(...dependencies);
-    componentClass[ASYNC_COMPONENT_METADATA_FN] = null;
+    componentClass[ASYNC_COMPONENT_METADATA_FN] = ASYNC_METADATA_LOADED;
     return dependencies;
   });
   return componentClass[ASYNC_COMPONENT_METADATA_FN];
@@ -10211,18 +10231,14 @@ class ApplicationInitStatus {
   static ɵfac = function ApplicationInitStatus_Factory(__ngFactoryType__) {
     return new (__ngFactoryType__ || ApplicationInitStatus)();
   };
-  static ɵprov = /*@__PURE__*/__defineInjectable({
+  static ɵprov = /*@__PURE__*/ɵɵdefineService({
     token: ApplicationInitStatus,
-    factory: ApplicationInitStatus.ɵfac,
-    providedIn: 'root'
+    factory: ApplicationInitStatus.ɵfac
   });
 }
 (() => {
   (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(ApplicationInitStatus, [{
-    type: Injectable,
-    args: [{
-      providedIn: 'root'
-    }]
+    type: Service
   }], () => [], null);
 })();
 
@@ -10952,28 +10968,6 @@ function registerDomTrigger(initialLView, tNode, triggerIndex, walkUpTimes, regi
   });
 }
 
-const _requestIdleCallback = () => (typeof requestIdleCallback !== 'undefined' ? requestIdleCallback : cb => setTimeout(cb)).bind(globalThis);
-const _cancelIdleCallback = () => (typeof requestIdleCallback !== 'undefined' ? cancelIdleCallback : clearTimeout).bind(globalThis);
-const IDLE_SERVICE = new InjectionToken(ngDevMode ? 'IDLE_SERVICE' : '', {
-  factory: () => new RequestIdleCallbackService()
-});
-function provideIdleServiceWith(useExisting) {
-  return makeEnvironmentProviders([{
-    provide: IDLE_SERVICE,
-    useExisting
-  }]);
-}
-class RequestIdleCallbackService {
-  requestIdleCallback = _requestIdleCallback();
-  cancelIdleCallback = _cancelIdleCallback();
-  requestOnIdle(callback, options) {
-    return this.requestIdleCallback(callback, options);
-  }
-  cancelOnIdle(id) {
-    return this.cancelIdleCallback(id);
-  }
-}
-
 class Console {
   log(message) {
     console.log(message);
@@ -11490,7 +11484,13 @@ function getNodeInjectorProviders(injector) {
   const {
     resolverToProviders
   } = getFrameworkDIDebugData();
-  return resolverToProviders.get(diResolver) ?? [];
+  const existingProviders = resolverToProviders.get(diResolver) ?? [];
+  const specialProviders = Array.from(getAllSpecialProviders()).map(token => ({
+    token: token,
+    isViewProvider: false,
+    provider: token
+  }));
+  return [...existingProviders, ...specialProviders];
 }
 function getProviderImportPaths(providerImportsContainer) {
   const providerToPath = new Map();
@@ -11799,7 +11799,7 @@ let counter = 0;
 const eventsStack = [];
 function getBaseDocUrl() {
   const full = VERSION.full;
-  const isPreRelease = full.includes('-next') || full.includes('-rc') || full === '22.0.0-next.9';
+  const isPreRelease = full.includes('-next') || full.includes('-rc') || full === '22.0.0-rc.0';
   const prefix = isPreRelease ? 'next' : `v${VERSION.major}`;
   return `https://${prefix}.angular.dev`;
 }
@@ -12514,18 +12514,14 @@ class ApplicationRef {
   static ɵfac = function ApplicationRef_Factory(__ngFactoryType__) {
     return new (__ngFactoryType__ || ApplicationRef)();
   };
-  static ɵprov = /*@__PURE__*/__defineInjectable({
+  static ɵprov = /*@__PURE__*/ɵɵdefineService({
     token: ApplicationRef,
-    factory: ApplicationRef.ɵfac,
-    providedIn: 'root'
+    factory: ApplicationRef.ɵfac
   });
 }
 (() => {
   (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(ApplicationRef, [{
-    type: Injectable,
-    args: [{
-      providedIn: 'root'
-    }]
+    type: Service
   }], () => [], null);
 })();
 function normalizeBootstrapOptions(hostElementOrOptions) {
@@ -12967,20 +12963,6 @@ function ɵɵdeferEnableTimerScheduling(tView, tDetails, placeholderConfigIndex,
   }
 }
 
-function promiseWithResolvers() {
-  let resolve;
-  let reject;
-  const promise = new Promise((res, rej) => {
-    resolve = res;
-    reject = rej;
-  });
-  return {
-    promise,
-    resolve,
-    reject
-  };
-}
-
 function scheduleDelayedTrigger(scheduleFn) {
   const lView = getLView();
   const tNode = getCurrentTNode();
@@ -14943,15 +14925,18 @@ function setMaskBit(hasChange) {
   changeMaskCounter++;
 }
 function applyI18n(tView, lView, index) {
-  if (changeMaskCounter > 0) {
-    ngDevMode && assertDefined(tView, `tView should be defined`);
-    const tI18n = tView.data[index];
-    const updateOpCodes = Array.isArray(tI18n) ? tI18n : tI18n.update;
-    const bindingsStartIndex = getBindingIndex() - changeMaskCounter - 1;
-    applyUpdateOpCodes(tView, lView, updateOpCodes, bindingsStartIndex, changeMask);
+  try {
+    if (changeMaskCounter > 0) {
+      ngDevMode && assertDefined(tView, `tView should be defined`);
+      const tI18n = tView.data[index];
+      const updateOpCodes = Array.isArray(tI18n) ? tI18n : tI18n.update;
+      const bindingsStartIndex = getBindingIndex() - changeMaskCounter - 1;
+      applyUpdateOpCodes(tView, lView, updateOpCodes, bindingsStartIndex, changeMask);
+    }
+  } finally {
+    changeMask = 0b0;
+    changeMaskCounter = 0;
   }
-  changeMask = 0b0;
-  changeMaskCounter = 0;
 }
 function createNodeWithoutHydration(lView, textOrName, nodeType) {
   const renderer = lView[RENDERER];
@@ -15503,7 +15488,7 @@ function i18nAttributesFirstPass(tView, index, values) {
         if (ICU_REGEXP.test(message)) {
           throw new Error(`ICU expressions are not supported in attributes. Message: "${message}".`);
         }
-        generateBindingUpdateOpCodes(updateOpCodes, message, previousElementIndex, attrName, countBindings(updateOpCodes), SENSITIVE_ATTRS[attrName.toLowerCase()] ? _sanitizeUrl : null);
+        generateBindingUpdateOpCodes(updateOpCodes, message, previousElementIndex, attrName, countBindings(updateOpCodes), i18nSanitizeAttribute(attrName));
       }
     }
     tView.data[index] = updateOpCodes;
@@ -15735,7 +15720,7 @@ function walkIcuTree(ast, tView, tIcu, lView, sharedUpdateOpCodes, create, remov
             const hasBinding = !!attr.value.match(BINDING_REGEXP);
             if (hasBinding) {
               if (VALID_ATTRS.hasOwnProperty(lowerAttrName)) {
-                generateBindingUpdateOpCodes(update, attr.value, newIndex, attr.name, 0, SENSITIVE_ATTRS[lowerAttrName] ? _sanitizeUrl : null);
+                generateBindingUpdateOpCodes(update, attr.value, newIndex, attr.name, 0, i18nSanitizeAttribute(lowerAttrName));
               } else {
                 ngDevMode && console.warn(`WARNING: ignoring unsafe attribute value ` + `${lowerAttrName} on element ${tagName} ` + `(see ${XSS_SECURITY_URL})`);
               }
@@ -15818,6 +15803,17 @@ function addCreateNodeAndAppend(create, marker, text, appendToParentIdx, createA
 function addCreateAttribute(create, newIndex, attrName, attrValue) {
   create.push(newIndex << 1 | 1, attrName, attrValue);
 }
+const SECURITY_SENSITIVE_ATTRS = /* @__PURE__ */(() => new Set(Object.values(SECURITY_SENSITIVE_ELEMENTS).flatMap(attrs => attrs ? Object.keys(attrs) : [])))();
+function i18nSanitizeAttribute(attrName) {
+  const lowerAttrName = attrName.toLowerCase();
+  if (SENSITIVE_ATTRS[lowerAttrName]) {
+    return _sanitizeUrl;
+  }
+  if (SECURITY_SENSITIVE_ATTRS.has(lowerAttrName)) {
+    return ɵɵvalidateAttribute;
+  }
+  return null;
+}
 
 const ROOT_TEMPLATE_ID = 0;
 const PP_MULTI_VALUE_PLACEHOLDERS_REGEXP = /\[(�.+?�?)\]/;
@@ -17189,6 +17185,31 @@ function maybeUnwrapModuleWithProviders(value) {
   return isModuleWithProviders(value) ? value.ngModule : value;
 }
 
+let _dehydratedBlockRegistryFactory = () => null;
+let _runIncrementalHydrationBootstrap = () => {};
+let isIncrementalHydrationRuntimeActive = false;
+function createDehydratedBlockRegistry() {
+  return _dehydratedBlockRegistryFactory();
+}
+function runIncrementalHydrationBootstrap(injector, doc) {
+  _runIncrementalHydrationBootstrap(injector, doc);
+}
+function ɵɵenableIncrementalHydrationRuntime() {
+  if (isIncrementalHydrationRuntimeActive) {
+    return;
+  }
+  isIncrementalHydrationRuntimeActive = true;
+  enableRetrieveDeferBlockDataImpl();
+  performanceMarkFeature('NgIncrementalHydration');
+  _dehydratedBlockRegistryFactory = () => new DehydratedBlockRegistry();
+  _runIncrementalHydrationBootstrap = (injector, doc) => {
+    const deferBlockData = processBlockData(injector);
+    const commentsByBlockId = gatherDeferBlocksCommentNodes(doc, doc.body);
+    processAndInitTriggers(injector, deferBlockData, commentsByBlockId);
+    appendDeferBlocksToJSActionMap(doc, injector);
+  };
+}
+
 function ɵɵpureFunction0(slotOffset, pureFn) {
   const bindingIndex = getBindingRoot() + slotOffset;
   const lView = getLView();
@@ -17651,6 +17672,7 @@ const angularCoreEnv = (() => ({
   'ɵɵdeferHydrateOnInteraction': ɵɵdeferHydrateOnInteraction,
   'ɵɵdeferHydrateOnViewport': ɵɵdeferHydrateOnViewport,
   'ɵɵdeferEnableTimerScheduling': ɵɵdeferEnableTimerScheduling,
+  'ɵɵenableIncrementalHydrationRuntime': ɵɵenableIncrementalHydrationRuntime,
   'ɵɵrepeater': ɵɵrepeater,
   'ɵɵrepeaterCreate': ɵɵrepeaterCreate,
   'ɵɵrepeaterTrackByIndex': ɵɵrepeaterTrackByIndex,
@@ -17879,12 +17901,12 @@ function verifySemanticsOfNgModuleDef(moduleType, allowDuplicateDeclarationsInRo
     verifySemanticsOfNgModuleImport(modOrStandaloneCmpt, moduleType);
     verifySemanticsOfNgModuleDef(modOrStandaloneCmpt, false, moduleType);
   });
-  const exports$1 = maybeUnwrapFn(ngModuleDef.exports);
+  const exports = maybeUnwrapFn(ngModuleDef.exports);
   declarations.forEach(verifyDeclarationsHaveDefinitions);
   declarations.forEach(verifyDirectivesHaveSelector);
   declarations.forEach(declarationType => verifyNotStandalone(declarationType, moduleType));
   const combinedDeclarations = [...declarations.map(resolveForwardRef), ...flatten(imports.map(computeCombinedExports)).map(resolveForwardRef)];
-  exports$1.forEach(verifyExportsAreDeclaredOrReExported);
+  exports.forEach(verifyExportsAreDeclaredOrReExported);
   declarations.forEach(decl => verifyDeclarationIsUnique(decl, allowDuplicateDeclarationsInRoot));
   const ngModule = getAnnotation(moduleType, 'NgModule');
   if (ngModule) {
@@ -18294,6 +18316,7 @@ function directiveMetadata(type, metadata) {
   const propMetadata = reflect.ownPropMetadata(type);
   return {
     name: type.name,
+    legacyOptionalChaining: false,
     type: type,
     selector: metadata.selector !== undefined ? metadata.selector : null,
     host: metadata.host || EMPTY_OBJ,
@@ -18345,7 +18368,8 @@ function convertToR3QueryMetadata(propertyName, ann) {
   };
 }
 function extractQueriesMetadata(type, propMetadata, isQueryAnn) {
-  const queriesMeta = [];
+  const signalQueriesMeta = [];
+  const decoratorQueriesMeta = [];
   for (const field in propMetadata) {
     if (propMetadata.hasOwnProperty(field)) {
       const annotations = propMetadata[field];
@@ -18357,12 +18381,17 @@ function extractQueriesMetadata(type, propMetadata, isQueryAnn) {
           if (annotations.some(isInputAnnotation)) {
             throw new Error(`Cannot combine @Input decorators with query decorators`);
           }
-          queriesMeta.push(convertToR3QueryMetadata(field, ann));
+          const queryMeta = convertToR3QueryMetadata(field, ann);
+          if (queryMeta.isSignal) {
+            signalQueriesMeta.push(queryMeta);
+          } else {
+            decoratorQueriesMeta.push(queryMeta);
+          }
         }
       });
     }
   }
-  return queriesMeta;
+  return [...signalQueriesMeta, ...decoratorQueriesMeta];
 }
 function extractExportAs(exportAs) {
   return exportAs === undefined ? null : splitByComma(exportAs);
@@ -18669,18 +18698,14 @@ class ChangeDetectionSchedulerImpl {
   static ɵfac = function ChangeDetectionSchedulerImpl_Factory(__ngFactoryType__) {
     return new (__ngFactoryType__ || ChangeDetectionSchedulerImpl)();
   };
-  static ɵprov = /*@__PURE__*/__defineInjectable({
+  static ɵprov = /*@__PURE__*/ɵɵdefineService({
     token: ChangeDetectionSchedulerImpl,
-    factory: ChangeDetectionSchedulerImpl.ɵfac,
-    providedIn: 'root'
+    factory: ChangeDetectionSchedulerImpl.ɵfac
   });
 }
 (() => {
   (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(ChangeDetectionSchedulerImpl, [{
-    type: Injectable,
-    args: [{
-      providedIn: 'root'
-    }]
+    type: Service
   }], () => [], null);
 })();
 function provideZonelessChangeDetection() {
@@ -18722,18 +18747,14 @@ class Compiler {
   static ɵfac = function Compiler_Factory(__ngFactoryType__) {
     return new (__ngFactoryType__ || Compiler)();
   };
-  static ɵprov = /*@__PURE__*/__defineInjectable({
+  static ɵprov = /*@__PURE__*/ɵɵdefineService({
     token: Compiler,
-    factory: Compiler.ɵfac,
-    providedIn: 'root'
+    factory: Compiler.ɵfac
   });
 }
 (() => {
   (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(Compiler, [{
-    type: Injectable,
-    args: [{
-      providedIn: 'root'
-    }]
+    type: Service
   }], null, null);
 })();
 const COMPILER_OPTIONS = new InjectionToken(typeof ngDevMode !== 'undefined' && ngDevMode ? 'compilerOptions' : '');
@@ -19111,5 +19132,5 @@ function getDebugNode(nativeNode) {
   return null;
 }
 
-export { AFTER_RENDER_PHASES, ANIMATIONS_DISABLED, ANIMATION_MODULE_TYPE, APP_BOOTSTRAP_LISTENER, APP_ID, APP_INITIALIZER, AcxChangeDetectionStrategy, AcxViewEncapsulation, AfterRenderImpl, AfterRenderManager, AfterRenderSequence, ApplicationInitStatus, ApplicationRef, Attribute, COMPILER_OPTIONS, CONTAINERS, CSP_NONCE, CUSTOM_ELEMENTS_SCHEMA, ChainedInjector, ChangeDetectionSchedulerImpl, ChangeDetectionStrategy, Compiler, CompilerFactory, Component, ComponentFactory, ComponentRef$1 as ComponentRef, ComponentRef as ComponentRef$1, Console, ControlFlowBlockType, DEFAULT_CURRENCY_CODE, DEFAULT_LOCALE_ID, DEFER_BLOCK_CONFIG, DEFER_BLOCK_DEPENDENCY_INTERCEPTOR, DEFER_BLOCK_ID, DEFER_BLOCK_SSR_ID_ATTRIBUTE, DEFER_BLOCK_STATE$1 as DEFER_BLOCK_STATE, DEFER_BLOCK_STATE as DEFER_BLOCK_STATE$1, DEFER_HYDRATE_TRIGGERS, DEFER_PARENT_BLOCK_ID, DEHYDRATED_BLOCK_REGISTRY, DISCONNECTED_NODES, DebugElement, DebugEventListener, DebugNode, DeferBlockBehavior, DeferBlockState, DehydratedBlockRegistry, Directive, ELEMENT_CONTAINERS, EVENT_REPLAY_ENABLED_DEFAULT, EVENT_REPLAY_QUEUE, ElementRef, EnvironmentNgModuleRefAdapter, Host, HostBinding, HostListener, HydrationStatus, I18N_DATA, IMAGE_CONFIG, IMAGE_CONFIG_DEFAULTS, IS_ENABLED_BLOCKING_INITIAL_NAVIGATION, IS_EVENT_REPLAY_ENABLED, IS_HYDRATION_DOM_REUSE_ENABLED, IS_I18N_HYDRATION_ENABLED, IS_INCREMENTAL_HYDRATION_ENABLED, Inject, Injectable, Input, JSACTION_BLOCK_ELEMENT_MAP, JSACTION_EVENT_CONTRACT, LContext, LOCALE_ID, LocaleDataIndex, MAX_ANIMATION_TIMEOUT, MULTIPLIER, MissingTranslationStrategy, NGH_ATTR_NAME, NGH_DATA_KEY, NGH_DEFER_BLOCKS_KEY, NODES, NOOP_AFTER_RENDER_REF, NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR, NO_CHANGE, NO_ERRORS_SCHEMA, NUM_ROOT_NODES, NgModule, NgModuleFactory, NgModuleFactory$1, NgModuleRef, NgModuleRef$1, NodeInjector, Optional, Output, PLATFORM_ID, PLATFORM_INITIALIZER, PRESERVE_HOST_CONTENT, Pipe, ProfilerEvent, QueryList, ReflectionCapabilities, Renderer2, RendererFactory2, RendererStyleFlags2, SHARED_STYLES_HOST, SKIP_HYDRATION_ATTR_NAME, SSR_CONTENT_INTEGRITY_MARKER, Sanitizer, SecurityContext, Self, SimpleChange, SkipSelf, TEMPLATES, TEMPLATE_ID, TESTABILITY, TESTABILITY_GETTER, TRANSLATIONS, TRANSLATIONS_FORMAT, TemplateRef, Testability, TestabilityRegistry, TimerScheduler, TracingAction, TracingService, TransferState, Type, USE_PENDING_TASKS, UseExhaustiveCheckNoChanges, ViewContainerRef, ViewEncapsulation, ViewRef, _sanitizeHtml, _sanitizeUrl, afterEveryRender, afterNextRender, allLeavingAnimations, allowSanitizationBypassAndThrow, angularCoreDiEnv, angularCoreEnv, appendDeferBlocksToJSActionMap, asNativeElements, assertComponentDef, assertStandaloneComponentType, bypassSanitizationTrustHtml, bypassSanitizationTrustResourceUrl, bypassSanitizationTrustScript, bypassSanitizationTrustStyle, bypassSanitizationTrustUrl, calcPathForNode, checkNoChangesInternal, cleanupDehydratedViews, clearResolutionOfComponentResourcesQueue, collectNativeNodes, collectNativeNodesInLContainer, compileComponent, compileDirective, compileNgModule, compileNgModuleDefs, compilePipe, convertHydrateTriggersToJsAction, countBlocksSkippedByHydration, createEnvironmentInjector, createMultiResultQuerySignalFn, createNgModule, createNgModuleRefWithProviders, createSingleResultOptionalQuerySignalFn, createSingleResultRequiredQuerySignalFn, depsTracker, devModeEqual, enableApplyRootElementTransformImpl, enableClaimDehydratedIcuCaseImpl, enableFindMatchingDehydratedViewImpl, enableLocateOrCreateContainerAnchorImpl, enableLocateOrCreateContainerRefImpl, enableLocateOrCreateElementContainerNodeImpl, enableLocateOrCreateElementNodeImpl, enableLocateOrCreateI18nNodeImpl, enableLocateOrCreateTextNodeImpl, enablePrepareI18nBlockForHydrationImpl, enableProfiling, enableRetrieveDeferBlockDataImpl, enableRetrieveHydrationInfoImpl, enableStashEventListenerImpl, findLocaleData, flushModuleScopingQueueAsMuchAsPossible, gatherDeferBlocksCommentNodes, generateStandaloneInDeclarationsError, getAsyncClassMetadataFn, getClosestComponentName, getCompilerFacade, getDebugNode, getDeferBlocks, getDirectives, getDocument, getHostElement, getInjector, getInjectorMetadata, getInjectorProviders, getLContext, getLDeferBlockDetails, getLNodeForHydration, getLocaleCurrencyCode, getLocalePluralCase, getNodeInjectorTNode, getOrComputeI18nChildren, getRegisteredNgModuleType, getSanitizationBypassType, getSignalGraph, getTDeferBlockDetails, getTransferState, inferTagNameFromDefinition, inputBinding, invokeListeners, isComponentDefPendingResolution, isComponentResourceResolutionQueueEmpty, isDeferBlock, isDetachedByI18n, isDisconnectedNode, isI18nHydrationEnabled, isI18nHydrationSupportEnabled, isInSkipHydrationBlock, isIncrementalHydrationEnabled, isJsObject, isLetDeclaration, isListLikeIterable, isNgModule, isPromise, isSubscribable, isTNodeShape, isViewDirty, iterateListLike, makeDecorator, makePropDecorator, makeStateKey, markForRefresh, noSideEffects, optionsReducer, outputBinding, patchComponentDefWithScope, performanceMarkFeature, processAndInitTriggers, processBlockData, processTextNodeBeforeSerialization, profiler, promiseWithResolvers, provideAppInitializer, provideIdleServiceWith, provideNgReflectAttributes, provideZonelessChangeDetection, provideZonelessChangeDetectionInternal, publishDefaultGlobalUtils, publishExternalGlobalUtil, publishSignalConfiguration, readHydrationInfo, reflectDependencies, registerLocaleData, registerNgModuleType, remove, removeListeners, renderDeferBlockState, resetCompiledComponents, resetIncrementalHydrationEnabledWarnedForTests, resetJitOptions, resolveComponentResources, restoreComponentResolutionQueue, setAllowDuplicateNgModuleIdsForTest, setClassMetadata, setClassMetadataAsync, setDocument, setIsI18nHydrationSupportEnabled, setJSActionAttributes, setJitOptions, setLocaleId, setStashFn, setTestabilityGetter, sharedMapFunction, sharedStashFunction, transitiveScopesFor, triggerHydrationFromBlockName, triggerResourceLoading, trySerializeI18nBlock, twoWayBinding, unregisterAllLocaleData, unsupportedProjectionOfDomNodes, unwrapSafeValue, validAppIdInitializer, validateMatchingNode, validateNodeExists, verifySsrContentsIntegrity, walkLViewDirectives, ɵgetUnknownElementStrictMode, ɵgetUnknownPropertyStrictMode, ɵsetClassDebugInfo, ɵsetUnknownElementStrictMode, ɵsetUnknownPropertyStrictMode, ɵɵControlFeature, ɵɵExternalStylesFeature, ɵɵHostDirectivesFeature, ɵɵInheritDefinitionFeature, ɵɵNgOnChangesFeature, ɵɵProvidersFeature, ɵɵadvance, ɵɵanimateEnter, ɵɵanimateEnterListener, ɵɵanimateLeave, ɵɵanimateLeaveListener, ɵɵariaProperty, ɵɵarrowFunction, ɵɵattachSourceLocations, ɵɵattribute, ɵɵclassMap, ɵɵclassProp, ɵɵcomponentInstance, ɵɵconditional, ɵɵconditionalBranchCreate, ɵɵconditionalCreate, ɵɵcontentQuery, ɵɵcontentQuerySignal, ɵɵcontrol, ɵɵcontrolCreate, ɵɵ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, ɵɵdefineNgModule, ɵɵdefinePipe, ɵɵdefineService, ɵɵdirectiveInject, ɵɵdomElement, ɵɵdomElementContainer, ɵɵdomElementContainerEnd, ɵɵdomElementContainerStart, ɵɵdomElementEnd, ɵɵdomElementStart, ɵɵdomListener, ɵɵdomProperty, ɵɵdomTemplate, ɵɵelement, ɵɵelementContainer, ɵɵelementContainerEnd, ɵɵelementContainerStart, ɵɵelementEnd, ɵɵelementStart, ɵɵgetComponentDepsFactory, ɵɵgetCurrentView, ɵɵgetInheritedFactory, ɵɵgetReplaceMetadataURL, ɵɵi18n, ɵɵi18nApply, ɵɵi18nAttributes, ɵɵi18nEnd, ɵɵi18nExp, ɵɵi18nPostprocess, ɵɵi18nStart, ɵɵinjectAttribute, ɵɵinterpolate, ɵɵinterpolate1, ɵɵinterpolate2, ɵɵinterpolate3, ɵɵinterpolate4, ɵɵinterpolate5, ɵɵinterpolate6, ɵɵinterpolate7, ɵɵinterpolate8, ɵɵinterpolateV, ɵɵinvalidFactory, ɵɵlistener, ɵɵloadQuery, ɵɵnextContext, ɵɵpipe, ɵɵpipeBind1, ɵɵpipeBind2, ɵɵpipeBind3, ɵɵpipeBind4, ɵɵpipeBindV, ɵɵprojection, ɵɵprojectionDef, ɵɵproperty, ɵɵpureFunction0, ɵɵpureFunction1, ɵɵpureFunction2, ɵɵpureFunction3, ɵɵpureFunction4, ɵɵpureFunction5, ɵɵpureFunction6, ɵɵpureFunction7, ɵɵpureFunction8, ɵɵpureFunctionV, ɵɵqueryAdvance, ɵɵqueryRefresh, ɵɵreadContextLet, ɵɵreference, ɵɵrepeater, ɵɵrepeaterCreate, ɵɵrepeaterTrackByIdentity, ɵɵrepeaterTrackByIndex, ɵɵreplaceMetadata, ɵɵresolveBody, ɵɵresolveDocument, ɵɵresolveWindow, ɵɵsanitizeHtml, ɵɵsanitizeResourceUrl, ɵɵsanitizeScript, ɵɵsanitizeStyle, ɵɵsanitizeUrl, ɵɵsanitizeUrlOrResourceUrl, ɵɵsetComponentScope, ɵɵsetNgModuleScope, ɵɵstoreLet, ɵɵstyleMap, ɵɵstyleProp, ɵɵsyntheticHostListener, ɵɵsyntheticHostProperty, ɵɵtemplate, ɵɵtemplateRefExtractor, ɵɵtext, ɵɵtextInterpolate, ɵɵtextInterpolate1, ɵɵtextInterpolate2, ɵɵtextInterpolate3, ɵɵtextInterpolate4, ɵɵtextInterpolate5, ɵɵtextInterpolate6, ɵɵtextInterpolate7, ɵɵtextInterpolate8, ɵɵtextInterpolateV, ɵɵtrustConstantHtml, ɵɵtrustConstantResourceUrl, ɵɵtwoWayBindingSet, ɵɵtwoWayListener, ɵɵtwoWayProperty, ɵɵvalidateAttribute, ɵɵviewQuery, ɵɵviewQuerySignal };
+export { AFTER_RENDER_PHASES, ANIMATIONS_DISABLED, APP_BOOTSTRAP_LISTENER, APP_INITIALIZER, AcxChangeDetectionStrategy, AcxViewEncapsulation, AfterRenderImpl, AfterRenderManager, AfterRenderSequence, ApplicationInitStatus, ApplicationRef, Attribute, COMPILER_OPTIONS, CONTAINERS, CUSTOM_ELEMENTS_SCHEMA, ChainedInjector, ChangeDetectionSchedulerImpl, ChangeDetectionStrategy, Compiler, CompilerFactory, Component, ComponentFactory, ComponentRef$1 as ComponentRef, ComponentRef as ComponentRef$1, Console, ControlFlowBlockType, DEFAULT_CURRENCY_CODE, DEFAULT_LOCALE_ID, DEFER_BLOCK_CONFIG, DEFER_BLOCK_DEPENDENCY_INTERCEPTOR, DEFER_BLOCK_ID, DEFER_BLOCK_SSR_ID_ATTRIBUTE, DEFER_BLOCK_STATE$1 as DEFER_BLOCK_STATE, DEFER_BLOCK_STATE as DEFER_BLOCK_STATE$1, DEFER_HYDRATE_TRIGGERS, DEFER_PARENT_BLOCK_ID, DEHYDRATED_BLOCK_REGISTRY, DISCONNECTED_NODES, DebugElement, DebugEventListener, DebugNode, DeferBlockBehavior, DeferBlockState, Directive, ELEMENT_CONTAINERS, EVENT_REPLAY_ENABLED_DEFAULT, EVENT_REPLAY_QUEUE, ElementRef, EnvironmentNgModuleRefAdapter, Host, HostBinding, HostListener, HydrationStatus, I18N_DATA, IDLE_SERVICE, IS_ENABLED_BLOCKING_INITIAL_NAVIGATION, IS_EVENT_REPLAY_ENABLED, IS_HYDRATION_DOM_REUSE_ENABLED, IS_I18N_HYDRATION_ENABLED, IS_INCREMENTAL_HYDRATION_ENABLED, Inject, Injectable, Input, JSACTION_BLOCK_ELEMENT_MAP, JSACTION_EVENT_CONTRACT, LContext, LOCALE_ID, LocaleDataIndex, MAX_ANIMATION_TIMEOUT, MULTIPLIER, MissingTranslationStrategy, NGH_ATTR_NAME, NGH_DATA_KEY, NGH_DEFER_BLOCKS_KEY, NODES, NOOP_AFTER_RENDER_REF, NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR, NO_CHANGE, NO_ERRORS_SCHEMA, NUM_ROOT_NODES, NgModule, NgModuleFactory, NgModuleFactory$1, NgModuleRef, NgModuleRef$1, NodeInjector, Optional, Output, PRESERVE_HOST_CONTENT, Pipe, ProfilerEvent, QueryList, ReflectionCapabilities, Renderer2, RendererFactory2, RendererStyleFlags2, SHARED_STYLES_HOST, SKIP_HYDRATION_ATTR_NAME, SSR_CONTENT_INTEGRITY_MARKER, Sanitizer, SecurityContext, Self, Service, SimpleChange, SkipSelf, TEMPLATES, TEMPLATE_ID, TESTABILITY, TESTABILITY_GETTER, TRANSLATIONS, TRANSLATIONS_FORMAT, TemplateRef, Testability, TestabilityRegistry, TimerScheduler, TracingAction, TracingService, Type, USE_PENDING_TASKS, UseExhaustiveCheckNoChanges, ViewContainerRef, ViewEncapsulation, ViewRef, _sanitizeHtml, _sanitizeUrl, afterEveryRender, afterNextRender, allLeavingAnimations, allowSanitizationBypassAndThrow, angularCoreEnv, asNativeElements, assertComponentDef, assertStandaloneComponentType, bypassSanitizationTrustHtml, bypassSanitizationTrustResourceUrl, bypassSanitizationTrustScript, bypassSanitizationTrustStyle, bypassSanitizationTrustUrl, calcPathForNode, checkNoChangesInternal, cleanupDehydratedViews, clearResolutionOfComponentResourcesQueue, collectNativeNodes, collectNativeNodesInLContainer, compileComponent, compileDirective, compileNgModule, compileNgModuleDefs, compilePipe, convertHydrateTriggersToJsAction, countBlocksSkippedByHydration, createDehydratedBlockRegistry, createEnvironmentInjector, createMultiResultQuerySignalFn, createNgModule, createNgModuleRefWithProviders, createSingleResultOptionalQuerySignalFn, createSingleResultRequiredQuerySignalFn, depsTracker, devModeEqual, enableApplyRootElementTransformImpl, enableClaimDehydratedIcuCaseImpl, enableFindMatchingDehydratedViewImpl, enableLocateOrCreateContainerAnchorImpl, enableLocateOrCreateContainerRefImpl, enableLocateOrCreateElementContainerNodeImpl, enableLocateOrCreateElementNodeImpl, enableLocateOrCreateI18nNodeImpl, enableLocateOrCreateTextNodeImpl, enablePrepareI18nBlockForHydrationImpl, enableProfiling, enableRetrieveHydrationInfoImpl, enableStashEventListenerImpl, findLocaleData, flushModuleScopingQueueAsMuchAsPossible, generateStandaloneInDeclarationsError, getAsyncClassMetadataFn, getClosestComponentName, getCompilerFacade, getDebugNode, getDeferBlocks, getDirectives, getDocument, getHostElement, getInjector, getInjectorMetadata, getInjectorProviders, getLContext, getLDeferBlockDetails, getLNodeForHydration, getLocaleCurrencyCode, getLocalePluralCase, getNodeInjectorTNode, getOrComputeI18nChildren, getRegisteredNgModuleType, getSanitizationBypassType, getSignalGraph, getTDeferBlockDetails, getTransferState, inferTagNameFromDefinition, inputBinding, invokeListeners, isComponentDefPendingResolution, isComponentResourceResolutionQueueEmpty, isDeferBlock, isDetachedByI18n, isDisconnectedNode, isI18nHydrationEnabled, isI18nHydrationSupportEnabled, isInSkipHydrationBlock, isIncrementalHydrationEnabled, isJsObject, isLetDeclaration, isListLikeIterable, isNgModule, isPromise, isSubscribable, isTNodeShape, isViewDirty, iterateListLike, makePropDecorator, markForRefresh, noSideEffects, optionsReducer, outputBinding, patchComponentDefWithScope, performanceMarkFeature, processTextNodeBeforeSerialization, profiler, promiseWithResolvers, provideAppInitializer, provideIdleServiceWith, provideNgReflectAttributes, provideZonelessChangeDetection, provideZonelessChangeDetectionInternal, publishDefaultGlobalUtils, publishExternalGlobalUtil, publishSignalConfiguration, readHydrationInfo, registerLocaleData, registerNgModuleType, remove, removeListeners, renderDeferBlockState, resetCompiledComponents, resetIncrementalHydrationEnabledWarnedForTests, resetJitOptions, resolveComponentResources, restoreComponentResolutionQueue, runIncrementalHydrationBootstrap, setAllowDuplicateNgModuleIdsForTest, setClassMetadata, setClassMetadataAsync, setDocument, setIsI18nHydrationSupportEnabled, setJSActionAttributes, setJitOptions, setLocaleId, setStashFn, setTestabilityGetter, sharedMapFunction, sharedStashFunction, transitiveScopesFor, triggerHydrationFromBlockName, triggerResourceLoading, trySerializeI18nBlock, twoWayBinding, unregisterAllLocaleData, unsupportedProjectionOfDomNodes, unwrapSafeValue, validateMatchingNode, validateNodeExists, verifySsrContentsIntegrity, walkLViewDirectives, ɵgetUnknownElementStrictMode, ɵgetUnknownPropertyStrictMode, ɵsetClassDebugInfo, ɵsetUnknownElementStrictMode, ɵsetUnknownPropertyStrictMode, ɵɵControlFeature, ɵɵExternalStylesFeature, ɵɵHostDirectivesFeature, ɵɵInheritDefinitionFeature, ɵɵNgOnChangesFeature, ɵɵProvidersFeature, ɵɵadvance, ɵɵanimateEnter, ɵɵanimateEnterListener, ɵɵanimateLeave, ɵɵanimateLeaveListener, ɵɵariaProperty, ɵɵarrowFunction, ɵɵattachSourceLocations, ɵɵattribute, ɵɵclassMap, ɵɵclassProp, ɵɵcomponentInstance, ɵɵconditional, ɵɵconditionalBranchCreate, ɵɵconditionalCreate, ɵɵcontentQuery, ɵɵcontentQuerySignal, ɵɵcontrol, ɵɵcontrolCreate, ɵɵ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, ɵɵdefineNgModule, ɵɵdefinePipe, ɵɵdefineService, ɵɵdirectiveInject, ɵɵdomElement, ɵɵdomElementContainer, ɵɵdomElementContainerEnd, ɵɵdomElementContainerStart, ɵɵdomElementEnd, ɵɵdomElementStart, ɵɵdomListener, ɵɵdomProperty, ɵɵdomTemplate, ɵɵelement, ɵɵelementContainer, ɵɵelementContainerEnd, ɵɵelementContainerStart, ɵɵelementEnd, ɵɵelementStart, ɵɵenableIncrementalHydrationRuntime, ɵɵgetComponentDepsFactory, ɵɵgetCurrentView, ɵɵgetInheritedFactory, ɵɵgetReplaceMetadataURL, ɵɵi18n, ɵɵi18nApply, ɵɵi18nAttributes, ɵɵi18nEnd, ɵɵi18nExp, ɵɵi18nPostprocess, ɵɵi18nStart, ɵɵinjectAttribute, ɵɵinterpolate, ɵɵinterpolate1, ɵɵinterpolate2, ɵɵinterpolate3, ɵɵinterpolate4, ɵɵinterpolate5, ɵɵinterpolate6, ɵɵinterpolate7, ɵɵinterpolate8, ɵɵinterpolateV, ɵɵinvalidFactory, ɵɵlistener, ɵɵloadQuery, ɵɵnextContext, ɵɵpipe, ɵɵpipeBind1, ɵɵpipeBind2, ɵɵpipeBind3, ɵɵpipeBind4, ɵɵpipeBindV, ɵɵprojection, ɵɵprojectionDef, ɵɵproperty, ɵɵpureFunction0, ɵɵpureFunction1, ɵɵpureFunction2, ɵɵpureFunction3, ɵɵpureFunction4, ɵɵpureFunction5, ɵɵpureFunction6, ɵɵpureFunction7, ɵɵpureFunction8, ɵɵpureFunctionV, ɵɵqueryAdvance, ɵɵqueryRefresh, ɵɵreadContextLet, ɵɵreference, ɵɵrepeater, ɵɵrepeaterCreate, ɵɵrepeaterTrackByIdentity, ɵɵrepeaterTrackByIndex, ɵɵreplaceMetadata, ɵɵresolveBody, ɵɵresolveDocument, ɵɵresolveWindow, ɵɵsanitizeHtml, ɵɵsanitizeResourceUrl, ɵɵsanitizeScript, ɵɵsanitizeStyle, ɵɵsanitizeUrl, ɵɵsanitizeUrlOrResourceUrl, ɵɵsetComponentScope, ɵɵsetNgModuleScope, ɵɵstoreLet, ɵɵstyleMap, ɵɵstyleProp, ɵɵsyntheticHostListener, ɵɵsyntheticHostProperty, ɵɵtemplate, ɵɵtemplateRefExtractor, ɵɵtext, ɵɵtextInterpolate, ɵɵtextInterpolate1, ɵɵtextInterpolate2, ɵɵtextInterpolate3, ɵɵtextInterpolate4, ɵɵtextInterpolate5, ɵɵtextInterpolate6, ɵɵtextInterpolate7, ɵɵtextInterpolate8, ɵɵtextInterpolateV, ɵɵtrustConstantHtml, ɵɵtrustConstantResourceUrl, ɵɵtwoWayBindingSet, ɵɵtwoWayListener, ɵɵtwoWayProperty, ɵɵvalidateAttribute, ɵɵviewQuery, ɵɵviewQuerySignal };
 //# sourceMappingURL=_debug_node-chunk.mjs.map