shared-lib-angular 1.0.0

package/.jest-cache/jest-transform-cache-9a3a3745ceefdbbde8dc96f3a11cb645-79ef2876fae7ca75eedb2aa53dc48338/cd/root_effect_scheduler_cd51ef0a8f200e1abf01dc277a3a5df9

@@ -0,0 +1,2781 @@
+8767f95b6452952c99d5cc3cd88cc7a4
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var root_effect_scheduler_exports = {};
+__export(root_effect_scheduler_exports, {
+  AFTER_RENDER_SEQUENCES_TO_ADD: () => AFTER_RENDER_SEQUENCES_TO_ADD,
+  ANIMATIONS: () => ANIMATIONS,
+  CHILD_HEAD: () => CHILD_HEAD,
+  CHILD_TAIL: () => CHILD_TAIL,
+  CLEANUP: () => CLEANUP,
+  CONTAINER_HEADER_OFFSET: () => CONTAINER_HEADER_OFFSET,
+  CONTEXT: () => CONTEXT,
+  ChangeDetectionScheduler: () => ChangeDetectionScheduler,
+  CheckNoChangesMode: () => CheckNoChangesMode,
+  DECLARATION_COMPONENT_VIEW: () => DECLARATION_COMPONENT_VIEW,
+  DECLARATION_LCONTAINER: () => DECLARATION_LCONTAINER,
+  DECLARATION_VIEW: () => DECLARATION_VIEW,
+  DEHYDRATED_VIEWS: () => DEHYDRATED_VIEWS,
+  DOCUMENT: () => DOCUMENT,
+  DestroyRef: () => DestroyRef,
+  EFFECTS: () => EFFECTS,
+  EFFECTS_TO_SCHEDULE: () => EFFECTS_TO_SCHEDULE,
+  EMBEDDED_VIEW_INJECTOR: () => EMBEDDED_VIEW_INJECTOR,
+  EMPTY_ARRAY: () => EMPTY_ARRAY,
+  EMPTY_OBJ: () => EMPTY_OBJ,
+  ENVIRONMENT: () => ENVIRONMENT,
+  ENVIRONMENT_INITIALIZER: () => ENVIRONMENT_INITIALIZER,
+  EffectScheduler: () => EffectScheduler,
+  EnvironmentInjector: () => EnvironmentInjector,
+  ErrorHandler: () => ErrorHandler,
+  FLAGS: () => FLAGS,
+  HEADER_OFFSET: () => HEADER_OFFSET,
+  HOST: () => HOST,
+  HYDRATION: () => HYDRATION,
+  ID: () => ID,
+  INJECTOR: () => INJECTOR$1,
+  INJECTOR$1: () => INJECTOR,
+  INJECTOR_DEF_TYPES: () => INJECTOR_DEF_TYPES,
+  INJECTOR_SCOPE: () => INJECTOR_SCOPE,
+  INTERNAL_APPLICATION_ERROR_HANDLER: () => INTERNAL_APPLICATION_ERROR_HANDLER,
+  InjectionToken: () => InjectionToken,
+  Injector: () => Injector,
+  MATH_ML_NAMESPACE: () => MATH_ML_NAMESPACE,
+  MOVED_VIEWS: () => MOVED_VIEWS,
+  NATIVE: () => NATIVE,
+  NEXT: () => NEXT,
+  NG_COMP_DEF: () => NG_COMP_DEF,
+  NG_DIR_DEF: () => NG_DIR_DEF,
+  NG_ELEMENT_ID: () => NG_ELEMENT_ID,
+  NG_FACTORY_DEF: () => NG_FACTORY_DEF,
+  NG_INJ_DEF: () => NG_INJ_DEF,
+  NG_MOD_DEF: () => NG_MOD_DEF,
+  NG_PIPE_DEF: () => NG_PIPE_DEF,
+  NG_PROV_DEF: () => NG_PROV_DEF,
+  NodeInjectorDestroyRef: () => NodeInjectorDestroyRef,
+  NullInjector: () => NullInjector,
+  ON_DESTROY_HOOKS: () => ON_DESTROY_HOOKS,
+  PARENT: () => PARENT,
+  PREORDER_HOOK_FLAGS: () => PREORDER_HOOK_FLAGS,
+  PROVIDED_ZONELESS: () => PROVIDED_ZONELESS,
+  PendingTasks: () => PendingTasks,
+  PendingTasksInternal: () => PendingTasksInternal,
+  QUERIES: () => QUERIES,
+  R3Injector: () => R3Injector,
+  REACTIVE_TEMPLATE_CONSUMER: () => REACTIVE_TEMPLATE_CONSUMER,
+  RENDERER: () => RENDERER,
+  RuntimeError: () => RuntimeError,
+  SCHEDULE_IN_ROOT_ZONE: () => SCHEDULE_IN_ROOT_ZONE,
+  SVG_NAMESPACE: () => SVG_NAMESPACE,
+  TVIEW: () => TVIEW,
+  T_HOST: () => T_HOST,
+  VERSION: () => VERSION,
+  VIEW_REFS: () => VIEW_REFS,
+  Version: () => Version,
+  ViewContext: () => ViewContext,
+  XSS_SECURITY_URL: () => XSS_SECURITY_URL,
+  ZONELESS_ENABLED: () => ZONELESS_ENABLED,
+  ZONELESS_SCHEDULER_DISABLED: () => ZONELESS_SCHEDULER_DISABLED,
+  _global: () => _global,
+  addToArray: () => addToArray,
+  arrayEquals: () => arrayEquals,
+  arrayInsert2: () => arrayInsert2,
+  arraySplice: () => arraySplice,
+  assertComponentType: () => assertComponentType,
+  assertDefined: () => assertDefined,
+  assertDirectiveDef: () => assertDirectiveDef,
+  assertDomNode: () => assertDomNode,
+  assertElement: () => assertElement,
+  assertEqual: () => assertEqual,
+  assertFirstCreatePass: () => assertFirstCreatePass,
+  assertFirstUpdatePass: () => assertFirstUpdatePass,
+  assertFunction: () => assertFunction,
+  assertGreaterThan: () => assertGreaterThan,
+  assertGreaterThanOrEqual: () => assertGreaterThanOrEqual,
+  assertHasParent: () => assertHasParent,
+  assertInInjectionContext: () => assertInInjectionContext,
+  assertIndexInDeclRange: () => assertIndexInDeclRange,
+  assertIndexInExpandoRange: () => assertIndexInExpandoRange,
+  assertIndexInRange: () => assertIndexInRange,
+  assertInjectImplementationNotEqual: () => assertInjectImplementationNotEqual,
+  assertLContainer: () => assertLContainer,
+  assertLView: () => assertLView,
+  assertLessThan: () => assertLessThan,
+  assertNgModuleType: () => assertNgModuleType,
+  assertNodeInjector: () => assertNodeInjector,
+  assertNotDefined: () => assertNotDefined,
+  assertNotEqual: () => assertNotEqual,
+  assertNotInReactiveContext: () => assertNotInReactiveContext,
+  assertNotReactive: () => assertNotReactive,
+  assertNotSame: () => assertNotSame,
+  assertNumber: () => assertNumber,
+  assertNumberInRange: () => assertNumberInRange,
+  assertOneOf: () => assertOneOf,
+  assertParentView: () => assertParentView,
+  assertProjectionSlots: () => assertProjectionSlots,
+  assertSame: () => assertSame,
+  assertString: () => assertString,
+  assertTIcu: () => assertTIcu,
+  assertTNode: () => assertTNode,
+  assertTNodeCreationIndex: () => assertTNodeCreationIndex,
+  assertTNodeForLView: () => assertTNodeForLView,
+  assertTNodeForTView: () => assertTNodeForTView,
+  attachInjectFlag: () => attachInjectFlag,
+  concatStringsWithSpace: () => concatStringsWithSpace,
+  convertToBitFlags: () => convertToBitFlags,
+  createInjector: () => createInjector,
+  createInjectorWithoutInjectorInstances: () => createInjectorWithoutInjectorInstances,
+  cyclicDependencyError: () => cyclicDependencyError,
+  cyclicDependencyErrorWithDetails: () => cyclicDependencyErrorWithDetails,
+  debugStringifyTypeForError: () => debugStringifyTypeForError,
+  decreaseElementDepthCount: () => decreaseElementDepthCount,
+  deepForEach: () => deepForEach,
+  defineInjectable: () => defineInjectable,
+  emitEffectCreatedEvent: () => emitEffectCreatedEvent,
+  emitInjectEvent: () => emitInjectEvent,
+  emitInjectorToCreateInstanceEvent: () => emitInjectorToCreateInstanceEvent,
+  emitInstanceCreatedByInjectorEvent: () => emitInstanceCreatedByInjectorEvent,
+  emitProviderConfiguredEvent: () => emitProviderConfiguredEvent,
+  enterDI: () => enterDI,
+  enterSkipHydrationBlock: () => enterSkipHydrationBlock,
+  enterView: () => enterView,
+  errorHandlerEnvironmentInitializer: () => errorHandlerEnvironmentInitializer,
+  fillProperties: () => fillProperties,
+  flatten: () => flatten,
+  formatRuntimeError: () => formatRuntimeError,
+  forwardRef: () => forwardRef,
+  getBindingIndex: () => getBindingIndex,
+  getBindingRoot: () => getBindingRoot,
+  getBindingsEnabled: () => getBindingsEnabled,
+  getClosureSafeProperty: () => getClosureSafeProperty,
+  getComponentDef: () => getComponentDef,
+  getComponentLViewByIndex: () => getComponentLViewByIndex,
+  getConstant: () => getConstant,
+  getContextLView: () => getContextLView,
+  getCurrentDirectiveDef: () => getCurrentDirectiveDef,
+  getCurrentDirectiveIndex: () => getCurrentDirectiveIndex,
+  getCurrentParentTNode: () => getCurrentParentTNode,
+  getCurrentQueryIndex: () => getCurrentQueryIndex,
+  getCurrentTNode: () => getCurrentTNode,
+  getCurrentTNodePlaceholderOk: () => getCurrentTNodePlaceholderOk,
+  getDirectiveDef: () => getDirectiveDef,
+  getDirectiveDefOrThrow: () => getDirectiveDefOrThrow,
+  getElementDepthCount: () => getElementDepthCount,
+  getFactoryDef: () => getFactoryDef,
+  getInjectableDef: () => getInjectableDef,
+  getInjectorDef: () => getInjectorDef,
+  getLView: () => getLView,
+  getLViewParent: () => getLViewParent,
+  getNamespace: () => getNamespace,
+  getNativeByIndex: () => getNativeByIndex,
+  getNativeByTNode: () => getNativeByTNode,
+  getNativeByTNodeOrNull: () => getNativeByTNodeOrNull,
+  getNgModuleDef: () => getNgModuleDef,
+  getNgModuleDefOrThrow: () => getNgModuleDefOrThrow,
+  getNullInjector: () => getNullInjector,
+  getOrCreateLViewCleanup: () => getOrCreateLViewCleanup,
+  getOrCreateTViewCleanup: () => getOrCreateTViewCleanup,
+  getPipeDef: () => getPipeDef,
+  getSelectedIndex: () => getSelectedIndex,
+  getSelectedTNode: () => getSelectedTNode,
+  getTNode: () => getTNode,
+  getTView: () => getTView,
+  hasI18n: () => hasI18n,
+  importProvidersFrom: () => importProvidersFrom,
+  increaseElementDepthCount: () => increaseElementDepthCount,
+  incrementBindingIndex: () => incrementBindingIndex,
+  initNgDevMode: () => initNgDevMode,
+  inject: () => inject,
+  injectRootLimpMode: () => injectRootLimpMode,
+  internalImportProvidersFrom: () => internalImportProvidersFrom,
+  isClassProvider: () => isClassProvider,
+  isComponentDef: () => isComponentDef,
+  isComponentHost: () => isComponentHost,
+  isContentQueryHost: () => isContentQueryHost,
+  isCreationMode: () => isCreationMode,
+  isCurrentTNodeParent: () => isCurrentTNodeParent,
+  isDestroyed: () => isDestroyed,
+  isDirectiveHost: () => isDirectiveHost,
+  isEnvironmentProviders: () => isEnvironmentProviders,
+  isExhaustiveCheckNoChanges: () => isExhaustiveCheckNoChanges,
+  isForwardRef: () => isForwardRef,
+  isInCheckNoChangesMode: () => isInCheckNoChangesMode,
+  isInI18nBlock: () => isInI18nBlock,
+  isInInjectionContext: () => isInInjectionContext,
+  isInSkipHydrationBlock: () => isInSkipHydrationBlock,
+  isInjectable: () => isInjectable,
+  isLContainer: () => isLContainer,
+  isLView: () => isLView,
+  isProjectionTNode: () => isProjectionTNode,
+  isRefreshingViews: () => isRefreshingViews,
+  isRootView: () => isRootView,
+  isSignal: () => isSignal,
+  isSkipHydrationRootTNode: () => isSkipHydrationRootTNode,
+  isStandalone: () => isStandalone,
+  isTypeProvider: () => isTypeProvider,
+  isWritableSignal: () => isWritableSignal,
+  keyValueArrayGet: () => keyValueArrayGet,
+  keyValueArrayIndexOf: () => keyValueArrayIndexOf,
+  keyValueArraySet: () => keyValueArraySet,
+  lastNodeWasCreated: () => lastNodeWasCreated,
+  leaveDI: () => leaveDI,
+  leaveSkipHydrationBlock: () => leaveSkipHydrationBlock,
+  leaveView: () => leaveView,
+  load: () => load,
+  makeEnvironmentProviders: () => makeEnvironmentProviders,
+  markAncestorsForTraversal: () => markAncestorsForTraversal,
+  markViewForRefresh: () => markViewForRefresh,
+  newArray: () => newArray,
+  nextBindingIndex: () => nextBindingIndex,
+  nextContextImpl: () => nextContextImpl,
+  noop: () => noop,
+  provideBrowserGlobalErrorListeners: () => provideBrowserGlobalErrorListeners,
+  provideEnvironmentInitializer: () => provideEnvironmentInitializer,
+  providerToFactory: () => providerToFactory,
+  removeFromArray: () => removeFromArray,
+  removeLViewOnDestroy: () => removeLViewOnDestroy,
+  renderStringify: () => renderStringify,
+  requiresRefreshOrTraversal: () => requiresRefreshOrTraversal,
+  resetPreOrderHookFlags: () => resetPreOrderHookFlags,
+  resolveForwardRef: () => resolveForwardRef,
+  runInInjectionContext: () => runInInjectionContext,
+  runInInjectorProfilerContext: () => runInInjectorProfilerContext,
+  setBindingIndex: () => setBindingIndex,
+  setBindingRootForHostBindings: () => setBindingRootForHostBindings,
+  setCurrentDirectiveIndex: () => setCurrentDirectiveIndex,
+  setCurrentQueryIndex: () => setCurrentQueryIndex,
+  setCurrentTNode: () => setCurrentTNode,
+  setCurrentTNodeAsNotParent: () => setCurrentTNodeAsNotParent,
+  setInI18nBlock: () => setInI18nBlock,
+  setInjectImplementation: () => setInjectImplementation,
+  setInjectorProfiler: () => setInjectorProfiler,
+  setInjectorProfilerContext: () => setInjectorProfilerContext,
+  setIsInCheckNoChangesMode: () => setIsInCheckNoChangesMode,
+  setIsRefreshingViews: () => setIsRefreshingViews,
+  setSelectedIndex: () => setSelectedIndex,
+  signal: () => signal,
+  signalAsReadonlyFn: () => signalAsReadonlyFn,
+  store: () => store,
+  storeCleanupWithContext: () => storeCleanupWithContext,
+  storeLViewOnDestroy: () => storeLViewOnDestroy,
+  stringify: () => stringify,
+  stringifyForError: () => stringifyForError,
+  throwError: () => throwError,
+  throwProviderNotFoundError: () => throwProviderNotFoundError,
+  truncateMiddle: () => truncateMiddle,
+  unwrapLView: () => unwrapLView,
+  unwrapRNode: () => unwrapRNode,
+  updateAncestorTraversalFlagsOnAttach: () => updateAncestorTraversalFlagsOnAttach,
+  viewAttachedToChangeDetector: () => viewAttachedToChangeDetector,
+  viewAttachedToContainer: () => viewAttachedToContainer,
+  walkProviderTree: () => walkProviderTree,
+  walkUpViews: () => walkUpViews,
+  wasLastNodeCreated: () => wasLastNodeCreated,
+  \u0275unwrapWritableSignal: () => \u0275unwrapWritableSignal,
+  \u0275\u0275defineInjectable: () => \u0275\u0275defineInjectable,
+  \u0275\u0275defineInjector: () => \u0275\u0275defineInjector,
+  \u0275\u0275disableBindings: () => \u0275\u0275disableBindings,
+  \u0275\u0275enableBindings: () => \u0275\u0275enableBindings,
+  \u0275\u0275inject: () => \u0275\u0275inject,
+  \u0275\u0275invalidFactoryDep: () => \u0275\u0275invalidFactoryDep,
+  \u0275\u0275namespaceHTML: () => \u0275\u0275namespaceHTML,
+  \u0275\u0275namespaceMathML: () => \u0275\u0275namespaceMathML,
+  \u0275\u0275namespaceSVG: () => \u0275\u0275namespaceSVG,
+  \u0275\u0275resetView: () => \u0275\u0275resetView,
+  \u0275\u0275restoreView: () => \u0275\u0275restoreView
+});
+module.exports = __toCommonJS(root_effect_scheduler_exports);
+var import_not_found = require("./not_found.mjs");
+var import_signal = require("./signal.mjs");
+var import_rxjs = require("rxjs");
+var import_signals = require("@angular/core/primitives/signals");
+var import_di = require("@angular/core/primitives/di");
+/**
+ * @license Angular v20.3.16
+ * (c) 2010-2025 Google LLC. https://angular.dev/
+ * License: MIT
+ */
+class Version {
+  constructor(full) {
+    __publicField(this, "full");
+    __publicField(this, "major");
+    __publicField(this, "minor");
+    __publicField(this, "patch");
+    this.full = full;
+    const parts = full.split(".");
+    this.major = parts[0];
+    this.minor = parts[1];
+    this.patch = parts.slice(2).join(".");
+  }
+}
+const VERSION = /* @__PURE__ */ new Version("20.3.16");
+const ERROR_DETAILS_PAGE_BASE_URL = (() => {
+  const versionSubDomain = VERSION.major !== "0" ? `v${VERSION.major}.` : "";
+  return `https://${versionSubDomain}angular.dev/errors`;
+})();
+const XSS_SECURITY_URL = "https://angular.dev/best-practices/security#preventing-cross-site-scripting-xss";
+class RuntimeError extends Error {
+  constructor(code, message) {
+    super(formatRuntimeError(code, message));
+    __publicField(this, "code");
+    this.code = code;
+  }
+}
+function formatRuntimeErrorCode(code) {
+  return `NG0${Math.abs(code)}`;
+}
+function formatRuntimeError(code, message) {
+  const fullCode = formatRuntimeErrorCode(code);
+  let errorMessage = `${fullCode}${message ? ": " + message : ""}`;
+  if (ngDevMode && code < 0) {
+    const addPeriodSeparator = !errorMessage.match(/[.,;!?\n]$/);
+    const separator = addPeriodSeparator ? "." : "";
+    errorMessage = `${errorMessage}${separator} Find more at ${ERROR_DETAILS_PAGE_BASE_URL}/${fullCode}`;
+  }
+  return errorMessage;
+}
+const _global = globalThis;
+function ngDevModeResetPerfCounters() {
+  const locationString = typeof location !== "undefined" ? location.toString() : "";
+  const newCounters = {
+    hydratedNodes: 0,
+    hydratedComponents: 0,
+    dehydratedViewsRemoved: 0,
+    dehydratedViewsCleanupRuns: 0,
+    componentsSkippedHydration: 0,
+    deferBlocksWithIncrementalHydration: 0
+  };
+  const allowNgDevModeTrue = locationString.indexOf("ngDevMode=false") === -1;
+  if (!allowNgDevModeTrue) {
+    _global["ngDevMode"] = false;
+  } else {
+    if (typeof _global["ngDevMode"] !== "object") {
+      _global["ngDevMode"] = {};
+    }
+    Object.assign(_global["ngDevMode"], newCounters);
+  }
+  return newCounters;
+}
+function initNgDevMode() {
+  if (typeof ngDevMode === "undefined" || ngDevMode) {
+    if (typeof ngDevMode !== "object" || Object.keys(ngDevMode).length === 0) {
+      ngDevModeResetPerfCounters();
+    }
+    return typeof ngDevMode !== "undefined" && !!ngDevMode;
+  }
+  return false;
+}
+function getClosureSafeProperty(objWithPropertyToExtract) {
+  for (let key in objWithPropertyToExtract) {
+    if (objWithPropertyToExtract[key] === getClosureSafeProperty) {
+      return key;
+    }
+  }
+  throw Error(typeof ngDevMode !== "undefined" && ngDevMode ? "Could not find renamed property on target object." : "");
+}
+function fillProperties(target, source) {
+  for (const key in source) {
+    if (source.hasOwnProperty(key) && !target.hasOwnProperty(key)) {
+      target[key] = source[key];
+    }
+  }
+}
+function stringify(token) {
+  if (typeof token === "string") {
+    return token;
+  }
+  if (Array.isArray(token)) {
+    return `[${token.map(stringify).join(", ")}]`;
+  }
+  if (token == null) {
+    return "" + token;
+  }
+  const name = token.overriddenName || token.name;
+  if (name) {
+    return `${name}`;
+  }
+  const result = token.toString();
+  if (result == null) {
+    return "" + result;
+  }
+  const newLineIndex = result.indexOf("\n");
+  return newLineIndex >= 0 ? result.slice(0, newLineIndex) : result;
+}
+function concatStringsWithSpace(before, after) {
+  if (!before)
+    return after || "";
+  if (!after)
+    return before;
+  return `${before} ${after}`;
+}
+function truncateMiddle(str, maxLength = 100) {
+  if (!str || maxLength < 1 || str.length <= maxLength)
+    return str;
+  if (maxLength == 1)
+    return str.substring(0, 1) + "...";
+  const halfLimit = Math.round(maxLength / 2);
+  return str.substring(0, halfLimit) + "..." + str.substring(str.length - halfLimit);
+}
+const __forward_ref__ = getClosureSafeProperty({ __forward_ref__: getClosureSafeProperty });
+function forwardRef(forwardRefFn) {
+  forwardRefFn.__forward_ref__ = forwardRef;
+  forwardRefFn.toString = function() {
+    return stringify(this());
+  };
+  return forwardRefFn;
+}
+function resolveForwardRef(type) {
+  return isForwardRef(type) ? type() : type;
+}
+function isForwardRef(fn) {
+  return typeof fn === "function" && fn.hasOwnProperty(__forward_ref__) && fn.__forward_ref__ === forwardRef;
+}
+function assertNumber(actual, msg) {
+  if (!(typeof actual === "number")) {
+    throwError(msg, typeof actual, "number", "===");
+  }
+}
+function assertNumberInRange(actual, minInclusive, maxInclusive) {
+  assertNumber(actual, "Expected a number");
+  assertLessThanOrEqual(actual, maxInclusive, "Expected number to be less than or equal to");
+  assertGreaterThanOrEqual(actual, minInclusive, "Expected number to be greater than or equal to");
+}
+function assertString(actual, msg) {
+  if (!(typeof actual === "string")) {
+    throwError(msg, actual === null ? "null" : typeof actual, "string", "===");
+  }
+}
+function assertFunction(actual, msg) {
+  if (!(typeof actual === "function")) {
+    throwError(msg, actual === null ? "null" : typeof actual, "function", "===");
+  }
+}
+function assertEqual(actual, expected, msg) {
+  if (!(actual == expected)) {
+    throwError(msg, actual, expected, "==");
+  }
+}
+function assertNotEqual(actual, expected, msg) {
+  if (!(actual != expected)) {
+    throwError(msg, actual, expected, "!=");
+  }
+}
+function assertSame(actual, expected, msg) {
+  if (!(actual === expected)) {
+    throwError(msg, actual, expected, "===");
+  }
+}
+function assertNotSame(actual, expected, msg) {
+  if (!(actual !== expected)) {
+    throwError(msg, actual, expected, "!==");
+  }
+}
+function assertLessThan(actual, expected, msg) {
+  if (!(actual < expected)) {
+    throwError(msg, actual, expected, "<");
+  }
+}
+function assertLessThanOrEqual(actual, expected, msg) {
+  if (!(actual <= expected)) {
+    throwError(msg, actual, expected, "<=");
+  }
+}
+function assertGreaterThan(actual, expected, msg) {
+  if (!(actual > expected)) {
+    throwError(msg, actual, expected, ">");
+  }
+}
+function assertGreaterThanOrEqual(actual, expected, msg) {
+  if (!(actual >= expected)) {
+    throwError(msg, actual, expected, ">=");
+  }
+}
+function assertNotDefined(actual, msg) {
+  if (actual != null) {
+    throwError(msg, actual, null, "==");
+  }
+}
+function assertDefined(actual, msg) {
+  if (actual == null) {
+    throwError(msg, actual, null, "!=");
+  }
+}
+function throwError(msg, actual, expected, comparison) {
+  throw new Error(`ASSERTION ERROR: ${msg}` + (comparison == null ? "" : ` [Expected=> ${expected} ${comparison} ${actual} <=Actual]`));
+}
+function assertDomNode(node) {
+  if (!(node instanceof Node)) {
+    throwError(`The provided value must be an instance of a DOM Node but got ${stringify(node)}`);
+  }
+}
+function assertElement(node) {
+  if (!(node instanceof Element)) {
+    throwError(`The provided value must be an element but got ${stringify(node)}`);
+  }
+}
+function assertIndexInRange(arr, index) {
+  assertDefined(arr, "Array must be defined.");
+  const maxLen = arr.length;
+  if (index < 0 || index >= maxLen) {
+    throwError(`Index expected to be less than ${maxLen} but got ${index}`);
+  }
+}
+function assertOneOf(value, ...validValues) {
+  if (validValues.indexOf(value) !== -1)
+    return true;
+  throwError(`Expected value to be one of ${JSON.stringify(validValues)} but was ${JSON.stringify(value)}.`);
+}
+function assertNotReactive(fn) {
+  if ((0, import_signal.getActiveConsumer)() !== null) {
+    throwError(`${fn}() should never be called in a reactive context.`);
+  }
+}
+function \u0275\u0275defineInjectable(opts) {
+  return {
+    token: opts.token,
+    providedIn: opts.providedIn || null,
+    factory: opts.factory,
+    value: void 0
+  };
+}
+const defineInjectable = \u0275\u0275defineInjectable;
+function \u0275\u0275defineInjector(options) {
+  return { providers: options.providers || [], imports: options.imports || [] };
+}
+function getInjectableDef(type) {
+  return getOwnDefinition(type, NG_PROV_DEF);
+}
+function isInjectable(type) {
+  return getInjectableDef(type) !== null;
+}
+function getOwnDefinition(type, field) {
+  return type.hasOwnProperty(field) && type[field] || null;
+}
+function getInheritedInjectableDef(type) {
+  var _a;
+  const def = (_a = type == null ? void 0 : type[NG_PROV_DEF]) != null ? _a : null;
+  if (def) {
+    ngDevMode && console.warn(`DEPRECATED: DI is instantiating a token "${type.name}" that inherits its @Injectable decorator but does not provide one itself.
+This will become an error in a future version of Angular. Please add @Injectable() to the "${type.name}" class.`);
+    return def;
+  } else {
+    return null;
+  }
+}
+function getInjectorDef(type) {
+  return type && type.hasOwnProperty(NG_INJ_DEF) ? type[NG_INJ_DEF] : null;
+}
+const NG_PROV_DEF = getClosureSafeProperty({ \u0275prov: getClosureSafeProperty });
+const NG_INJ_DEF = getClosureSafeProperty({ \u0275inj: getClosureSafeProperty });
+class InjectionToken {
+  /**
+   * @param _desc   Description for the token,
+   *                used only for debugging purposes,
+   *                it should but does not need to be unique
+   * @param options Options for the token's usage, as described above
+   */
+  constructor(_desc, options) {
+    __publicField(this, "_desc");
+    /** @internal */
+    __publicField(this, "ngMetadataName", "InjectionToken");
+    __publicField(this, "\u0275prov");
+    this._desc = _desc;
+    this.\u0275prov = void 0;
+    if (typeof options == "number") {
+      (typeof ngDevMode === "undefined" || ngDevMode) && assertLessThan(options, 0, "Only negative numbers are supported here");
+      this.__NG_ELEMENT_ID__ = options;
+    } else if (options !== void 0) {
+      this.\u0275prov = \u0275\u0275defineInjectable({
+        token: this,
+        providedIn: options.providedIn || "root",
+        factory: options.factory
+      });
+    }
+  }
+  /**
+   * @internal
+   */
+  get multi() {
+    return this;
+  }
+  toString() {
+    return `InjectionToken ${this._desc}`;
+  }
+}
+let _injectorProfilerContext;
+function getInjectorProfilerContext() {
+  !ngDevMode && throwError("getInjectorProfilerContext should never be called in production mode");
+  return _injectorProfilerContext;
+}
+function setInjectorProfilerContext(context) {
+  !ngDevMode && throwError("setInjectorProfilerContext should never be called in production mode");
+  const previous = _injectorProfilerContext;
+  _injectorProfilerContext = context;
+  return previous;
+}
+const injectorProfilerCallbacks = [];
+const NOOP_PROFILER_REMOVAL = () => {
+};
+function removeProfiler(profiler) {
+  const profilerIdx = injectorProfilerCallbacks.indexOf(profiler);
+  if (profilerIdx !== -1) {
+    injectorProfilerCallbacks.splice(profilerIdx, 1);
+  }
+}
+function setInjectorProfiler(injectorProfiler2) {
+  !ngDevMode && throwError("setInjectorProfiler should never be called in production mode");
+  if (injectorProfiler2 !== null) {
+    if (!injectorProfilerCallbacks.includes(injectorProfiler2)) {
+      injectorProfilerCallbacks.push(injectorProfiler2);
+    }
+    return () => removeProfiler(injectorProfiler2);
+  } else {
+    injectorProfilerCallbacks.length = 0;
+    return NOOP_PROFILER_REMOVAL;
+  }
+}
+function injectorProfiler(event) {
+  !ngDevMode && throwError("Injector profiler should never be called in production mode");
+  for (let i = 0; i < injectorProfilerCallbacks.length; i++) {
+    const injectorProfilerCallback = injectorProfilerCallbacks[i];
+    injectorProfilerCallback(event);
+  }
+}
+function emitProviderConfiguredEvent(eventProvider, isViewProvider = false) {
+  !ngDevMode && throwError("Injector profiler should never be called in production mode");
+  let token;
+  if (typeof eventProvider === "function") {
+    token = eventProvider;
+  } else if (eventProvider instanceof InjectionToken) {
+    token = eventProvider;
+  } else {
+    token = resolveForwardRef(eventProvider.provide);
+  }
+  let provider = eventProvider;
+  if (eventProvider instanceof InjectionToken) {
+    provider = eventProvider.\u0275prov || eventProvider;
+  }
+  injectorProfiler({
+    type: 2,
+    context: getInjectorProfilerContext(),
+    providerRecord: { token, provider, isViewProvider }
+  });
+}
+function emitInjectorToCreateInstanceEvent(token) {
+  !ngDevMode && throwError("Injector profiler should never be called in production mode");
+  injectorProfiler({
+    type: 4,
+    context: getInjectorProfilerContext(),
+    token
+  });
+}
+function emitInstanceCreatedByInjectorEvent(instance) {
+  !ngDevMode && throwError("Injector profiler should never be called in production mode");
+  injectorProfiler({
+    type: 1,
+    context: getInjectorProfilerContext(),
+    instance: { value: instance }
+  });
+}
+function emitInjectEvent(token, value, flags) {
+  !ngDevMode && throwError("Injector profiler should never be called in production mode");
+  injectorProfiler({
+    type: 0,
+    context: getInjectorProfilerContext(),
+    service: { token, value, flags }
+  });
+}
+function emitEffectCreatedEvent(effect) {
+  !ngDevMode && throwError("Injector profiler should never be called in production mode");
+  injectorProfiler({
+    type: 3,
+    context: getInjectorProfilerContext(),
+    effect
+  });
+}
+function runInInjectorProfilerContext(injector, token, callback) {
+  !ngDevMode && throwError("runInInjectorProfilerContext should never be called in production mode");
+  const prevInjectContext = setInjectorProfilerContext({ injector, token });
+  try {
+    callback();
+  } finally {
+    setInjectorProfilerContext(prevInjectContext);
+  }
+}
+function isEnvironmentProviders(value) {
+  return value && !!value.\u0275providers;
+}
+const NG_COMP_DEF = getClosureSafeProperty({ \u0275cmp: getClosureSafeProperty });
+const NG_DIR_DEF = getClosureSafeProperty({ \u0275dir: getClosureSafeProperty });
+const NG_PIPE_DEF = getClosureSafeProperty({ \u0275pipe: getClosureSafeProperty });
+const NG_MOD_DEF = getClosureSafeProperty({ \u0275mod: getClosureSafeProperty });
+const NG_FACTORY_DEF = getClosureSafeProperty({ \u0275fac: getClosureSafeProperty });
+const NG_ELEMENT_ID = getClosureSafeProperty({
+  __NG_ELEMENT_ID__: getClosureSafeProperty
+});
+const NG_ENV_ID = getClosureSafeProperty({ __NG_ENV_ID__: getClosureSafeProperty });
+function renderStringify(value) {
+  if (typeof value === "string")
+    return value;
+  if (value == null)
+    return "";
+  return String(value);
+}
+function stringifyForError(value) {
+  if (typeof value === "function")
+    return value.name || value.toString();
+  if (typeof value === "object" && value != null && typeof value.type === "function") {
+    return value.type.name || value.type.toString();
+  }
+  return renderStringify(value);
+}
+function debugStringifyTypeForError(type) {
+  let componentDef = type[NG_COMP_DEF] || null;
+  if (componentDef !== null && componentDef.debugInfo) {
+    return stringifyTypeFromDebugInfo(componentDef.debugInfo);
+  }
+  return stringifyForError(type);
+}
+function stringifyTypeFromDebugInfo(debugInfo) {
+  if (!debugInfo.filePath || !debugInfo.lineNumber) {
+    return debugInfo.className;
+  } else {
+    return `${debugInfo.className} (at ${debugInfo.filePath}:${debugInfo.lineNumber})`;
+  }
+}
+const NG_RUNTIME_ERROR_CODE = getClosureSafeProperty({ "ngErrorCode": getClosureSafeProperty });
+const NG_RUNTIME_ERROR_MESSAGE = getClosureSafeProperty({ "ngErrorMessage": getClosureSafeProperty });
+const NG_TOKEN_PATH = getClosureSafeProperty({ "ngTokenPath": getClosureSafeProperty });
+function cyclicDependencyError(token, path) {
+  const message = ngDevMode ? `Circular dependency detected for \`${token}\`.` : "";
+  return createRuntimeError(message, -200, path);
+}
+function cyclicDependencyErrorWithDetails(token, path) {
+  return augmentRuntimeError(cyclicDependencyError(token, path), null);
+}
+function throwMixedMultiProviderError() {
+  throw new Error(`Cannot mix multi providers and regular providers`);
+}
+function throwInvalidProviderError(ngModuleType, providers, provider) {
+  if (ngModuleType && providers) {
+    const providerDetail = providers.map((v) => v == provider ? "?" + provider + "?" : "...");
+    throw new Error(`Invalid provider for the NgModule '${stringify(ngModuleType)}' - only instances of Provider and Type are allowed, got: [${providerDetail.join(", ")}]`);
+  } else if (isEnvironmentProviders(provider)) {
+    if (provider.\u0275fromNgModule) {
+      throw new RuntimeError(207, `Invalid providers from 'importProvidersFrom' present in a non-environment injector. 'importProvidersFrom' can't be used for component providers.`);
+    } else {
+      throw new RuntimeError(207, `Invalid providers present in a non-environment injector. 'EnvironmentProviders' can't be used for component providers.`);
+    }
+  } else {
+    throw new Error("Invalid provider");
+  }
+}
+function throwProviderNotFoundError(token, injectorName) {
+  const errorMessage = ngDevMode && `No provider for ${stringifyForError(token)} found${injectorName ? ` in ${injectorName}` : ""}`;
+  throw new RuntimeError(-201, errorMessage);
+}
+function prependTokenToDependencyPath(error, token) {
+  var _a;
+  (_a = error[NG_TOKEN_PATH]) != null ? _a : error[NG_TOKEN_PATH] = [];
+  const currentPath = error[NG_TOKEN_PATH];
+  let pathStr;
+  if (typeof token === "object" && "multi" in token && (token == null ? void 0 : token.multi) === true) {
+    assertDefined(token.provide, "Token with multi: true should have a provide property");
+    pathStr = stringifyForError(token.provide);
+  } else {
+    pathStr = stringifyForError(token);
+  }
+  if (currentPath[0] !== pathStr) {
+    error[NG_TOKEN_PATH].unshift(pathStr);
+  }
+}
+function augmentRuntimeError(error, source) {
+  const tokenPath = error[NG_TOKEN_PATH];
+  const errorCode = error[NG_RUNTIME_ERROR_CODE];
+  const message = error[NG_RUNTIME_ERROR_MESSAGE] || error.message;
+  error.message = formatErrorMessage(message, errorCode, tokenPath, source);
+  return error;
+}
+function createRuntimeError(message, code, path) {
+  const error = new RuntimeError(code, message);
+  error[NG_RUNTIME_ERROR_CODE] = code;
+  error[NG_RUNTIME_ERROR_MESSAGE] = message;
+  if (path) {
+    error[NG_TOKEN_PATH] = path;
+  }
+  return error;
+}
+function getRuntimeErrorCode(error) {
+  return error[NG_RUNTIME_ERROR_CODE];
+}
+function formatErrorMessage(text, code, path = [], source = null) {
+  let pathDetails = "";
+  if (path && path.length > 1) {
+    pathDetails = ` Path: ${path.join(" -> ")}.`;
+  }
+  const sourceDetails = source ? ` Source: ${source}.` : "";
+  return formatRuntimeError(code, `${text}${sourceDetails}${pathDetails}`);
+}
+let _injectImplementation;
+function getInjectImplementation() {
+  return _injectImplementation;
+}
+function setInjectImplementation(impl) {
+  const previous = _injectImplementation;
+  _injectImplementation = impl;
+  return previous;
+}
+function injectRootLimpMode(token, notFoundValue, flags) {
+  const injectableDef = getInjectableDef(token);
+  if (injectableDef && injectableDef.providedIn == "root") {
+    return injectableDef.value === void 0 ? injectableDef.value = injectableDef.factory() : injectableDef.value;
+  }
+  if (flags & 8)
+    return null;
+  if (notFoundValue !== void 0)
+    return notFoundValue;
+  throwProviderNotFoundError(token, "Injector");
+}
+function assertInjectImplementationNotEqual(fn) {
+  ngDevMode && assertNotEqual(_injectImplementation, fn, "Calling \u0275\u0275inject would cause infinite recursion");
+}
+const _THROW_IF_NOT_FOUND = {};
+const THROW_IF_NOT_FOUND = _THROW_IF_NOT_FOUND;
+const DI_DECORATOR_FLAG = "__NG_DI_FLAG__";
+class RetrievingInjector {
+  constructor(injector) {
+    __publicField(this, "injector");
+    this.injector = injector;
+  }
+  retrieve(token, options) {
+    const flags = convertToBitFlags(options) || 0;
+    try {
+      return this.injector.get(
+        token,
+        // When a dependency is requested with an optional flag, DI returns null as the default value.
+        flags & 8 ? null : THROW_IF_NOT_FOUND,
+        flags
+      );
+    } catch (e) {
+      if ((0, import_not_found.isNotFound)(e)) {
+        return e;
+      }
+      throw e;
+    }
+  }
+}
+function injectInjectorOnly(token, flags = 0) {
+  const currentInjector = (0, import_not_found.getCurrentInjector)();
+  if (currentInjector === void 0) {
+    throw new RuntimeError(-203, ngDevMode && `The \`${stringify(token)}\` token injection failed. \`inject()\` function must be called from an injection context such as a constructor, a factory function, a field initializer, or a function used with \`runInInjectionContext\`.`);
+  } else if (currentInjector === null) {
+    return injectRootLimpMode(token, void 0, flags);
+  } else {
+    const options = convertToInjectOptions(flags);
+    const value = currentInjector.retrieve(token, options);
+    ngDevMode && emitInjectEvent(token, value, flags);
+    if ((0, import_not_found.isNotFound)(value)) {
+      if (options.optional) {
+        return null;
+      }
+      throw value;
+    }
+    return value;
+  }
+}
+function \u0275\u0275inject(token, flags = 0) {
+  return (getInjectImplementation() || injectInjectorOnly)(resolveForwardRef(token), flags);
+}
+function \u0275\u0275invalidFactoryDep(index) {
+  throw new RuntimeError(202, ngDevMode && `This constructor is not compatible with Angular Dependency Injection because its dependency at index ${index} of the parameter list is invalid.
+This can happen if the dependency type is a primitive like a string or if an ancestor of this class is missing an Angular decorator.
+
+Please check that 1) the type for the parameter at index ${index} is correct and 2) the correct Angular decorators are defined for this class and its ancestors.`);
+}
+function inject(token, options) {
+  return \u0275\u0275inject(token, convertToBitFlags(options));
+}
+function convertToBitFlags(flags) {
+  if (typeof flags === "undefined" || typeof flags === "number") {
+    return flags;
+  }
+  return 0 | // comment to force a line break in the formatter
+  (flags.optional && 8) | (flags.host && 1) | (flags.self && 2) | (flags.skipSelf && 4);
+}
+function convertToInjectOptions(flags) {
+  return {
+    optional: !!(flags & 8),
+    host: !!(flags & 1),
+    self: !!(flags & 2),
+    skipSelf: !!(flags & 4)
+  };
+}
+function injectArgs(types) {
+  const args = [];
+  for (let i = 0; i < types.length; i++) {
+    const arg = resolveForwardRef(types[i]);
+    if (Array.isArray(arg)) {
+      if (arg.length === 0) {
+        throw new RuntimeError(900, ngDevMode && "Arguments array must have arguments.");
+      }
+      let type = void 0;
+      let flags = 0;
+      for (let j = 0; j < arg.length; j++) {
+        const meta = arg[j];
+        const flag = getInjectFlag(meta);
+        if (typeof flag === "number") {
+          if (flag === -1) {
+            type = meta.token;
+          } else {
+            flags |= flag;
+          }
+        } else {
+          type = meta;
+        }
+      }
+      args.push(\u0275\u0275inject(type, flags));
+    } else {
+      args.push(\u0275\u0275inject(arg));
+    }
+  }
+  return args;
+}
+function attachInjectFlag(decorator, flag) {
+  decorator[DI_DECORATOR_FLAG] = flag;
+  decorator.prototype[DI_DECORATOR_FLAG] = flag;
+  return decorator;
+}
+function getInjectFlag(token) {
+  return token[DI_DECORATOR_FLAG];
+}
+function getFactoryDef(type, throwNotFound) {
+  const hasFactoryDef = type.hasOwnProperty(NG_FACTORY_DEF);
+  if (!hasFactoryDef && throwNotFound === true && ngDevMode) {
+    throw new Error(`Type ${stringify(type)} does not have '\u0275fac' property.`);
+  }
+  return hasFactoryDef ? type[NG_FACTORY_DEF] : null;
+}
+function arrayEquals(a, b, identityAccessor) {
+  if (a.length !== b.length)
+    return false;
+  for (let i = 0; i < a.length; i++) {
+    let valueA = a[i];
+    let valueB = b[i];
+    if (identityAccessor) {
+      valueA = identityAccessor(valueA);
+      valueB = identityAccessor(valueB);
+    }
+    if (valueB !== valueA) {
+      return false;
+    }
+  }
+  return true;
+}
+function flatten(list) {
+  return list.flat(Number.POSITIVE_INFINITY);
+}
+function deepForEach(input, fn) {
+  input.forEach((value) => Array.isArray(value) ? deepForEach(value, fn) : fn(value));
+}
+function addToArray(arr, index, value) {
+  if (index >= arr.length) {
+    arr.push(value);
+  } else {
+    arr.splice(index, 0, value);
+  }
+}
+function removeFromArray(arr, index) {
+  if (index >= arr.length - 1) {
+    return arr.pop();
+  } else {
+    return arr.splice(index, 1)[0];
+  }
+}
+function newArray(size, value) {
+  const list = [];
+  for (let i = 0; i < size; i++) {
+    list.push(value);
+  }
+  return list;
+}
+function arraySplice(array, index, count) {
+  const length = array.length - count;
+  while (index < length) {
+    array[index] = array[index + count];
+    index++;
+  }
+  while (count--) {
+    array.pop();
+  }
+}
+function arrayInsert2(array, index, value1, value2) {
+  ngDevMode && assertLessThanOrEqual(index, array.length, "Can't insert past array end.");
+  let end = array.length;
+  if (end == index) {
+    array.push(value1, value2);
+  } else if (end === 1) {
+    array.push(value2, array[0]);
+    array[0] = value1;
+  } else {
+    end--;
+    array.push(array[end - 1], array[end]);
+    while (end > index) {
+      const previousEnd = end - 2;
+      array[end] = array[previousEnd];
+      end--;
+    }
+    array[index] = value1;
+    array[index + 1] = value2;
+  }
+}
+function keyValueArraySet(keyValueArray, key, value) {
+  let index = keyValueArrayIndexOf(keyValueArray, key);
+  if (index >= 0) {
+    keyValueArray[index | 1] = value;
+  } else {
+    index = ~index;
+    arrayInsert2(keyValueArray, index, key, value);
+  }
+  return index;
+}
+function keyValueArrayGet(keyValueArray, key) {
+  const index = keyValueArrayIndexOf(keyValueArray, key);
+  if (index >= 0) {
+    return keyValueArray[index | 1];
+  }
+  return void 0;
+}
+function keyValueArrayIndexOf(keyValueArray, key) {
+  return _arrayIndexOfSorted(keyValueArray, key, 1);
+}
+function _arrayIndexOfSorted(array, value, shift) {
+  ngDevMode && assertEqual(Array.isArray(array), true, "Expecting an array");
+  let start = 0;
+  let end = array.length >> shift;
+  while (end !== start) {
+    const middle = start + (end - start >> 1);
+    const current = array[middle << shift];
+    if (value === current) {
+      return middle << shift;
+    } else if (current > value) {
+      end = middle;
+    } else {
+      start = middle + 1;
+    }
+  }
+  return ~(end << shift);
+}
+const EMPTY_OBJ = {};
+const EMPTY_ARRAY = [];
+if ((typeof ngDevMode === "undefined" || ngDevMode) && initNgDevMode()) {
+  Object.freeze(EMPTY_OBJ);
+  Object.freeze(EMPTY_ARRAY);
+}
+const ENVIRONMENT_INITIALIZER = new InjectionToken(ngDevMode ? "ENVIRONMENT_INITIALIZER" : "");
+const INJECTOR$1 = new InjectionToken(
+  ngDevMode ? "INJECTOR" : "",
+  // Disable tslint because this is const enum which gets inlined not top level prop access.
+  // tslint:disable-next-line: no-toplevel-property-access
+  -1
+  /* InjectorMarkers.Injector */
+);
+const INJECTOR_DEF_TYPES = new InjectionToken(ngDevMode ? "INJECTOR_DEF_TYPES" : "");
+class NullInjector {
+  get(token, notFoundValue = THROW_IF_NOT_FOUND) {
+    if (notFoundValue === THROW_IF_NOT_FOUND) {
+      const message = ngDevMode ? `No provider found for \`${stringify(token)}\`.` : "";
+      const error = createRuntimeError(
+        message,
+        -201
+        /* RuntimeErrorCode.PROVIDER_NOT_FOUND */
+      );
+      error.name = "\u0275NotFound";
+      throw error;
+    }
+    return notFoundValue;
+  }
+}
+function getNgModuleDef(type) {
+  return type[NG_MOD_DEF] || null;
+}
+function getNgModuleDefOrThrow(type) {
+  const ngModuleDef = getNgModuleDef(type);
+  if (!ngModuleDef) {
+    throw new RuntimeError(915, (typeof ngDevMode === "undefined" || ngDevMode) && `Type ${stringify(type)} does not have '\u0275mod' property.`);
+  }
+  return ngModuleDef;
+}
+function getComponentDef(type) {
+  return type[NG_COMP_DEF] || null;
+}
+function getDirectiveDefOrThrow(type) {
+  const def = getDirectiveDef(type);
+  if (!def) {
+    throw new RuntimeError(916, (typeof ngDevMode === "undefined" || ngDevMode) && `Type ${stringify(type)} does not have '\u0275dir' property.`);
+  }
+  return def;
+}
+function getDirectiveDef(type) {
+  return type[NG_DIR_DEF] || null;
+}
+function getPipeDef(type) {
+  return type[NG_PIPE_DEF] || null;
+}
+function isStandalone(type) {
+  const def = getComponentDef(type) || getDirectiveDef(type) || getPipeDef(type);
+  return def !== null && def.standalone;
+}
+function makeEnvironmentProviders(providers) {
+  return {
+    \u0275providers: providers
+  };
+}
+function provideEnvironmentInitializer(initializerFn) {
+  return makeEnvironmentProviders([
+    {
+      provide: ENVIRONMENT_INITIALIZER,
+      multi: true,
+      useValue: initializerFn
+    }
+  ]);
+}
+function importProvidersFrom(...sources) {
+  return {
+    \u0275providers: internalImportProvidersFrom(true, sources),
+    \u0275fromNgModule: true
+  };
+}
+function internalImportProvidersFrom(checkForStandaloneCmp, ...sources) {
+  const providersOut = [];
+  const dedup = /* @__PURE__ */ new Set();
+  let injectorTypesWithProviders;
+  const collectProviders = (provider) => {
+    providersOut.push(provider);
+  };
+  deepForEach(sources, (source) => {
+    if ((typeof ngDevMode === "undefined" || ngDevMode) && checkForStandaloneCmp) {
+      const cmpDef = getComponentDef(source);
+      if (cmpDef == null ? void 0 : cmpDef.standalone) {
+        throw new RuntimeError(800, `Importing providers supports NgModule or ModuleWithProviders but got a standalone component "${stringifyForError(source)}"`);
+      }
+    }
+    const internalSource = source;
+    if (walkProviderTree(internalSource, collectProviders, [], dedup)) {
+      injectorTypesWithProviders || (injectorTypesWithProviders = []);
+      injectorTypesWithProviders.push(internalSource);
+    }
+  });
+  if (injectorTypesWithProviders !== void 0) {
+    processInjectorTypesWithProviders(injectorTypesWithProviders, collectProviders);
+  }
+  return providersOut;
+}
+function processInjectorTypesWithProviders(typesWithProviders, visitor) {
+  for (let i = 0; i < typesWithProviders.length; i++) {
+    const { ngModule, providers } = typesWithProviders[i];
+    deepForEachProvider(providers, (provider) => {
+      ngDevMode && validateProvider(provider, providers || EMPTY_ARRAY, ngModule);
+      visitor(provider, ngModule);
+    });
+  }
+}
+function walkProviderTree(container, visitor, parents, dedup) {
+  container = resolveForwardRef(container);
+  if (!container)
+    return false;
+  let defType = null;
+  let injDef = getInjectorDef(container);
+  const cmpDef = !injDef && getComponentDef(container);
+  if (!injDef && !cmpDef) {
+    const ngModule = container.ngModule;
+    injDef = getInjectorDef(ngModule);
+    if (injDef) {
+      defType = ngModule;
+    } else {
+      return false;
+    }
+  } else if (cmpDef && !cmpDef.standalone) {
+    return false;
+  } else {
+    defType = container;
+  }
+  if (ngDevMode && parents.indexOf(defType) !== -1) {
+    const defName = stringify(defType);
+    const path = parents.map(stringify).concat(defName);
+    throw cyclicDependencyErrorWithDetails(defName, path);
+  }
+  const isDuplicate = dedup.has(defType);
+  if (cmpDef) {
+    if (isDuplicate) {
+      return false;
+    }
+    dedup.add(defType);
+    if (cmpDef.dependencies) {
+      const deps = typeof cmpDef.dependencies === "function" ? cmpDef.dependencies() : cmpDef.dependencies;
+      for (const dep of deps) {
+        walkProviderTree(dep, visitor, parents, dedup);
+      }
+    }
+  } else if (injDef) {
+    if (injDef.imports != null && !isDuplicate) {
+      ngDevMode && parents.push(defType);
+      dedup.add(defType);
+      let importTypesWithProviders;
+      try {
+        deepForEach(injDef.imports, (imported) => {
+          if (walkProviderTree(imported, visitor, parents, dedup)) {
+            importTypesWithProviders || (importTypesWithProviders = []);
+            importTypesWithProviders.push(imported);
+          }
+        });
+      } finally {
+        ngDevMode && parents.pop();
+      }
+      if (importTypesWithProviders !== void 0) {
+        processInjectorTypesWithProviders(importTypesWithProviders, visitor);
+      }
+    }
+    if (!isDuplicate) {
+      const factory = getFactoryDef(defType) || (() => new defType());
+      visitor({ provide: defType, useFactory: factory, deps: EMPTY_ARRAY }, defType);
+      visitor({ provide: INJECTOR_DEF_TYPES, useValue: defType, multi: true }, defType);
+      visitor({ provide: ENVIRONMENT_INITIALIZER, useValue: () => \u0275\u0275inject(defType), multi: true }, defType);
+    }
+    const defProviders = injDef.providers;
+    if (defProviders != null && !isDuplicate) {
+      const injectorType = container;
+      deepForEachProvider(defProviders, (provider) => {
+        ngDevMode && validateProvider(provider, defProviders, injectorType);
+        visitor(provider, injectorType);
+      });
+    }
+  } else {
+    return false;
+  }
+  return defType !== container && container.providers !== void 0;
+}
+function validateProvider(provider, providers, containerType) {
+  if (isTypeProvider(provider) || isValueProvider(provider) || isFactoryProvider(provider) || isExistingProvider(provider)) {
+    return;
+  }
+  const classRef = resolveForwardRef(provider && (provider.useClass || provider.provide));
+  if (!classRef) {
+    throwInvalidProviderError(containerType, providers, provider);
+  }
+}
+function deepForEachProvider(providers, fn) {
+  for (let provider of providers) {
+    if (isEnvironmentProviders(provider)) {
+      provider = provider.\u0275providers;
+    }
+    if (Array.isArray(provider)) {
+      deepForEachProvider(provider, fn);
+    } else {
+      fn(provider);
+    }
+  }
+}
+const USE_VALUE = getClosureSafeProperty({
+  provide: String,
+  useValue: getClosureSafeProperty
+});
+function isValueProvider(value) {
+  return value !== null && typeof value == "object" && USE_VALUE in value;
+}
+function isExistingProvider(value) {
+  return !!(value && value.useExisting);
+}
+function isFactoryProvider(value) {
+  return !!(value && value.useFactory);
+}
+function isTypeProvider(value) {
+  return typeof value === "function";
+}
+function isClassProvider(value) {
+  return !!value.useClass;
+}
+const INJECTOR_SCOPE = new InjectionToken(ngDevMode ? "Set Injector scope." : "");
+const NOT_YET = {};
+const CIRCULAR = {};
+let NULL_INJECTOR = void 0;
+function getNullInjector() {
+  if (NULL_INJECTOR === void 0) {
+    NULL_INJECTOR = new NullInjector();
+  }
+  return NULL_INJECTOR;
+}
+class EnvironmentInjector {
+}
+class R3Injector extends EnvironmentInjector {
+  constructor(providers, parent, source, scopes) {
+    super();
+    __publicField(this, "parent");
+    __publicField(this, "source");
+    __publicField(this, "scopes");
+    /**
+     * Map of tokens to records which contain the instances of those tokens.
+     * - `null` value implies that we don't have the record. Used by tree-shakable injectors
+     * to prevent further searches.
+     */
+    __publicField(this, "records", /* @__PURE__ */ new Map());
+    /**
+     * Set of values instantiated by this injector which contain `ngOnDestroy` lifecycle hooks.
+     */
+    __publicField(this, "_ngOnDestroyHooks", /* @__PURE__ */ new Set());
+    __publicField(this, "_onDestroyHooks", []);
+    __publicField(this, "_destroyed", false);
+    __publicField(this, "injectorDefTypes");
+    this.parent = parent;
+    this.source = source;
+    this.scopes = scopes;
+    forEachSingleProvider(providers, (provider) => this.processProvider(provider));
+    this.records.set(INJECTOR$1, makeRecord(void 0, this));
+    if (scopes.has("environment")) {
+      this.records.set(EnvironmentInjector, makeRecord(void 0, this));
+    }
+    const record = this.records.get(INJECTOR_SCOPE);
+    if (record != null && typeof record.value === "string") {
+      this.scopes.add(record.value);
+    }
+    this.injectorDefTypes = new Set(this.get(INJECTOR_DEF_TYPES, EMPTY_ARRAY, { self: true }));
+  }
+  /**
+   * Flag indicating that this injector was previously destroyed.
+   */
+  get destroyed() {
+    return this._destroyed;
+  }
+  retrieve(token, options) {
+    const flags = convertToBitFlags(options) || 0;
+    try {
+      return this.get(
+        token,
+        // When a dependency is requested with an optional flag, DI returns null as the default value.
+        THROW_IF_NOT_FOUND,
+        flags
+      );
+    } catch (e) {
+      if ((0, import_di.isNotFound)(e)) {
+        return e;
+      }
+      throw e;
+    }
+  }
+  /**
+   * Destroy the injector and release references to every instance or provider associated with it.
+   *
+   * Also calls the `OnDestroy` lifecycle hooks of every instance that was created for which a
+   * hook was found.
+   */
+  destroy() {
+    assertNotDestroyed(this);
+    this._destroyed = true;
+    const prevConsumer = (0, import_signals.setActiveConsumer)(null);
+    try {
+      for (const service of this._ngOnDestroyHooks) {
+        service.ngOnDestroy();
+      }
+      const onDestroyHooks = this._onDestroyHooks;
+      this._onDestroyHooks = [];
+      for (const hook of onDestroyHooks) {
+        hook();
+      }
+    } finally {
+      this.records.clear();
+      this._ngOnDestroyHooks.clear();
+      this.injectorDefTypes.clear();
+      (0, import_signals.setActiveConsumer)(prevConsumer);
+    }
+  }
+  onDestroy(callback) {
+    assertNotDestroyed(this);
+    this._onDestroyHooks.push(callback);
+    return () => this.removeOnDestroy(callback);
+  }
+  runInContext(fn) {
+    assertNotDestroyed(this);
+    const previousInjector = (0, import_not_found.setCurrentInjector)(this);
+    const previousInjectImplementation = setInjectImplementation(void 0);
+    let prevInjectContext;
+    if (ngDevMode) {
+      prevInjectContext = setInjectorProfilerContext({ injector: this, token: null });
+    }
+    try {
+      return fn();
+    } finally {
+      (0, import_not_found.setCurrentInjector)(previousInjector);
+      setInjectImplementation(previousInjectImplementation);
+      ngDevMode && setInjectorProfilerContext(prevInjectContext);
+    }
+  }
+  get(token, notFoundValue = THROW_IF_NOT_FOUND, options) {
+    assertNotDestroyed(this);
+    if (token.hasOwnProperty(NG_ENV_ID)) {
+      return token[NG_ENV_ID](this);
+    }
+    const flags = convertToBitFlags(options);
+    let prevInjectContext;
+    if (ngDevMode) {
+      prevInjectContext = setInjectorProfilerContext({ injector: this, token });
+    }
+    const previousInjector = (0, import_not_found.setCurrentInjector)(this);
+    const previousInjectImplementation = setInjectImplementation(void 0);
+    try {
+      if (!(flags & 4)) {
+        let record = this.records.get(token);
+        if (record === void 0) {
+          const def = couldBeInjectableType(token) && getInjectableDef(token);
+          if (def && this.injectableDefInScope(def)) {
+            if (ngDevMode) {
+              runInInjectorProfilerContext(this, token, () => {
+                emitProviderConfiguredEvent(token);
+              });
+            }
+            record = makeRecord(injectableDefOrInjectorDefFactory(token), NOT_YET);
+          } else {
+            record = null;
+          }
+          this.records.set(token, record);
+        }
+        if (record != null) {
+          return this.hydrate(token, record, flags);
+        }
+      }
+      const nextInjector = !(flags & 2) ? this.parent : getNullInjector();
+      notFoundValue = flags & 8 && notFoundValue === THROW_IF_NOT_FOUND ? null : notFoundValue;
+      return nextInjector.get(token, notFoundValue);
+    } catch (error) {
+      const errorCode = getRuntimeErrorCode(error);
+      if (errorCode === -200 || errorCode === -201) {
+        if (ngDevMode) {
+          prependTokenToDependencyPath(error, token);
+          if (previousInjector) {
+            throw error;
+          } else {
+            throw augmentRuntimeError(error, this.source);
+          }
+        } else {
+          throw new RuntimeError(errorCode, null);
+        }
+      } else {
+        throw error;
+      }
+    } finally {
+      setInjectImplementation(previousInjectImplementation);
+      (0, import_not_found.setCurrentInjector)(previousInjector);
+      ngDevMode && setInjectorProfilerContext(prevInjectContext);
+    }
+  }
+  /** @internal */
+  resolveInjectorInitializers() {
+    const prevConsumer = (0, import_signals.setActiveConsumer)(null);
+    const previousInjector = (0, import_not_found.setCurrentInjector)(this);
+    const previousInjectImplementation = setInjectImplementation(void 0);
+    let prevInjectContext;
+    if (ngDevMode) {
+      prevInjectContext = setInjectorProfilerContext({ injector: this, token: null });
+    }
+    try {
+      const initializers = this.get(ENVIRONMENT_INITIALIZER, EMPTY_ARRAY, { self: true });
+      if (ngDevMode && !Array.isArray(initializers)) {
+        throw new RuntimeError(-209, `Unexpected type of the \`ENVIRONMENT_INITIALIZER\` token value (expected an array, but got ${typeof initializers}). Please check that the \`ENVIRONMENT_INITIALIZER\` token is configured as a \`multi: true\` provider.`);
+      }
+      for (const initializer of initializers) {
+        initializer();
+      }
+    } finally {
+      (0, import_not_found.setCurrentInjector)(previousInjector);
+      setInjectImplementation(previousInjectImplementation);
+      ngDevMode && setInjectorProfilerContext(prevInjectContext);
+      (0, import_signals.setActiveConsumer)(prevConsumer);
+    }
+  }
+  toString() {
+    const tokens = [];
+    const records = this.records;
+    for (const token of records.keys()) {
+      tokens.push(stringify(token));
+    }
+    return `R3Injector[${tokens.join(", ")}]`;
+  }
+  /**
+   * Process a `SingleProvider` and add it.
+   */
+  processProvider(provider) {
+    provider = resolveForwardRef(provider);
+    let token = isTypeProvider(provider) ? provider : resolveForwardRef(provider && provider.provide);
+    const record = providerToRecord(provider);
+    if (ngDevMode) {
+      runInInjectorProfilerContext(this, token, () => {
+        if (isValueProvider(provider)) {
+          emitInjectorToCreateInstanceEvent(token);
+          emitInstanceCreatedByInjectorEvent(provider.useValue);
+        }
+        emitProviderConfiguredEvent(provider);
+      });
+    }
+    if (!isTypeProvider(provider) && provider.multi === true) {
+      let multiRecord = this.records.get(token);
+      if (multiRecord) {
+        if (ngDevMode && multiRecord.multi === void 0) {
+          throwMixedMultiProviderError();
+        }
+      } else {
+        multiRecord = makeRecord(void 0, NOT_YET, true);
+        multiRecord.factory = () => injectArgs(multiRecord.multi);
+        this.records.set(token, multiRecord);
+      }
+      token = provider;
+      multiRecord.multi.push(provider);
+    } else {
+      if (ngDevMode) {
+        const existing = this.records.get(token);
+        if (existing && existing.multi !== void 0) {
+          throwMixedMultiProviderError();
+        }
+      }
+    }
+    this.records.set(token, record);
+  }
+  hydrate(token, record, flags) {
+    const prevConsumer = (0, import_signals.setActiveConsumer)(null);
+    try {
+      if (record.value === CIRCULAR) {
+        throw cyclicDependencyError(stringify(token));
+      } else if (record.value === NOT_YET) {
+        record.value = CIRCULAR;
+        if (ngDevMode) {
+          runInInjectorProfilerContext(this, token, () => {
+            emitInjectorToCreateInstanceEvent(token);
+            record.value = record.factory(void 0, flags);
+            emitInstanceCreatedByInjectorEvent(record.value);
+          });
+        } else {
+          record.value = record.factory(void 0, flags);
+        }
+      }
+      if (typeof record.value === "object" && record.value && hasOnDestroy(record.value)) {
+        this._ngOnDestroyHooks.add(record.value);
+      }
+      return record.value;
+    } finally {
+      (0, import_signals.setActiveConsumer)(prevConsumer);
+    }
+  }
+  injectableDefInScope(def) {
+    if (!def.providedIn) {
+      return false;
+    }
+    const providedIn = resolveForwardRef(def.providedIn);
+    if (typeof providedIn === "string") {
+      return providedIn === "any" || this.scopes.has(providedIn);
+    } else {
+      return this.injectorDefTypes.has(providedIn);
+    }
+  }
+  removeOnDestroy(callback) {
+    const destroyCBIdx = this._onDestroyHooks.indexOf(callback);
+    if (destroyCBIdx !== -1) {
+      this._onDestroyHooks.splice(destroyCBIdx, 1);
+    }
+  }
+}
+function injectableDefOrInjectorDefFactory(token) {
+  const injectableDef = getInjectableDef(token);
+  const factory = injectableDef !== null ? injectableDef.factory : getFactoryDef(token);
+  if (factory !== null) {
+    return factory;
+  }
+  if (token instanceof InjectionToken) {
+    throw new RuntimeError(204, ngDevMode && `Token ${stringify(token)} is missing a \u0275prov definition.`);
+  }
+  if (token instanceof Function) {
+    return getUndecoratedInjectableFactory(token);
+  }
+  throw new RuntimeError(204, ngDevMode && "unreachable");
+}
+function getUndecoratedInjectableFactory(token) {
+  const paramLength = token.length;
+  if (paramLength > 0) {
+    throw new RuntimeError(204, ngDevMode && `Can't resolve all parameters for ${stringify(token)}: (${newArray(paramLength, "?").join(", ")}).`);
+  }
+  const inheritedInjectableDef = getInheritedInjectableDef(token);
+  if (inheritedInjectableDef !== null) {
+    return () => inheritedInjectableDef.factory(token);
+  } else {
+    return () => new token();
+  }
+}
+function providerToRecord(provider) {
+  if (isValueProvider(provider)) {
+    return makeRecord(void 0, provider.useValue);
+  } else {
+    const factory = providerToFactory(provider);
+    return makeRecord(factory, NOT_YET);
+  }
+}
+function providerToFactory(provider, ngModuleType, providers) {
+  let factory = void 0;
+  if (ngDevMode && isEnvironmentProviders(provider)) {
+    throwInvalidProviderError(void 0, providers, provider);
+  }
+  if (isTypeProvider(provider)) {
+    const unwrappedProvider = resolveForwardRef(provider);
+    return getFactoryDef(unwrappedProvider) || injectableDefOrInjectorDefFactory(unwrappedProvider);
+  } else {
+    if (isValueProvider(provider)) {
+      factory = () => resolveForwardRef(provider.useValue);
+    } else if (isFactoryProvider(provider)) {
+      factory = () => provider.useFactory(...injectArgs(provider.deps || []));
+    } else if (isExistingProvider(provider)) {
+      factory = (_, flags) => \u0275\u0275inject(resolveForwardRef(provider.useExisting), flags !== void 0 && flags & 8 ? 8 : void 0);
+    } else {
+      const classRef = resolveForwardRef(provider && (provider.useClass || provider.provide));
+      if (ngDevMode && !classRef) {
+        throwInvalidProviderError(ngModuleType, providers, provider);
+      }
+      if (hasDeps(provider)) {
+        factory = () => new classRef(...injectArgs(provider.deps));
+      } else {
+        return getFactoryDef(classRef) || injectableDefOrInjectorDefFactory(classRef);
+      }
+    }
+  }
+  return factory;
+}
+function assertNotDestroyed(injector) {
+  if (injector.destroyed) {
+    throw new RuntimeError(205, ngDevMode && "Injector has already been destroyed.");
+  }
+}
+function makeRecord(factory, value, multi = false) {
+  return {
+    factory,
+    value,
+    multi: multi ? [] : void 0
+  };
+}
+function hasDeps(value) {
+  return !!value.deps;
+}
+function hasOnDestroy(value) {
+  return value !== null && typeof value === "object" && typeof value.ngOnDestroy === "function";
+}
+function couldBeInjectableType(value) {
+  return typeof value === "function" || typeof value === "object" && value.ngMetadataName === "InjectionToken";
+}
+function forEachSingleProvider(providers, fn) {
+  for (const provider of providers) {
+    if (Array.isArray(provider)) {
+      forEachSingleProvider(provider, fn);
+    } else if (provider && isEnvironmentProviders(provider)) {
+      forEachSingleProvider(provider.\u0275providers, fn);
+    } else {
+      fn(provider);
+    }
+  }
+}
+function runInInjectionContext(injector, fn) {
+  let internalInjector;
+  if (injector instanceof R3Injector) {
+    assertNotDestroyed(injector);
+    internalInjector = injector;
+  } else {
+    internalInjector = new RetrievingInjector(injector);
+  }
+  let prevInjectorProfilerContext;
+  if (ngDevMode) {
+    prevInjectorProfilerContext = setInjectorProfilerContext({ injector, token: null });
+  }
+  const prevInjector = (0, import_not_found.setCurrentInjector)(internalInjector);
+  const previousInjectImplementation = setInjectImplementation(void 0);
+  try {
+    return fn();
+  } finally {
+    (0, import_not_found.setCurrentInjector)(prevInjector);
+    ngDevMode && setInjectorProfilerContext(prevInjectorProfilerContext);
+    setInjectImplementation(previousInjectImplementation);
+  }
+}
+function isInInjectionContext() {
+  return getInjectImplementation() !== void 0 || (0, import_not_found.getCurrentInjector)() != null;
+}
+function assertInInjectionContext(debugFn) {
+  if (!isInInjectionContext()) {
+    throw new RuntimeError(-203, ngDevMode && debugFn.name + "() can only be used within an injection context such as a constructor, a factory function, a field initializer, or a function used with `runInInjectionContext`");
+  }
+}
+const HOST = 0;
+const TVIEW = 1;
+const FLAGS = 2;
+const PARENT = 3;
+const NEXT = 4;
+const T_HOST = 5;
+const HYDRATION = 6;
+const CLEANUP = 7;
+const CONTEXT = 8;
+const INJECTOR = 9;
+const ENVIRONMENT = 10;
+const RENDERER = 11;
+const CHILD_HEAD = 12;
+const CHILD_TAIL = 13;
+const DECLARATION_VIEW = 14;
+const DECLARATION_COMPONENT_VIEW = 15;
+const DECLARATION_LCONTAINER = 16;
+const PREORDER_HOOK_FLAGS = 17;
+const QUERIES = 18;
+const ID = 19;
+const EMBEDDED_VIEW_INJECTOR = 20;
+const ON_DESTROY_HOOKS = 21;
+const EFFECTS_TO_SCHEDULE = 22;
+const EFFECTS = 23;
+const REACTIVE_TEMPLATE_CONSUMER = 24;
+const AFTER_RENDER_SEQUENCES_TO_ADD = 25;
+const ANIMATIONS = 26;
+const HEADER_OFFSET = 27;
+const TYPE = 1;
+const DEHYDRATED_VIEWS = 6;
+const NATIVE = 7;
+const VIEW_REFS = 8;
+const MOVED_VIEWS = 9;
+const CONTAINER_HEADER_OFFSET = 10;
+function isLView(value) {
+  return Array.isArray(value) && typeof value[TYPE] === "object";
+}
+function isLContainer(value) {
+  return Array.isArray(value) && value[TYPE] === true;
+}
+function isContentQueryHost(tNode) {
+  return (tNode.flags & 4) !== 0;
+}
+function isComponentHost(tNode) {
+  return tNode.componentOffset > -1;
+}
+function isDirectiveHost(tNode) {
+  return (tNode.flags & 1) === 1;
+}
+function isComponentDef(def) {
+  return !!def.template;
+}
+function isRootView(target) {
+  return (target[FLAGS] & 512) !== 0;
+}
+function isProjectionTNode(tNode) {
+  return (tNode.type & 16) === 16;
+}
+function hasI18n(lView) {
+  return (lView[FLAGS] & 32) === 32;
+}
+function isDestroyed(lView) {
+  return (lView[FLAGS] & 256) === 256;
+}
+function assertTNodeForLView(tNode, lView) {
+  assertTNodeForTView(tNode, lView[TVIEW]);
+}
+function assertTNodeCreationIndex(lView, index) {
+  const adjustedIndex = index + HEADER_OFFSET;
+  assertIndexInRange(lView, adjustedIndex);
+  assertLessThan(adjustedIndex, lView[TVIEW].bindingStartIndex, "TNodes should be created before any bindings");
+}
+function assertTNodeForTView(tNode, tView) {
+  assertTNode(tNode);
+  const tData = tView.data;
+  for (let i = HEADER_OFFSET; i < tData.length; i++) {
+    if (tData[i] === tNode) {
+      return;
+    }
+  }
+  throwError("This TNode does not belong to this TView.");
+}
+function assertTNode(tNode) {
+  assertDefined(tNode, "TNode must be defined");
+  if (!(tNode && typeof tNode === "object" && tNode.hasOwnProperty("directiveStylingLast"))) {
+    throwError("Not of type TNode, got: " + tNode);
+  }
+}
+function assertTIcu(tIcu) {
+  assertDefined(tIcu, "Expected TIcu to be defined");
+  if (!(typeof tIcu.currentCaseLViewIndex === "number")) {
+    throwError("Object is not of TIcu type.");
+  }
+}
+function assertComponentType(actual, msg = "Type passed in is not ComponentType, it does not have '\u0275cmp' property.") {
+  if (!getComponentDef(actual)) {
+    throwError(msg);
+  }
+}
+function assertNgModuleType(actual, msg = "Type passed in is not NgModuleType, it does not have '\u0275mod' property.") {
+  if (!getNgModuleDef(actual)) {
+    throwError(msg);
+  }
+}
+function assertHasParent(tNode) {
+  assertDefined(tNode, "currentTNode should exist!");
+  assertDefined(tNode.parent, "currentTNode should have a parent");
+}
+function assertLContainer(value) {
+  assertDefined(value, "LContainer must be defined");
+  assertEqual(isLContainer(value), true, "Expecting LContainer");
+}
+function assertLViewOrUndefined(value) {
+  value && assertEqual(isLView(value), true, "Expecting LView or undefined or null");
+}
+function assertLView(value) {
+  assertDefined(value, "LView must be defined");
+  assertEqual(isLView(value), true, "Expecting LView");
+}
+function assertFirstCreatePass(tView, errMessage) {
+  assertEqual(tView.firstCreatePass, true, errMessage || "Should only be called in first create pass.");
+}
+function assertFirstUpdatePass(tView, errMessage) {
+  assertEqual(tView.firstUpdatePass, true, "Should only be called in first update pass.");
+}
+function assertDirectiveDef(obj) {
+  if (obj.type === void 0 || obj.selectors == void 0 || obj.inputs === void 0) {
+    throwError(`Expected a DirectiveDef/ComponentDef and this object does not seem to have the expected shape.`);
+  }
+}
+function assertIndexInDeclRange(tView, index) {
+  assertBetween(HEADER_OFFSET, tView.bindingStartIndex, index);
+}
+function assertIndexInExpandoRange(lView, index) {
+  const tView = lView[1];
+  assertBetween(tView.expandoStartIndex, lView.length, index);
+}
+function assertBetween(lower, upper, index) {
+  if (!(lower <= index && index < upper)) {
+    throwError(`Index out of range (expecting ${lower} <= ${index} < ${upper})`);
+  }
+}
+function assertProjectionSlots(lView, errMessage) {
+  assertDefined(lView[DECLARATION_COMPONENT_VIEW], "Component views should exist.");
+  assertDefined(lView[DECLARATION_COMPONENT_VIEW][T_HOST].projection, "Components with projection nodes (<ng-content>) must have projection slots defined.");
+}
+function assertParentView(lView, errMessage) {
+  assertDefined(lView, "Component views should always have a parent view (component's host view)");
+}
+function assertNodeInjector(lView, injectorIndex) {
+  assertIndexInExpandoRange(lView, injectorIndex);
+  assertIndexInExpandoRange(
+    lView,
+    injectorIndex + 8
+    /* NodeInjectorOffset.PARENT */
+  );
+  assertNumber(lView[injectorIndex + 0], "injectorIndex should point to a bloom filter");
+  assertNumber(lView[injectorIndex + 1], "injectorIndex should point to a bloom filter");
+  assertNumber(lView[injectorIndex + 2], "injectorIndex should point to a bloom filter");
+  assertNumber(lView[injectorIndex + 3], "injectorIndex should point to a bloom filter");
+  assertNumber(lView[injectorIndex + 4], "injectorIndex should point to a bloom filter");
+  assertNumber(lView[injectorIndex + 5], "injectorIndex should point to a bloom filter");
+  assertNumber(lView[injectorIndex + 6], "injectorIndex should point to a bloom filter");
+  assertNumber(lView[injectorIndex + 7], "injectorIndex should point to a bloom filter");
+  assertNumber(lView[
+    injectorIndex + 8
+    /* NodeInjectorOffset.PARENT */
+  ], "injectorIndex should point to parent injector");
+}
+const SVG_NAMESPACE = "svg";
+const MATH_ML_NAMESPACE = "math";
+function unwrapRNode(value) {
+  while (Array.isArray(value)) {
+    value = value[HOST];
+  }
+  return value;
+}
+function unwrapLView(value) {
+  while (Array.isArray(value)) {
+    if (typeof value[TYPE] === "object")
+      return value;
+    value = value[HOST];
+  }
+  return null;
+}
+function getNativeByIndex(index, lView) {
+  ngDevMode && assertIndexInRange(lView, index);
+  ngDevMode && assertGreaterThanOrEqual(index, HEADER_OFFSET, "Expected to be past HEADER_OFFSET");
+  return unwrapRNode(lView[index]);
+}
+function getNativeByTNode(tNode, lView) {
+  ngDevMode && assertTNodeForLView(tNode, lView);
+  ngDevMode && assertIndexInRange(lView, tNode.index);
+  const node = unwrapRNode(lView[tNode.index]);
+  return node;
+}
+function getNativeByTNodeOrNull(tNode, lView) {
+  const index = tNode === null ? -1 : tNode.index;
+  if (index !== -1) {
+    ngDevMode && assertTNodeForLView(tNode, lView);
+    const node = unwrapRNode(lView[index]);
+    return node;
+  }
+  return null;
+}
+function getTNode(tView, index) {
+  ngDevMode && assertGreaterThan(index, -1, "wrong index for TNode");
+  ngDevMode && assertLessThan(index, tView.data.length, "wrong index for TNode");
+  const tNode = tView.data[index];
+  ngDevMode && tNode !== null && assertTNode(tNode);
+  return tNode;
+}
+function load(view, index) {
+  ngDevMode && assertIndexInRange(view, index);
+  return view[index];
+}
+function store(tView, lView, index, value) {
+  if (index >= tView.data.length) {
+    tView.data[index] = null;
+    tView.blueprint[index] = null;
+  }
+  lView[index] = value;
+}
+function getComponentLViewByIndex(nodeIndex, hostView) {
+  ngDevMode && assertIndexInRange(hostView, nodeIndex);
+  const slotValue = hostView[nodeIndex];
+  const lView = isLView(slotValue) ? slotValue : slotValue[HOST];
+  return lView;
+}
+function isCreationMode(view) {
+  return (view[FLAGS] & 4) === 4;
+}
+function viewAttachedToChangeDetector(view) {
+  return (view[FLAGS] & 128) === 128;
+}
+function viewAttachedToContainer(view) {
+  return isLContainer(view[PARENT]);
+}
+function getConstant(consts, index) {
+  if (index === null || index === void 0)
+    return null;
+  ngDevMode && assertIndexInRange(consts, index);
+  return consts[index];
+}
+function resetPreOrderHookFlags(lView) {
+  lView[PREORDER_HOOK_FLAGS] = 0;
+}
+function markViewForRefresh(lView) {
+  if (lView[FLAGS] & 1024) {
+    return;
+  }
+  lView[FLAGS] |= 1024;
+  if (viewAttachedToChangeDetector(lView)) {
+    markAncestorsForTraversal(lView);
+  }
+}
+function walkUpViews(nestingLevel, currentView) {
+  while (nestingLevel > 0) {
+    ngDevMode && assertDefined(currentView[DECLARATION_VIEW], "Declaration view should be defined if nesting level is greater than 0.");
+    currentView = currentView[DECLARATION_VIEW];
+    nestingLevel--;
+  }
+  return currentView;
+}
+function requiresRefreshOrTraversal(lView) {
+  var _a;
+  return !!(lView[FLAGS] & (1024 | 8192) || ((_a = lView[REACTIVE_TEMPLATE_CONSUMER]) == null ? void 0 : _a.dirty));
+}
+function updateAncestorTraversalFlagsOnAttach(lView) {
+  var _a;
+  (_a = lView[ENVIRONMENT].changeDetectionScheduler) == null ? void 0 : _a.notify(8);
+  if (lView[FLAGS] & 64) {
+    lView[FLAGS] |= 1024;
+  }
+  if (requiresRefreshOrTraversal(lView)) {
+    markAncestorsForTraversal(lView);
+  }
+}
+function markAncestorsForTraversal(lView) {
+  var _a;
+  (_a = lView[ENVIRONMENT].changeDetectionScheduler) == null ? void 0 : _a.notify(0);
+  let parent = getLViewParent(lView);
+  while (parent !== null) {
+    if (parent[FLAGS] & 8192) {
+      break;
+    }
+    parent[FLAGS] |= 8192;
+    if (!viewAttachedToChangeDetector(parent)) {
+      break;
+    }
+    parent = getLViewParent(parent);
+  }
+}
+function storeLViewOnDestroy(lView, onDestroyCallback) {
+  if (isDestroyed(lView)) {
+    throw new RuntimeError(911, ngDevMode && "View has already been destroyed.");
+  }
+  if (lView[ON_DESTROY_HOOKS] === null) {
+    lView[ON_DESTROY_HOOKS] = [];
+  }
+  lView[ON_DESTROY_HOOKS].push(onDestroyCallback);
+}
+function removeLViewOnDestroy(lView, onDestroyCallback) {
+  if (lView[ON_DESTROY_HOOKS] === null)
+    return;
+  const destroyCBIdx = lView[ON_DESTROY_HOOKS].indexOf(onDestroyCallback);
+  if (destroyCBIdx !== -1) {
+    lView[ON_DESTROY_HOOKS].splice(destroyCBIdx, 1);
+  }
+}
+function getLViewParent(lView) {
+  ngDevMode && assertLView(lView);
+  const parent = lView[PARENT];
+  return isLContainer(parent) ? parent[PARENT] : parent;
+}
+function getOrCreateLViewCleanup(view) {
+  var _a;
+  return (_a = view[CLEANUP]) != null ? _a : view[CLEANUP] = [];
+}
+function getOrCreateTViewCleanup(tView) {
+  var _a;
+  return (_a = tView.cleanup) != null ? _a : tView.cleanup = [];
+}
+function storeCleanupWithContext(tView, lView, context, cleanupFn) {
+  const lCleanup = getOrCreateLViewCleanup(lView);
+  ngDevMode && assertDefined(context, "Cleanup context is mandatory when registering framework-level destroy hooks");
+  lCleanup.push(context);
+  if (tView.firstCreatePass) {
+    getOrCreateTViewCleanup(tView).push(cleanupFn, lCleanup.length - 1);
+  } else {
+    if (ngDevMode) {
+      Object.freeze(getOrCreateTViewCleanup(tView));
+    }
+  }
+}
+const instructionState = {
+  lFrame: createLFrame(null),
+  bindingsEnabled: true,
+  skipHydrationRootTNode: null
+};
+var CheckNoChangesMode;
+(function(CheckNoChangesMode2) {
+  CheckNoChangesMode2[CheckNoChangesMode2["Off"] = 0] = "Off";
+  CheckNoChangesMode2[CheckNoChangesMode2["Exhaustive"] = 1] = "Exhaustive";
+  CheckNoChangesMode2[CheckNoChangesMode2["OnlyDirtyViews"] = 2] = "OnlyDirtyViews";
+})(CheckNoChangesMode || (CheckNoChangesMode = {}));
+let _checkNoChangesMode = 0;
+let _isRefreshingViews = false;
+function getElementDepthCount() {
+  return instructionState.lFrame.elementDepthCount;
+}
+function increaseElementDepthCount() {
+  instructionState.lFrame.elementDepthCount++;
+}
+function decreaseElementDepthCount() {
+  instructionState.lFrame.elementDepthCount--;
+}
+function getBindingsEnabled() {
+  return instructionState.bindingsEnabled;
+}
+function isInSkipHydrationBlock() {
+  return instructionState.skipHydrationRootTNode !== null;
+}
+function isSkipHydrationRootTNode(tNode) {
+  return instructionState.skipHydrationRootTNode === tNode;
+}
+function \u0275\u0275enableBindings() {
+  instructionState.bindingsEnabled = true;
+}
+function enterSkipHydrationBlock(tNode) {
+  instructionState.skipHydrationRootTNode = tNode;
+}
+function \u0275\u0275disableBindings() {
+  instructionState.bindingsEnabled = false;
+}
+function leaveSkipHydrationBlock() {
+  instructionState.skipHydrationRootTNode = null;
+}
+function getLView() {
+  return instructionState.lFrame.lView;
+}
+function getTView() {
+  return instructionState.lFrame.tView;
+}
+function \u0275\u0275restoreView(viewToRestore) {
+  instructionState.lFrame.contextLView = viewToRestore;
+  return viewToRestore[CONTEXT];
+}
+function \u0275\u0275resetView(value) {
+  instructionState.lFrame.contextLView = null;
+  return value;
+}
+function getCurrentTNode() {
+  let currentTNode = getCurrentTNodePlaceholderOk();
+  while (currentTNode !== null && currentTNode.type === 64) {
+    currentTNode = currentTNode.parent;
+  }
+  return currentTNode;
+}
+function getCurrentTNodePlaceholderOk() {
+  return instructionState.lFrame.currentTNode;
+}
+function getCurrentParentTNode() {
+  const lFrame = instructionState.lFrame;
+  const currentTNode = lFrame.currentTNode;
+  return lFrame.isParent ? currentTNode : currentTNode.parent;
+}
+function setCurrentTNode(tNode, isParent) {
+  ngDevMode && tNode && assertTNodeForTView(tNode, instructionState.lFrame.tView);
+  const lFrame = instructionState.lFrame;
+  lFrame.currentTNode = tNode;
+  lFrame.isParent = isParent;
+}
+function isCurrentTNodeParent() {
+  return instructionState.lFrame.isParent;
+}
+function setCurrentTNodeAsNotParent() {
+  instructionState.lFrame.isParent = false;
+}
+function getContextLView() {
+  const contextLView = instructionState.lFrame.contextLView;
+  ngDevMode && assertDefined(contextLView, "contextLView must be defined.");
+  return contextLView;
+}
+function isInCheckNoChangesMode() {
+  !ngDevMode && throwError("Must never be called in production mode");
+  return _checkNoChangesMode !== CheckNoChangesMode.Off;
+}
+function isExhaustiveCheckNoChanges() {
+  !ngDevMode && throwError("Must never be called in production mode");
+  return _checkNoChangesMode === CheckNoChangesMode.Exhaustive;
+}
+function setIsInCheckNoChangesMode(mode) {
+  !ngDevMode && throwError("Must never be called in production mode");
+  _checkNoChangesMode = mode;
+}
+function isRefreshingViews() {
+  return _isRefreshingViews;
+}
+function setIsRefreshingViews(mode) {
+  const prev = _isRefreshingViews;
+  _isRefreshingViews = mode;
+  return prev;
+}
+function getBindingRoot() {
+  const lFrame = instructionState.lFrame;
+  let index = lFrame.bindingRootIndex;
+  if (index === -1) {
+    index = lFrame.bindingRootIndex = lFrame.tView.bindingStartIndex;
+  }
+  return index;
+}
+function getBindingIndex() {
+  return instructionState.lFrame.bindingIndex;
+}
+function setBindingIndex(value) {
+  return instructionState.lFrame.bindingIndex = value;
+}
+function nextBindingIndex() {
+  return instructionState.lFrame.bindingIndex++;
+}
+function incrementBindingIndex(count) {
+  const lFrame = instructionState.lFrame;
+  const index = lFrame.bindingIndex;
+  lFrame.bindingIndex = lFrame.bindingIndex + count;
+  return index;
+}
+function isInI18nBlock() {
+  return instructionState.lFrame.inI18n;
+}
+function setInI18nBlock(isInI18nBlock2) {
+  instructionState.lFrame.inI18n = isInI18nBlock2;
+}
+function setBindingRootForHostBindings(bindingRootIndex, currentDirectiveIndex) {
+  const lFrame = instructionState.lFrame;
+  lFrame.bindingIndex = lFrame.bindingRootIndex = bindingRootIndex;
+  setCurrentDirectiveIndex(currentDirectiveIndex);
+}
+function getCurrentDirectiveIndex() {
+  return instructionState.lFrame.currentDirectiveIndex;
+}
+function setCurrentDirectiveIndex(currentDirectiveIndex) {
+  instructionState.lFrame.currentDirectiveIndex = currentDirectiveIndex;
+}
+function getCurrentDirectiveDef(tData) {
+  const currentDirectiveIndex = instructionState.lFrame.currentDirectiveIndex;
+  return currentDirectiveIndex === -1 ? null : tData[currentDirectiveIndex];
+}
+function getCurrentQueryIndex() {
+  return instructionState.lFrame.currentQueryIndex;
+}
+function setCurrentQueryIndex(value) {
+  instructionState.lFrame.currentQueryIndex = value;
+}
+function getDeclarationTNode(lView) {
+  const tView = lView[TVIEW];
+  if (tView.type === 2) {
+    ngDevMode && assertDefined(tView.declTNode, "Embedded TNodes should have declaration parents.");
+    return tView.declTNode;
+  }
+  if (tView.type === 1) {
+    return lView[T_HOST];
+  }
+  return null;
+}
+function enterDI(lView, tNode, flags) {
+  ngDevMode && assertLViewOrUndefined(lView);
+  if (flags & 4) {
+    ngDevMode && assertTNodeForTView(tNode, lView[TVIEW]);
+    let parentTNode = tNode;
+    let parentLView = lView;
+    while (true) {
+      ngDevMode && assertDefined(parentTNode, "Parent TNode should be defined");
+      parentTNode = parentTNode.parent;
+      if (parentTNode === null && !(flags & 1)) {
+        parentTNode = getDeclarationTNode(parentLView);
+        if (parentTNode === null)
+          break;
+        ngDevMode && assertDefined(parentLView, "Parent LView should be defined");
+        parentLView = parentLView[DECLARATION_VIEW];
+        if (parentTNode.type & (2 | 8)) {
+          break;
+        }
+      } else {
+        break;
+      }
+    }
+    if (parentTNode === null) {
+      return false;
+    } else {
+      tNode = parentTNode;
+      lView = parentLView;
+    }
+  }
+  ngDevMode && assertTNodeForLView(tNode, lView);
+  const lFrame = instructionState.lFrame = allocLFrame();
+  lFrame.currentTNode = tNode;
+  lFrame.lView = lView;
+  return true;
+}
+function enterView(newView) {
+  ngDevMode && assertNotEqual(newView[0], newView[1], "????");
+  ngDevMode && assertLViewOrUndefined(newView);
+  const newLFrame = allocLFrame();
+  if (ngDevMode) {
+    assertEqual(newLFrame.isParent, true, "Expected clean LFrame");
+    assertEqual(newLFrame.lView, null, "Expected clean LFrame");
+    assertEqual(newLFrame.tView, null, "Expected clean LFrame");
+    assertEqual(newLFrame.selectedIndex, -1, "Expected clean LFrame");
+    assertEqual(newLFrame.elementDepthCount, 0, "Expected clean LFrame");
+    assertEqual(newLFrame.currentDirectiveIndex, -1, "Expected clean LFrame");
+    assertEqual(newLFrame.currentNamespace, null, "Expected clean LFrame");
+    assertEqual(newLFrame.bindingRootIndex, -1, "Expected clean LFrame");
+    assertEqual(newLFrame.currentQueryIndex, 0, "Expected clean LFrame");
+  }
+  const tView = newView[TVIEW];
+  instructionState.lFrame = newLFrame;
+  ngDevMode && tView.firstChild && assertTNodeForTView(tView.firstChild, tView);
+  newLFrame.currentTNode = tView.firstChild;
+  newLFrame.lView = newView;
+  newLFrame.tView = tView;
+  newLFrame.contextLView = newView;
+  newLFrame.bindingIndex = tView.bindingStartIndex;
+  newLFrame.inI18n = false;
+}
+function allocLFrame() {
+  const currentLFrame = instructionState.lFrame;
+  const childLFrame = currentLFrame === null ? null : currentLFrame.child;
+  const newLFrame = childLFrame === null ? createLFrame(currentLFrame) : childLFrame;
+  return newLFrame;
+}
+function createLFrame(parent) {
+  const lFrame = {
+    currentTNode: null,
+    isParent: true,
+    lView: null,
+    tView: null,
+    selectedIndex: -1,
+    contextLView: null,
+    elementDepthCount: 0,
+    currentNamespace: null,
+    currentDirectiveIndex: -1,
+    bindingRootIndex: -1,
+    bindingIndex: -1,
+    currentQueryIndex: 0,
+    parent,
+    child: null,
+    inI18n: false
+  };
+  parent !== null && (parent.child = lFrame);
+  return lFrame;
+}
+function leaveViewLight() {
+  const oldLFrame = instructionState.lFrame;
+  instructionState.lFrame = oldLFrame.parent;
+  oldLFrame.currentTNode = null;
+  oldLFrame.lView = null;
+  return oldLFrame;
+}
+const leaveDI = leaveViewLight;
+function leaveView() {
+  const oldLFrame = leaveViewLight();
+  oldLFrame.isParent = true;
+  oldLFrame.tView = null;
+  oldLFrame.selectedIndex = -1;
+  oldLFrame.contextLView = null;
+  oldLFrame.elementDepthCount = 0;
+  oldLFrame.currentDirectiveIndex = -1;
+  oldLFrame.currentNamespace = null;
+  oldLFrame.bindingRootIndex = -1;
+  oldLFrame.bindingIndex = -1;
+  oldLFrame.currentQueryIndex = 0;
+}
+function nextContextImpl(level) {
+  const contextLView = instructionState.lFrame.contextLView = walkUpViews(level, instructionState.lFrame.contextLView);
+  return contextLView[CONTEXT];
+}
+function getSelectedIndex() {
+  return instructionState.lFrame.selectedIndex;
+}
+function setSelectedIndex(index) {
+  ngDevMode && index !== -1 && assertGreaterThanOrEqual(index, HEADER_OFFSET, "Index must be past HEADER_OFFSET (or -1).");
+  ngDevMode && assertLessThan(index, instructionState.lFrame.lView.length, "Can't set index passed end of LView");
+  instructionState.lFrame.selectedIndex = index;
+}
+function getSelectedTNode() {
+  const lFrame = instructionState.lFrame;
+  return getTNode(lFrame.tView, lFrame.selectedIndex);
+}
+function \u0275\u0275namespaceSVG() {
+  instructionState.lFrame.currentNamespace = SVG_NAMESPACE;
+}
+function \u0275\u0275namespaceMathML() {
+  instructionState.lFrame.currentNamespace = MATH_ML_NAMESPACE;
+}
+function \u0275\u0275namespaceHTML() {
+  namespaceHTMLInternal();
+}
+function namespaceHTMLInternal() {
+  instructionState.lFrame.currentNamespace = null;
+}
+function getNamespace() {
+  return instructionState.lFrame.currentNamespace;
+}
+let _wasLastNodeCreated = true;
+function wasLastNodeCreated() {
+  return _wasLastNodeCreated;
+}
+function lastNodeWasCreated(flag) {
+  _wasLastNodeCreated = flag;
+}
+function createInjector(defType, parent = null, additionalProviders = null, name) {
+  const injector = createInjectorWithoutInjectorInstances(defType, parent, additionalProviders, name);
+  injector.resolveInjectorInitializers();
+  return injector;
+}
+function createInjectorWithoutInjectorInstances(defType, parent = null, additionalProviders = null, name, scopes = /* @__PURE__ */ new Set()) {
+  const providers = [additionalProviders || EMPTY_ARRAY, importProvidersFrom(defType)];
+  name = name || (typeof defType === "object" ? void 0 : stringify(defType));
+  return new R3Injector(providers, parent || getNullInjector(), name || null, scopes);
+}
+const _Injector = class _Injector {
+  static create(options, parent) {
+    var _a;
+    if (Array.isArray(options)) {
+      return createInjector({ name: "" }, parent, options, "");
+    } else {
+      const name = (_a = options.name) != null ? _a : "";
+      return createInjector({ name }, options.parent, options.providers, name);
+    }
+  }
+};
+__publicField(_Injector, "THROW_IF_NOT_FOUND", THROW_IF_NOT_FOUND);
+__publicField(_Injector, "NULL", new NullInjector());
+/** @nocollapse */
+__publicField(
+  _Injector,
+  "\u0275prov",
+  /** @pureOrBreakMyCode */
+  /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _Injector,
+    providedIn: "any",
+    factory: () => \u0275\u0275inject(INJECTOR$1)
+  })
+);
+/**
+ * @internal
+ * @nocollapse
+ */
+__publicField(_Injector, "__NG_ELEMENT_ID__", -1);
+let Injector = _Injector;
+const DOCUMENT = new InjectionToken(ngDevMode ? "DocumentToken" : "");
+class DestroyRef {
+}
+/**
+ * @internal
+ * @nocollapse
+ */
+__publicField(DestroyRef, "__NG_ELEMENT_ID__", injectDestroyRef);
+/**
+ * @internal
+ * @nocollapse
+ */
+__publicField(DestroyRef, "__NG_ENV_ID__", (injector) => injector);
+class NodeInjectorDestroyRef extends DestroyRef {
+  constructor(_lView) {
+    super();
+    __publicField(this, "_lView");
+    this._lView = _lView;
+  }
+  get destroyed() {
+    return isDestroyed(this._lView);
+  }
+  onDestroy(callback) {
+    const lView = this._lView;
+    storeLViewOnDestroy(lView, callback);
+    return () => removeLViewOnDestroy(lView, callback);
+  }
+}
+function injectDestroyRef() {
+  return new NodeInjectorDestroyRef(getLView());
+}
+class ErrorHandler {
+  constructor() {
+    /**
+     * @internal
+     */
+    __publicField(this, "_console", console);
+  }
+  handleError(error) {
+    this._console.error("ERROR", error);
+  }
+}
+const INTERNAL_APPLICATION_ERROR_HANDLER = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "internal error handler" : "", {
+  providedIn: "root",
+  factory: () => {
+    const injector = inject(EnvironmentInjector);
+    let userErrorHandler;
+    return (e) => {
+      if (injector.destroyed && !userErrorHandler) {
+        setTimeout(() => {
+          throw e;
+        });
+      } else {
+        userErrorHandler != null ? userErrorHandler : userErrorHandler = injector.get(ErrorHandler);
+        userErrorHandler.handleError(e);
+      }
+    };
+  }
+});
+const errorHandlerEnvironmentInitializer = {
+  provide: ENVIRONMENT_INITIALIZER,
+  useValue: () => void inject(ErrorHandler),
+  multi: true
+};
+const globalErrorListeners = new InjectionToken(ngDevMode ? "GlobalErrorListeners" : "", {
+  providedIn: "root",
+  factory: () => {
+    if (typeof ngServerMode !== "undefined" && ngServerMode) {
+      return;
+    }
+    const window = inject(DOCUMENT).defaultView;
+    if (!window) {
+      return;
+    }
+    const errorHandler = inject(INTERNAL_APPLICATION_ERROR_HANDLER);
+    const rejectionListener = (e) => {
+      errorHandler(e.reason);
+      e.preventDefault();
+    };
+    const errorListener = (e) => {
+      if (e.error) {
+        errorHandler(e.error);
+      } else {
+        errorHandler(new Error(ngDevMode ? `An ErrorEvent with no error occurred. See Error.cause for details: ${e.message}` : e.message, { cause: e }));
+      }
+      e.preventDefault();
+    };
+    const setupEventListeners = () => {
+      window.addEventListener("unhandledrejection", rejectionListener);
+      window.addEventListener("error", errorListener);
+    };
+    if (typeof Zone !== "undefined") {
+      Zone.root.run(setupEventListeners);
+    } else {
+      setupEventListeners();
+    }
+    inject(DestroyRef).onDestroy(() => {
+      window.removeEventListener("error", errorListener);
+      window.removeEventListener("unhandledrejection", rejectionListener);
+    });
+  }
+});
+function provideBrowserGlobalErrorListeners() {
+  return makeEnvironmentProviders([
+    provideEnvironmentInitializer(() => void inject(globalErrorListeners))
+  ]);
+}
+function isSignal(value) {
+  return typeof value === "function" && value[import_signal.SIGNAL] !== void 0;
+}
+function \u0275unwrapWritableSignal(value) {
+  return null;
+}
+function signal(initialValue, options) {
+  const [get, set, update] = (0, import_signal.createSignal)(initialValue, options == null ? void 0 : options.equal);
+  const signalFn = get;
+  const node = signalFn[import_signal.SIGNAL];
+  signalFn.set = set;
+  signalFn.update = update;
+  signalFn.asReadonly = signalAsReadonlyFn.bind(signalFn);
+  if (ngDevMode) {
+    signalFn.toString = () => `[Signal: ${signalFn()}]`;
+    node.debugName = options == null ? void 0 : options.debugName;
+  }
+  return signalFn;
+}
+function signalAsReadonlyFn() {
+  const node = this[import_signal.SIGNAL];
+  if (node.readonlyFn === void 0) {
+    const readonlyFn = () => this();
+    readonlyFn[import_signal.SIGNAL] = node;
+    node.readonlyFn = readonlyFn;
+  }
+  return node.readonlyFn;
+}
+function isWritableSignal(value) {
+  return isSignal(value) && typeof value.set === "function";
+}
+function assertNotInReactiveContext(debugFn, extraContext) {
+  if ((0, import_signal.getActiveConsumer)() !== null) {
+    throw new RuntimeError(-602, ngDevMode && `${debugFn.name}() cannot be called from within a reactive context.${extraContext ? ` ${extraContext}` : ""}`);
+  }
+}
+class ViewContext {
+  constructor(view, node) {
+    __publicField(this, "view");
+    __publicField(this, "node");
+    this.view = view;
+    this.node = node;
+  }
+}
+/**
+ * @internal
+ * @nocollapse
+ */
+__publicField(ViewContext, "__NG_ELEMENT_ID__", injectViewContext);
+function injectViewContext() {
+  return new ViewContext(getLView(), getCurrentTNode());
+}
+class ChangeDetectionScheduler {
+}
+const ZONELESS_ENABLED = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "Zoneless enabled" : "", { providedIn: "root", factory: () => false });
+const PROVIDED_ZONELESS = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "Zoneless provided" : "", { providedIn: "root", factory: () => false });
+const ZONELESS_SCHEDULER_DISABLED = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "scheduler disabled" : "");
+const SCHEDULE_IN_ROOT_ZONE = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "run changes outside zone in root" : "");
+const _PendingTasksInternal = class _PendingTasksInternal {
+  constructor() {
+    __publicField(this, "taskId", 0);
+    __publicField(this, "pendingTasks", /* @__PURE__ */ new Set());
+    __publicField(this, "destroyed", false);
+    __publicField(this, "pendingTask", new import_rxjs.BehaviorSubject(false));
+  }
+  get hasPendingTasks() {
+    return this.destroyed ? false : this.pendingTask.value;
+  }
+  /**
+   * In case the service is about to be destroyed, return a self-completing observable.
+   * Otherwise, return the observable that emits the current state of pending tasks.
+   */
+  get hasPendingTasksObservable() {
+    if (this.destroyed) {
+      return new import_rxjs.Observable((subscriber) => {
+        subscriber.next(false);
+        subscriber.complete();
+      });
+    }
+    return this.pendingTask;
+  }
+  add() {
+    if (!this.hasPendingTasks && !this.destroyed) {
+      this.pendingTask.next(true);
+    }
+    const taskId = this.taskId++;
+    this.pendingTasks.add(taskId);
+    return taskId;
+  }
+  has(taskId) {
+    return this.pendingTasks.has(taskId);
+  }
+  remove(taskId) {
+    this.pendingTasks.delete(taskId);
+    if (this.pendingTasks.size === 0 && this.hasPendingTasks) {
+      this.pendingTask.next(false);
+    }
+  }
+  ngOnDestroy() {
+    this.pendingTasks.clear();
+    if (this.hasPendingTasks) {
+      this.pendingTask.next(false);
+    }
+    this.destroyed = true;
+    this.pendingTask.unsubscribe();
+  }
+};
+/** @nocollapse */
+__publicField(
+  _PendingTasksInternal,
+  "\u0275prov",
+  /** @pureOrBreakMyCode */
+  /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _PendingTasksInternal,
+    providedIn: "root",
+    factory: () => new _PendingTasksInternal()
+  })
+);
+let PendingTasksInternal = _PendingTasksInternal;
+const _PendingTasks = class _PendingTasks {
+  constructor() {
+    __publicField(this, "internalPendingTasks", inject(PendingTasksInternal));
+    __publicField(this, "scheduler", inject(ChangeDetectionScheduler));
+    __publicField(this, "errorHandler", inject(INTERNAL_APPLICATION_ERROR_HANDLER));
+  }
+  /**
+   * Adds a new task that should block application's stability.
+   * @returns A cleanup function that removes a task when called.
+   */
+  add() {
+    const taskId = this.internalPendingTasks.add();
+    return () => {
+      if (!this.internalPendingTasks.has(taskId)) {
+        return;
+      }
+      this.scheduler.notify(
+        11
+        /* NotificationSource.PendingTaskRemoved */
+      );
+      this.internalPendingTasks.remove(taskId);
+    };
+  }
+  /**
+   * Runs an asynchronous function and blocks the application's stability until the function completes.
+   *
+   * ```ts
+   * pendingTasks.run(async () => {
+   *   const userData = await fetch('/api/user');
+   *   this.userData.set(userData);
+   * });
+   * ```
+   *
+   * @param fn The asynchronous function to execute
+   * @developerPreview 19.0
+   */
+  run(fn) {
+    const removeTask = this.add();
+    fn().catch(this.errorHandler).finally(removeTask);
+  }
+};
+/** @nocollapse */
+__publicField(
+  _PendingTasks,
+  "\u0275prov",
+  /** @pureOrBreakMyCode */
+  /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _PendingTasks,
+    providedIn: "root",
+    factory: () => new _PendingTasks()
+  })
+);
+let PendingTasks = _PendingTasks;
+function noop(...args) {
+}
+const _EffectScheduler = class _EffectScheduler {
+};
+/** @nocollapse */
+__publicField(
+  _EffectScheduler,
+  "\u0275prov",
+  /** @pureOrBreakMyCode */
+  /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _EffectScheduler,
+    providedIn: "root",
+    factory: () => new ZoneAwareEffectScheduler()
+  })
+);
+let EffectScheduler = _EffectScheduler;
+class ZoneAwareEffectScheduler {
+  constructor() {
+    __publicField(this, "dirtyEffectCount", 0);
+    __publicField(this, "queues", /* @__PURE__ */ new Map());
+  }
+  add(handle) {
+    this.enqueue(handle);
+    this.schedule(handle);
+  }
+  schedule(handle) {
+    if (!handle.dirty) {
+      return;
+    }
+    this.dirtyEffectCount++;
+  }
+  remove(handle) {
+    const zone = handle.zone;
+    const queue = this.queues.get(zone);
+    if (!queue.has(handle)) {
+      return;
+    }
+    queue.delete(handle);
+    if (handle.dirty) {
+      this.dirtyEffectCount--;
+    }
+  }
+  enqueue(handle) {
+    const zone = handle.zone;
+    if (!this.queues.has(zone)) {
+      this.queues.set(zone, /* @__PURE__ */ new Set());
+    }
+    const queue = this.queues.get(zone);
+    if (queue.has(handle)) {
+      return;
+    }
+    queue.add(handle);
+  }
+  /**
+   * Run all scheduled effects.
+   *
+   * Execution order of effects within the same zone is guaranteed to be FIFO, but there is no
+   * ordering guarantee between effects scheduled in different zones.
+   */
+  flush() {
+    while (this.dirtyEffectCount > 0) {
+      let ranOneEffect = false;
+      for (const [zone, queue] of this.queues) {
+        if (zone === null) {
+          ranOneEffect || (ranOneEffect = this.flushQueue(queue));
+        } else {
+          ranOneEffect || (ranOneEffect = zone.run(() => this.flushQueue(queue)));
+        }
+      }
+      if (!ranOneEffect) {
+        this.dirtyEffectCount = 0;
+      }
+    }
+  }
+  flushQueue(queue) {
+    let ranOneEffect = false;
+    for (const handle of queue) {
+      if (!handle.dirty) {
+        continue;
+      }
+      this.dirtyEffectCount--;
+      ranOneEffect = true;
+      handle.run();
+    }
+    return ranOneEffect;
+  }
+}