static-injector 6.3.1 → 7.0.0

package/index.js

@@ -20,6 +20,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/import/index.ts
 var import_exports = {};
 __export(import_exports, {
+  APP_ID: () => APP_ID,
   ChangeDetectionScheduler: () => ChangeDetectionScheduler,
   ChangeDetectionSchedulerImpl: () => ChangeDetectionSchedulerImpl,
   DecoratorFlags: () => DecoratorFlags,
@@ -27,6 +28,7 @@ __export(import_exports, {
   EffectScheduler: () => EffectScheduler,
   EnvironmentInjector: () => EnvironmentInjector,
   ErrorHandler: () => ErrorHandler,
+  EventEmitter: () => EventEmitter,
   INJECTOR_SCOPE: () => INJECTOR_SCOPE,
   INTERNAL_APPLICATION_ERROR_HANDLER: () => INTERNAL_APPLICATION_ERROR_HANDLER,
   Inject: () => Inject,
@@ -40,20 +42,20 @@ __export(import_exports, {
   NotificationSource: () => NotificationSource,
   NullInjector: () => NullInjector,
   Optional: () => Optional,
-  PROVIDED_ZONELESS: () => PROVIDED_ZONELESS,
   PendingTasks: () => PendingTasks,
-  PendingTasksInternal: () => PendingTasksInternal,
   R3Injector: () => R3Injector,
+  ResourceDependencyError: () => ResourceDependencyError,
+  ResourceParamsStatus: () => ResourceParamsStatus,
   RetrievingInjector: () => RetrievingInjector,
   RootStaticInjectOptions: () => RootStaticInjectOptions,
-  SCHEDULE_IN_ROOT_ZONE: () => SCHEDULE_IN_ROOT_ZONE,
   SOURCE: () => SOURCE,
   Self: () => Self,
   SkipSelf: () => SkipSelf,
   StaticInjectOptions: () => StaticInjectOptions,
   THROW_IF_NOT_FOUND: () => THROW_IF_NOT_FOUND,
-  ZONELESS_ENABLED: () => ZONELESS_ENABLED,
-  ZONELESS_SCHEDULER_DISABLED: () => ZONELESS_SCHEDULER_DISABLED,
+  TransferState: () => TransferState,
+  Type: () => Type,
+  assertInInjectionContext: () => assertInInjectionContext,
   assertNotDestroyed: () => assertNotDestroyed,
   assertNotInReactiveContext: () => assertNotInReactiveContext,
   attachInjectFlag: () => attachInjectFlag,
@@ -61,8 +63,9 @@ __export(import_exports, {
   convertToBitFlags: () => convertToBitFlags,
   createInjector: () => createInjector2,
   createRootInjector: () => createRootInjector,
+  debounced: () => debounced,
   effect: () => effect,
-  formatError: () => formatError,
+  forwardRef: () => forwardRef,
   getCurrentInjector: () => getCurrentInjector,
   getInheritedInjectableDef: () => getInheritedInjectableDef,
   getInjectFlag: () => getInjectFlag,
@@ -71,12 +74,20 @@ __export(import_exports, {
   getNullInjector: () => getNullInjector,
   inject: () => inject2,
   injectArgs: () => injectArgs,
+  injectAsync: () => injectAsync,
   injectInjectorOnly: () => injectInjectorOnly,
   isInjectable: () => isInjectable,
-  isSignal: () => isSignal,
+  isSignal: () => isSignal2,
+  isWritableSignal: () => isWritableSignal,
   linkedSignal: () => linkedSignal,
+  makeStateKey: () => makeStateKey,
+  onIdle: () => onIdle,
+  provideIdleServiceWith: () => provideIdleServiceWith,
   providerToFactory: () => providerToFactory,
+  resolveForwardRef: () => resolveForwardRef,
   resource: () => resource,
+  resourceFromSnapshots: () => resourceFromSnapshots,
+  runInInjectionContext: () => runInInjectionContext,
   setCurrentInjector: () => setCurrentInjector,
   signal: () => signal,
   untracked: () => untracked2,
@@ -91,6 +102,9 @@ __export(import_exports, {
 });
 module.exports = __toCommonJS(import_exports);
 
+// script/shim.js
+var ngDevMode = typeof ngDevMode === "undefined" ? true : ngDevMode;
+
 // src/import/di/interface/provider.ts
 function isEnvironmentProviders(value) {
   return value && !!value.ɵproviders;
@@ -108,17 +122,15 @@ function formatRuntimeErrorCode(code) {
 }
 function formatRuntimeError(code, message) {
   const fullCode = formatRuntimeErrorCode(code);
-  const errorMessage = `${fullCode}${message ? ": " + message : ""}`;
-  if (false) {
+  let errorMessage = `${fullCode}${message ? ": " + message : ""}`;
+  if (ngDevMode && code < 0) {
+    const addPeriodSeparator = !errorMessage.match(/[.,;!?\n]$/);
+    const separator = addPeriodSeparator ? "." : "";
+    errorMessage = `${errorMessage}${separator} Find more at ${"https://v22.angular.dev/errors"}/${fullCode}`;
   }
   return errorMessage;
 }
 
-// src/import/render3/definition_factory.ts
-function getFactoryDef(type, throwNotFound) {
-  return () => new type();
-}
-
 // src/import/util/property.ts
 function getClosureSafeProperty(objWithPropertyToExtract) {
   for (const key in objWithPropertyToExtract) {
@@ -126,41 +138,7 @@ function getClosureSafeProperty(objWithPropertyToExtract) {
       return key;
     }
   }
-  throw Error("");
-}
-
-// src/import/render3/errors_di.ts
-var NG_RUNTIME_ERROR_CODE = getClosureSafeProperty({ ngErrorCode: getClosureSafeProperty });
-var NG_RUNTIME_ERROR_MESSAGE = getClosureSafeProperty({ ngErrorMessage: getClosureSafeProperty });
-var NG_TOKEN_PATH = getClosureSafeProperty({ ngTokenPath: getClosureSafeProperty });
-function cyclicDependencyError(token, path) {
-  const message = "";
-  return createRuntimeError(message, -200 /* CYCLIC_DI_DEPENDENCY */, path);
-}
-function throwProviderNotFoundError(token, injectorName) {
-  const errorMessage = void 0;
-  throw new RuntimeError(-201 /* PROVIDER_NOT_FOUND */, errorMessage);
-}
-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];
-}
-
-// src/import/render3/fields.ts
-var NG_FACTORY_DEF = getClosureSafeProperty({ ɵfac: getClosureSafeProperty });
-var NG_ENV_ID = getClosureSafeProperty({ __NG_ENV_ID__: getClosureSafeProperty });
-
-// src/import/util/empty.ts
-var EMPTY_ARRAY = [];
-if (false) {
+  throw Error(typeof ngDevMode !== "undefined" && ngDevMode ? "Could not find renamed property on target object." : "");
 }
 
 // src/import/util/stringify.ts
@@ -190,9 +168,11 @@ function stringify(token) {
 var __forward_ref__ = getClosureSafeProperty({ __forward_ref__: getClosureSafeProperty });
 function forwardRef(forwardRefFn) {
   forwardRefFn.__forward_ref__ = forwardRef;
-  forwardRefFn.toString = function() {
-    return stringify(this());
-  };
+  if (ngDevMode) {
+    forwardRefFn.toString = function() {
+      return stringify(this());
+    };
+  }
   return forwardRefFn;
 }
 function resolveForwardRef(type) {
@@ -202,1237 +182,1600 @@ function isForwardRef(fn) {
   return typeof fn === "function" && fn.hasOwnProperty(__forward_ref__) && fn.__forward_ref__ === forwardRef;
 }
 
-// src/import/di/interface/defs.ts
-function ɵɵdefineInjectable(opts) {
-  return {
-    token: opts.token,
-    providedIn: opts.providedIn || null,
-    factory: opts.factory,
-    value: void 0
-  };
-}
-function ɵɵdefineInjector(options) {
-  return { providers: options.providers || [], imports: options.imports || [] };
-}
-function getInjectableDef(type) {
-  return getOwnDefinition(type, NG_PROV_DEF) || { token: type, factory: () => new type(), ...type.injectOptions };
+// src/primitives/signals/src/graph.ts
+var activeConsumer = null;
+var inNotificationPhase = false;
+var epoch = 1;
+var postProducerCreatedFn = null;
+var SIGNAL = /* @__PURE__ */ Symbol("SIGNAL");
+function setActiveConsumer(consumer) {
+  const prev = activeConsumer;
+  activeConsumer = consumer;
+  return prev;
 }
-function isInjectable(type) {
-  return getInjectableDef(type) !== null;
+function getActiveConsumer() {
+  return activeConsumer;
 }
-function getOwnDefinition(type, field) {
-  return type.hasOwnProperty(field) && type[field] || null;
+function isInNotificationPhase() {
+  return inNotificationPhase;
 }
-function getInheritedInjectableDef(type) {
-  const def = type?.[NG_PROV_DEF] ?? null;
-  if (def) {
-    return def;
+var REACTIVE_NODE = {
+  version: 0,
+  lastCleanEpoch: 0,
+  dirty: false,
+  producers: void 0,
+  producersTail: void 0,
+  consumers: void 0,
+  consumersTail: void 0,
+  recomputing: false,
+  consumerAllowSignalWrites: false,
+  consumerIsAlwaysLive: false,
+  kind: "unknown",
+  producerMustRecompute: () => false,
+  producerRecomputeValue: () => {
+  },
+  consumerMarkedDirty: () => {
+  },
+  consumerOnSignalRead: () => {
+  }
+};
+function producerAccessed(node) {
+  if (inNotificationPhase) {
+    throw new Error(typeof ngDevMode !== "undefined" && ngDevMode ? `Assertion error: signal read during notification phase` : "");
+  }
+  if (activeConsumer === null) {
+    return;
+  }
+  activeConsumer.consumerOnSignalRead(node);
+  const prevProducerLink = activeConsumer.producersTail;
+  if (prevProducerLink !== void 0 && prevProducerLink.producer === node) {
+    return;
+  }
+  let nextProducerLink = void 0;
+  const isRecomputing = activeConsumer.recomputing;
+  if (isRecomputing) {
+    nextProducerLink = prevProducerLink !== void 0 ? prevProducerLink.nextProducer : activeConsumer.producers;
+    if (nextProducerLink !== void 0 && nextProducerLink.producer === node) {
+      activeConsumer.producersTail = nextProducerLink;
+      nextProducerLink.lastReadVersion = node.version;
+      nextProducerLink.knownValidAtEpoch = epoch;
+      return;
+    }
+  }
+  const prevConsumerLink = node.consumersTail;
+  if (prevConsumerLink !== void 0 && prevConsumerLink.consumer === activeConsumer && (!isRecomputing || prevConsumerLink.knownValidAtEpoch === epoch)) {
+    return;
+  }
+  const isLive = consumerIsLive(activeConsumer);
+  const newLink = {
+    producer: node,
+    consumer: activeConsumer,
+    // instead of eagerly destroying the previous link, we delay until we've finished recomputing
+    // the producers list, so that we can destroy all of the old links at once.
+    nextProducer: nextProducerLink,
+    // Don't set prevConsumer here — it's only meaningful when the link is part of
+    // the producer's consumer list. producerAddLiveConsumer sets it correctly when
+    // the link is actually inserted. Setting it eagerly would create a dangling
+    // reference into the consumer list that prevents GC of removed entries.
+    prevConsumer: void 0,
+    knownValidAtEpoch: epoch,
+    lastReadVersion: node.version,
+    nextConsumer: void 0
+  };
+  activeConsumer.producersTail = newLink;
+  if (prevProducerLink !== void 0) {
+    prevProducerLink.nextProducer = newLink;
   } else {
-    return null;
+    activeConsumer.producers = newLink;
+  }
+  if (isLive) {
+    producerAddLiveConsumer(node, newLink);
   }
 }
-function getInjectorDef(type) {
-  return type && type.hasOwnProperty(NG_INJ_DEF) ? type[NG_INJ_DEF] : null;
+function producerIncrementEpoch() {
+  epoch++;
 }
-var NG_PROV_DEF = getClosureSafeProperty({ ɵprov: getClosureSafeProperty });
-var NG_INJ_DEF = getClosureSafeProperty({ ɵinj: getClosureSafeProperty });
-
-// src/import/di/injection_token.ts
-var InjectionToken = class {
-  /**
-   * @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) {
-    this._desc = _desc;
-    this.ɵprov = void 0;
-    if (typeof options === "number") {
-    } else if (options !== void 0) {
-      this.ɵprov = ɵɵdefineInjectable({
-        token: this,
-        providedIn: options.providedIn || "root",
-        factory: options.factory
-      });
-    }
+function producerUpdateValueVersion(node) {
+  if (consumerIsLive(node) && !node.dirty) {
+    return;
   }
-  /** @internal */
-  ngMetadataName = "InjectionToken";
-  ɵprov;
-  /**
-   * @internal
-   */
-  get multi() {
-    return this;
+  if (!node.dirty && node.lastCleanEpoch === epoch) {
+    return;
   }
-  toString() {
-    return `InjectionToken ${this._desc}`;
+  if (!node.producerMustRecompute(node) && !consumerPollProducersForChange(node)) {
+    producerMarkClean(node);
+    return;
   }
-};
-
-// src/import/di/initializer_token.ts
-var ENVIRONMENT_INITIALIZER = new InjectionToken("");
-
-// src/import/di/interface/injector.ts
-var DecoratorFlags = /* @__PURE__ */ ((DecoratorFlags2) => {
-  DecoratorFlags2[DecoratorFlags2["Inject"] = -1] = "Inject";
-  return DecoratorFlags2;
-})(DecoratorFlags || {});
-var InternalInjectFlags = /* @__PURE__ */ ((InternalInjectFlags2) => {
-  InternalInjectFlags2[InternalInjectFlags2["Default"] = 0] = "Default";
-  InternalInjectFlags2[InternalInjectFlags2["Host"] = 1] = "Host";
-  InternalInjectFlags2[InternalInjectFlags2["Self"] = 2] = "Self";
-  InternalInjectFlags2[InternalInjectFlags2["SkipSelf"] = 4] = "SkipSelf";
-  InternalInjectFlags2[InternalInjectFlags2["Optional"] = 8] = "Optional";
-  InternalInjectFlags2[InternalInjectFlags2["ForPipe"] = 16] = "ForPipe";
-  return InternalInjectFlags2;
-})(InternalInjectFlags || {});
-
-// src/import/di/inject_switch.ts
-var _injectImplementation;
-function getInjectImplementation() {
-  return _injectImplementation;
-}
-function setInjectImplementation(impl) {
-  const previous = _injectImplementation;
-  _injectImplementation = impl;
-  return previous;
+  node.producerRecomputeValue(node);
+  producerMarkClean(node);
 }
-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;
+function producerNotifyConsumers(node) {
+  if (node.consumers === void 0) {
+    return;
+  }
+  const prev = inNotificationPhase;
+  inNotificationPhase = true;
+  try {
+    for (let link = node.consumers; link !== void 0; link = link.nextConsumer) {
+      const consumer = link.consumer;
+      if (!consumer.dirty) {
+        consumerMarkDirty(consumer);
+      }
+    }
+  } finally {
+    inNotificationPhase = prev;
   }
-  if (flags & 8 /* Optional */) return null;
-  if (notFoundValue !== void 0) return notFoundValue;
-  throwProviderNotFoundError(token, "Injector");
 }
-
-// src/primitives/di/src/injector.ts
-var _currentInjector = void 0;
-function getCurrentInjector() {
-  return _currentInjector;
+function producerUpdatesAllowed() {
+  return activeConsumer?.consumerAllowSignalWrites !== false;
 }
-function setCurrentInjector(injector) {
-  const former = _currentInjector;
-  _currentInjector = injector;
-  return former;
+function consumerMarkDirty(node) {
+  node.dirty = true;
+  producerNotifyConsumers(node);
+  node.consumerMarkedDirty?.(node);
 }
-
-// src/primitives/di/src/not_found.ts
-var NOT_FOUND = Symbol("NotFound");
-function isNotFound(e) {
-  return e === NOT_FOUND || e?.name === "ɵNotFound";
+function producerMarkClean(node) {
+  node.dirty = false;
+  node.lastCleanEpoch = epoch;
 }
-
-// src/import/di/injector_compatibility.ts
-var _THROW_IF_NOT_FOUND = {};
-var THROW_IF_NOT_FOUND = _THROW_IF_NOT_FOUND;
-var DI_DECORATOR_FLAG = "__NG_DI_FLAG__";
-var RetrievingInjector = class {
-  constructor(injector) {
-    this.injector = injector;
-  }
-  retrieve(token, options) {
-    const flags = convertToBitFlags(options) || 0 /* Default */;
-    try {
-      return this.injector.get(
-        token,
-        // When a dependency is requested with an optional flag, DI returns null as the default value.
-        flags & 8 /* Optional */ ? null : THROW_IF_NOT_FOUND,
-        flags
-      );
-    } catch (e) {
-      if (isNotFound(e)) {
-        return e;
-      }
-      throw e;
-    }
-  }
-};
-var NG_TEMP_TOKEN_PATH = "ngTempTokenPath";
-var NEW_LINE = /\n/gm;
-var NO_NEW_LINE = "ɵ";
-var SOURCE = "__source";
-function injectInjectorOnly(token, flags = 0 /* Default */) {
-  const currentInjector = getCurrentInjector();
-  if (currentInjector === void 0) {
-    throw new RuntimeError(-203 /* MISSING_INJECTION_CONTEXT */, void 0);
-  } else if (currentInjector === null) {
-    return injectRootLimpMode(token, void 0, flags);
-  } else {
-    const options = convertToInjectOptions(flags);
-    const value = currentInjector.retrieve(token, options);
-    if (isNotFound(value)) {
-      if (options.optional) {
-        return null;
-      }
-      throw value;
+function consumerBeforeComputation(node) {
+  if (node) resetConsumerBeforeComputation(node);
+  return setActiveConsumer(node);
+}
+function resetConsumerBeforeComputation(node) {
+  if (node.producersTail?.knownValidAtEpoch === epoch) {
+    let producer = node.producers;
+    while (producer !== void 0) {
+      producer.knownValidAtEpoch = null;
+      producer = producer.nextProducer;
     }
-    return value;
   }
+  node.producersTail = void 0;
+  node.recomputing = true;
 }
-function ɵɵinject(token, flags = 0 /* Default */) {
-  return (getInjectImplementation() || injectInjectorOnly)(resolveForwardRef(token), flags);
-}
-function ɵɵinvalidFactoryDep(index) {
-  throw new RuntimeError(202 /* INVALID_FACTORY_DEPENDENCY */, void 0);
-}
-function inject2(token, options) {
-  return ɵɵinject(token, convertToBitFlags(options));
+function consumerAfterComputation(node, prevConsumer) {
+  setActiveConsumer(prevConsumer);
+  if (node) finalizeConsumerAfterComputation(node);
 }
-function convertToBitFlags(flags) {
-  if (typeof flags === "undefined" || typeof flags === "number") {
-    return flags;
+function finalizeConsumerAfterComputation(node) {
+  node.recomputing = false;
+  const producersTail = node.producersTail;
+  let toRemove = producersTail !== void 0 ? producersTail.nextProducer : node.producers;
+  if (toRemove !== void 0) {
+    if (consumerIsLive(node)) {
+      do {
+        toRemove = producerRemoveLiveConsumerLink(toRemove);
+      } while (toRemove !== void 0);
+    }
+    if (producersTail !== void 0) {
+      producersTail.nextProducer = void 0;
+    } else {
+      node.producers = void 0;
+    }
   }
-  return 0 /* Default */ | // comment to force a line break in the formatter
-  (flags.optional && 8 /* Optional */) | 0 | (flags.self && 2 /* Self */) | (flags.skipSelf && 4 /* SkipSelf */);
-}
-function convertToInjectOptions(flags) {
-  return {
-    optional: !!(flags & 8 /* Optional */),
-    host: !!(flags & 1 /* Host */),
-    self: !!(flags & 2 /* Self */),
-    skipSelf: !!(flags & 4 /* SkipSelf */)
-  };
 }
-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 /* INVALID_DIFFER_INPUT */, void 0);
-      }
-      let type = void 0;
-      let flags = 0 /* Default */;
-      for (let j = 0; j < arg.length; j++) {
-        const meta = arg[j];
-        const flag = getInjectFlag(meta);
-        if (typeof flag === "number") {
-          if (flag === -1 /* Inject */) {
-            type = meta.token;
-          } else {
-            flags |= flag;
-          }
-        } else {
-          type = meta;
-        }
-      }
-      args.push(ɵɵinject(type, flags));
-    } else {
-      args.push(ɵɵinject(arg));
+function consumerPollProducersForChange(node) {
+  for (let link = node.producers; link !== void 0; link = link.nextProducer) {
+    const producer = link.producer;
+    const seenVersion = link.lastReadVersion;
+    if (seenVersion !== producer.version) {
+      return true;
+    }
+    producerUpdateValueVersion(producer);
+    if (seenVersion !== producer.version) {
+      return true;
     }
   }
-  return args;
+  return false;
 }
-function attachInjectFlag(decorator, flag) {
-  decorator[DI_DECORATOR_FLAG] = flag;
-  decorator.prototype[DI_DECORATOR_FLAG] = flag;
-  return decorator;
+function consumerDestroy(node) {
+  if (consumerIsLive(node)) {
+    let link = node.producers;
+    while (link !== void 0) {
+      link = producerRemoveLiveConsumerLink(link);
+    }
+  }
+  node.producers = void 0;
+  node.producersTail = void 0;
+  node.consumers = void 0;
+  node.consumersTail = void 0;
 }
-function getInjectFlag(token) {
-  return token[DI_DECORATOR_FLAG];
+function producerAddLiveConsumer(node, link) {
+  const consumersTail = node.consumersTail;
+  const wasLive = consumerIsLive(node);
+  if (consumersTail !== void 0) {
+    link.nextConsumer = consumersTail.nextConsumer;
+    consumersTail.nextConsumer = link;
+  } else {
+    link.nextConsumer = void 0;
+    node.consumers = link;
+  }
+  link.prevConsumer = consumersTail;
+  node.consumersTail = link;
+  if (!wasLive) {
+    for (let link2 = node.producers; link2 !== void 0; link2 = link2.nextProducer) {
+      producerAddLiveConsumer(link2.producer, link2);
+    }
+  }
 }
-function formatError(text, obj, injectorErrorName, source = null) {
-  text = text && text.charAt(0) === "\n" && text.charAt(1) == NO_NEW_LINE ? text.slice(2) : text;
-  let context = stringify(obj);
-  if (Array.isArray(obj)) {
-    context = obj.map(stringify).join(" -> ");
-  } else if (typeof obj === "object") {
-    const parts = [];
-    for (const key in obj) {
-      if (obj.hasOwnProperty(key)) {
-        const value = obj[key];
-        parts.push(key + ":" + (typeof value === "string" ? JSON.stringify(value) : stringify(value)));
+function producerRemoveLiveConsumerLink(link) {
+  const producer = link.producer;
+  const nextProducer = link.nextProducer;
+  const nextConsumer = link.nextConsumer;
+  const prevConsumer = link.prevConsumer;
+  link.nextConsumer = void 0;
+  link.prevConsumer = void 0;
+  if (nextConsumer !== void 0) {
+    nextConsumer.prevConsumer = prevConsumer;
+  } else {
+    producer.consumersTail = prevConsumer;
+  }
+  if (prevConsumer !== void 0) {
+    prevConsumer.nextConsumer = nextConsumer;
+  } else {
+    producer.consumers = nextConsumer;
+    if (!consumerIsLive(producer)) {
+      let producerLink = producer.producers;
+      while (producerLink !== void 0) {
+        producerLink = producerRemoveLiveConsumerLink(producerLink);
       }
     }
-    context = `{${parts.join(", ")}}`;
   }
-  return `${injectorErrorName}${source ? "(" + source + ")" : ""}[${context}]: ${text.replace(NEW_LINE, "\n  ")}`;
+  return nextProducer;
+}
+function consumerIsLive(node) {
+  return node.consumerIsAlwaysLive || node.consumers !== void 0;
+}
+function runPostProducerCreatedFn(node) {
+  postProducerCreatedFn?.(node);
 }
 
-// src/import/di/injector_token.ts
-var INJECTOR = new InjectionToken(
-  "",
-  // Disable tslint because this is const enum which gets inlined not top level prop access.
-  // tslint:disable-next-line: no-toplevel-property-access
-  -1 /* Injector */
-  // Special value used by Ivy to identify `Injector`.
-);
-
-// src/import/di/internal_tokens.ts
-var INJECTOR_DEF_TYPES = new InjectionToken("");
-
-// src/import/di/null_injector.ts
-var NullInjector = class {
-  get(token, notFoundValue = THROW_IF_NOT_FOUND) {
-    if (notFoundValue === THROW_IF_NOT_FOUND) {
-      const message = "";
-      const error = createRuntimeError(message, -201 /* PROVIDER_NOT_FOUND */);
-      error.name = "ɵNotFound";
-      throw error;
+// src/primitives/signals/src/formatter.ts
+var formatter = {
+  /**
+   *  If the function returns `null`, the formatter is not used for this reference
+   */
+  header: (sig, config) => {
+    if (!isSignal(sig) || config?.ngSkipFormatting) return null;
+    let value;
+    try {
+      value = sig();
+    } catch (e) {
+      return ["span", `Signal(⚠️ Error)${e.message ? `: ${e.message}` : ""}`];
+    }
+    const kind = "computation" in sig[SIGNAL] ? "Computed" : "Signal";
+    const isPrimitive = value === null || !Array.isArray(value) && typeof value !== "object";
+    return [
+      "span",
+      {},
+      ["span", {}, `${kind}(`],
+      (() => {
+        if (isSignal(value)) {
+          return formatter.header(value, config);
+        } else if (isPrimitive && value !== void 0 && typeof value !== "function") {
+          return ["object", { object: value }];
+        } else {
+          return prettifyPreview(value);
+        }
+      })(),
+      ["span", {}, `)`]
+    ];
+  },
+  hasBody: (sig, config) => {
+    if (!isSignal(sig)) return false;
+    try {
+      sig();
+    } catch {
+      return false;
     }
-    return notFoundValue;
+    return !config?.ngSkipFormatting;
+  },
+  body: (sig, config) => {
+    const color = "var(--sys-color-primary)";
+    return [
+      "div",
+      { style: `background: #FFFFFF10; padding-left: 4px; padding-top: 2px; padding-bottom: 2px;` },
+      ["div", { style: `color: ${color}` }, "Signal value: "],
+      ["div", { style: `padding-left: .5rem;` }, ["object", { object: sig(), config }]],
+      ["div", { style: `color: ${color}` }, "Signal function: "],
+      ["div", { style: `padding-left: .5rem;` }, ["object", { object: sig, config: { ...config, ngSkipFormatting: true } }]]
+    ];
   }
 };
-
-// src/import/di/provider_collection.ts
-var 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 prettifyPreview(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return `Array(${value.length})`;
+  if (value instanceof Element) return `<${value.tagName.toLowerCase()}>`;
+  if (value instanceof URL) return `URL`;
+  switch (typeof value) {
+    case "undefined": {
+      return "undefined";
+    }
+    case "function": {
+      if ("prototype" in value) {
+        return "class";
+      } else {
+        return "() => {…}";
+      }
+    }
+    case "object": {
+      if (value.constructor.name === "Object") {
+        return "{…}";
+      } else {
+        return `${value.constructor.name} {}`;
+      }
+    }
+    default: {
+      return ["object", { object: value, config: { ngSkipFormatting: true } }];
+    }
+  }
 }
-function isFactoryProvider(value) {
-  return !!(value && value.useFactory);
+function isSignal(value) {
+  return value[SIGNAL] !== void 0;
 }
-function isTypeProvider(value) {
-  return typeof value === "function";
+function installDevToolsSignalFormatter() {
+  globalThis.devtoolsFormatters ??= [];
+  if (!globalThis.devtoolsFormatters.some((f) => f === formatter)) {
+    globalThis.devtoolsFormatters.push(formatter);
+  }
 }
 
-// src/import/di/scope.ts
-var INJECTOR_SCOPE = new InjectionToken("");
+// src/primitives/signals/src/equality.ts
+function defaultEquals(a, b) {
+  return Object.is(a, b);
+}
 
-// src/import/di/r3_injector.ts
-var NOT_YET = {};
-var CIRCULAR = {};
-var NULL_INJECTOR = void 0;
-function getNullInjector() {
-  if (NULL_INJECTOR === void 0) {
-    NULL_INJECTOR = new NullInjector();
+// src/primitives/signals/src/computed.ts
+function createComputed(computation, equal) {
+  const node = Object.create(COMPUTED_NODE);
+  node.computation = computation;
+  if (equal !== void 0) {
+    node.equal = equal;
   }
-  return NULL_INJECTOR;
-}
-var EnvironmentInjector = class {
-};
-var R3Injector = class extends EnvironmentInjector {
-  constructor(providers, parent, source, scopes) {
-    super();
-    this.parent = parent;
-    this.source = source;
-    this.scopes = scopes;
-    forEachSingleProvider(providers, (provider) => this.processProvider(provider));
-    this.records.set(INJECTOR, 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);
+  const computed2 = () => {
+    producerUpdateValueVersion(node);
+    producerAccessed(node);
+    if (node.value === ERRORED) {
+      throw node.error;
     }
-    this.injectorDefTypes = new Set(this.get(INJECTOR_DEF_TYPES, EMPTY_ARRAY, { self: true }));
-  }
-  /**
-   * 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.
-   */
-  records = /* @__PURE__ */ new Map();
-  /**
-   * Set of values instantiated by this injector which contain `ngOnDestroy` lifecycle hooks.
-   */
-  _ngOnDestroyHooks = /* @__PURE__ */ new Set();
-  _onDestroyHooks = [];
-  /**
-   * Flag indicating that this injector was previously destroyed.
-   */
-  get destroyed() {
-    return this._destroyed;
+    return node.value;
+  };
+  computed2[SIGNAL] = node;
+  if (typeof ngDevMode !== "undefined" && ngDevMode) {
+    computed2.toString = () => `[Computed${node.debugName ? " (" + node.debugName + ")" : ""}: ${String(node.value)}]`;
   }
-  _destroyed = false;
-  injectorDefTypes;
-  retrieve(token, options) {
-    const flags = convertToBitFlags(options) || 0 /* Default */;
-    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 (isNotFound(e)) {
-        return e;
-      }
-      throw e;
+  runPostProducerCreatedFn(node);
+  return computed2;
+}
+var UNSET = /* @__PURE__ */ Symbol("UNSET");
+var COMPUTING = /* @__PURE__ */ Symbol("COMPUTING");
+var ERRORED = /* @__PURE__ */ Symbol("ERRORED");
+var COMPUTED_NODE = /* @__PURE__ */ (() => ({
+  ...REACTIVE_NODE,
+  value: UNSET,
+  dirty: true,
+  error: null,
+  equal: defaultEquals,
+  kind: "computed",
+  producerMustRecompute(node) {
+    return node.value === UNSET || node.value === COMPUTING;
+  },
+  producerRecomputeValue(node) {
+    if (node.value === COMPUTING) {
+      throw new Error(typeof ngDevMode !== "undefined" && ngDevMode ? "Detected cycle in computations." : "");
     }
-  }
-  /**
-   * 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 oldValue = node.value;
+    node.value = COMPUTING;
+    const prevConsumer = consumerBeforeComputation(node);
+    let newValue;
+    let wasEqual = false;
     try {
-      for (const service of this._ngOnDestroyHooks) {
-        service.ngOnDestroy();
-      }
-      const onDestroyHooks = this._onDestroyHooks;
-      this._onDestroyHooks = [];
-      for (const hook of onDestroyHooks) {
-        hook();
-      }
+      newValue = node.computation();
+      setActiveConsumer(null);
+      wasEqual = oldValue !== UNSET && oldValue !== ERRORED && newValue !== ERRORED && node.equal(oldValue, newValue);
+    } catch (err) {
+      newValue = ERRORED;
+      node.error = err;
     } finally {
-      this.records.clear();
-      this._ngOnDestroyHooks.clear();
-      this.injectorDefTypes.clear();
-    }
-  }
-  onDestroy(callback) {
-    assertNotDestroyed(this);
-    this._onDestroyHooks.push(callback);
-    return () => this.removeOnDestroy(callback);
-  }
-  runInContext(fn) {
-    assertNotDestroyed(this);
-    const previousInjector = setCurrentInjector(this);
-    const previousInjectImplementation = setInjectImplementation(void 0);
-    if (false) {
+      consumerAfterComputation(node, prevConsumer);
     }
-    try {
-      return fn();
-    } finally {
-      setCurrentInjector(previousInjector);
-      setInjectImplementation(previousInjectImplementation);
+    if (wasEqual) {
+      node.value = oldValue;
+      return;
     }
+    node.value = newValue;
+    node.version++;
   }
-  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);
-    if (false) {
-    }
-    const previousInjector = setCurrentInjector(this);
-    const previousInjectImplementation = setInjectImplementation(void 0);
-    try {
-      if (!(flags & 4 /* SkipSelf */)) {
-        let record = this.records.get(token);
-        if (record === void 0) {
-          const def = couldBeInjectableType(token) && getInjectableDef(token);
-          if (def && this.injectableDefInScope(def)) {
-            if (false) {
-            }
-            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 /* Self */) ? this.parent : getNullInjector();
-      notFoundValue = flags & 8 /* Optional */ && notFoundValue === THROW_IF_NOT_FOUND ? null : notFoundValue;
-      return nextInjector.get(token, notFoundValue);
-    } catch (error) {
-      const errorCode = getRuntimeErrorCode(error);
-      if (errorCode === -200 /* CYCLIC_DI_DEPENDENCY */ || errorCode === -201 /* PROVIDER_NOT_FOUND */) {
-        if (false) {
-        } else {
-          throw new RuntimeError(errorCode, null);
-        }
-      } else {
-        throw error;
-      }
-    } finally {
-      setInjectImplementation(previousInjectImplementation);
-      setCurrentInjector(previousInjector);
-    }
+}))();
+
+// src/primitives/signals/src/errors.ts
+function defaultThrowError() {
+  throw new Error();
+}
+var throwInvalidWriteToSignalErrorFn = defaultThrowError;
+function throwInvalidWriteToSignalError(node) {
+  throwInvalidWriteToSignalErrorFn(node);
+}
+
+// src/primitives/signals/src/signal.ts
+var postSignalSetFn = null;
+function createSignal(initialValue, equal) {
+  const node = Object.create(SIGNAL_NODE);
+  node.value = initialValue;
+  if (equal !== void 0) {
+    node.equal = equal;
   }
-  /** @internal */
-  resolveInjectorInitializers() {
-    const previousInjector = setCurrentInjector(this);
-    const previousInjectImplementation = setInjectImplementation(void 0);
-    if (false) {
-    }
-    try {
-      const initializers = this.get(ENVIRONMENT_INITIALIZER, EMPTY_ARRAY, { self: true });
-      if (false) {
-      }
-      for (const initializer of initializers) {
-        initializer();
-      }
-    } finally {
-      setCurrentInjector(previousInjector);
-      setInjectImplementation(previousInjectImplementation);
-    }
+  const getter = () => signalGetFn(node);
+  getter[SIGNAL] = node;
+  if (typeof ngDevMode !== "undefined" && ngDevMode) {
+    getter.toString = () => `[Signal${node.debugName ? " (" + node.debugName + ")" : ""}: ${String(node.value)}]`;
   }
-  toString() {
-    const tokens = [];
-    const records = this.records;
-    for (const token of records.keys()) {
-      tokens.push(stringify(token));
-    }
-    return `R3Injector[${tokens.join(", ")}]`;
+  runPostProducerCreatedFn(node);
+  const set = (newValue) => signalSetFn(node, newValue);
+  const update = (updateFn) => signalUpdateFn(node, updateFn);
+  return [getter, set, update];
+}
+function signalGetFn(node) {
+  producerAccessed(node);
+  return node.value;
+}
+function signalSetFn(node, newValue) {
+  if (!producerUpdatesAllowed()) {
+    throwInvalidWriteToSignalError(node);
   }
-  /**
-   * 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 (false) {
-    }
-    if (!isTypeProvider(provider) && provider.multi === true) {
-      let multiRecord = this.records.get(token);
-      if (multiRecord) {
-        if (false) {
-        }
-      } 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 (false) {
-      }
-    }
-    this.records.set(token, record);
+  if (!node.equal(node.value, newValue)) {
+    node.value = newValue;
+    signalValueChanged(node);
   }
-  hydrate(token, record, flags) {
-    try {
-      if (record.value === CIRCULAR) {
-        throw cyclicDependencyError(stringify(token));
-      } else if (record.value === NOT_YET) {
-        record.value = CIRCULAR;
-        if (false) {
-        } 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 {
-    }
+}
+function signalUpdateFn(node, updater) {
+  if (!producerUpdatesAllowed()) {
+    throwInvalidWriteToSignalError(node);
   }
-  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);
-    }
+  signalSetFn(node, updater(node.value));
+}
+var SIGNAL_NODE = /* @__PURE__ */ (() => ({
+  ...REACTIVE_NODE,
+  equal: defaultEquals,
+  value: void 0,
+  kind: "signal"
+}))();
+function signalValueChanged(node) {
+  node.version++;
+  producerIncrementEpoch();
+  producerNotifyConsumers(node);
+  postSignalSetFn?.(node);
+}
+
+// src/primitives/signals/src/linked_signal.ts
+function createLinkedSignal(sourceFn, computationFn, equalityFn) {
+  const node = Object.create(LINKED_SIGNAL_NODE);
+  node.source = sourceFn;
+  node.computation = computationFn;
+  if (equalityFn != void 0) {
+    node.equal = equalityFn;
   }
-  removeOnDestroy(callback) {
-    const destroyCBIdx = this._onDestroyHooks.indexOf(callback);
-    if (destroyCBIdx !== -1) {
-      this._onDestroyHooks.splice(destroyCBIdx, 1);
+  const linkedSignalGetter = () => {
+    producerUpdateValueVersion(node);
+    producerAccessed(node);
+    if (node.value === ERRORED) {
+      throw node.error;
     }
+    return node.value;
+  };
+  const getter = linkedSignalGetter;
+  getter[SIGNAL] = node;
+  if (typeof ngDevMode !== "undefined" && ngDevMode) {
+    getter.toString = () => `[LinkedSignal${node.debugName ? " (" + node.debugName + ")" : ""}: ${String(node.value)}]`;
   }
-};
-function injectableDefOrInjectorDefFactory(token) {
-  const injectableDef = getInjectableDef(token);
-  const factory = injectableDef !== null ? injectableDef.factory : getFactoryDef(token);
-  if (factory !== null) {
-    return factory;
+  runPostProducerCreatedFn(node);
+  return getter;
+}
+function linkedSignalSetFn(node, newValue) {
+  producerUpdateValueVersion(node);
+  signalSetFn(node, newValue);
+  producerMarkClean(node);
+}
+function linkedSignalUpdateFn(node, updater) {
+  producerUpdateValueVersion(node);
+  if (node.value === ERRORED) {
+    throw node.error;
   }
-  if (token instanceof InjectionToken) {
-    throw new RuntimeError(204 /* INVALID_INJECTION_TOKEN */, void 0);
+  signalUpdateFn(node, updater);
+  producerMarkClean(node);
+}
+var LINKED_SIGNAL_NODE = /* @__PURE__ */ (() => ({
+  ...REACTIVE_NODE,
+  value: UNSET,
+  dirty: true,
+  error: null,
+  equal: defaultEquals,
+  kind: "linkedSignal",
+  producerMustRecompute(node) {
+    return node.value === UNSET || node.value === COMPUTING;
+  },
+  producerRecomputeValue(node) {
+    if (node.value === COMPUTING) {
+      throw new Error(typeof ngDevMode !== "undefined" && ngDevMode ? "Detected cycle in computations." : "");
+    }
+    const oldValue = node.value;
+    node.value = COMPUTING;
+    const prevConsumer = consumerBeforeComputation(node);
+    let newValue;
+    let wasEqual = false;
+    try {
+      const newSourceValue = node.source();
+      const oldValueValid = oldValue !== UNSET && oldValue !== ERRORED;
+      const prev = oldValueValid ? {
+        source: node.sourceValue,
+        value: oldValue
+      } : void 0;
+      newValue = node.computation(newSourceValue, prev);
+      node.sourceValue = newSourceValue;
+      setActiveConsumer(null);
+      wasEqual = oldValueValid && newValue !== ERRORED && node.equal(oldValue, newValue);
+    } catch (err) {
+      newValue = ERRORED;
+      node.error = err;
+    } finally {
+      consumerAfterComputation(node, prevConsumer);
+    }
+    if (wasEqual) {
+      node.value = oldValue;
+      return;
+    }
+    node.value = newValue;
+    node.version++;
   }
-  if (token instanceof Function) {
-    return getUndecoratedInjectableFactory(token);
+}))();
+
+// src/primitives/signals/src/untracked.ts
+function untracked(nonReactiveReadsFn) {
+  const prevConsumer = setActiveConsumer(null);
+  try {
+    return nonReactiveReadsFn();
+  } finally {
+    setActiveConsumer(prevConsumer);
   }
-  throw new RuntimeError(204 /* INVALID_INJECTION_TOKEN */, void 0);
 }
-function getUndecoratedInjectableFactory(token) {
-  const paramLength = token.length;
-  if (paramLength > 0) {
-    throw new RuntimeError(204 /* INVALID_INJECTION_TOKEN */, void 0);
+
+// src/primitives/signals/src/effect.ts
+var BASE_EFFECT_NODE = /* @__PURE__ */ (() => ({
+  ...REACTIVE_NODE,
+  consumerIsAlwaysLive: true,
+  consumerAllowSignalWrites: true,
+  dirty: true,
+  kind: "effect"
+}))();
+function runEffect(node) {
+  node.dirty = false;
+  if (node.version > 0 && !consumerPollProducersForChange(node)) {
+    return;
   }
-  const inheritedInjectableDef = getInheritedInjectableDef(token);
-  if (inheritedInjectableDef !== null) {
-    return () => inheritedInjectableDef.factory(token);
-  } else {
-    return () => new token();
+  node.version++;
+  const prevNode = consumerBeforeComputation(node);
+  try {
+    node.cleanup();
+    node.fn();
+  } finally {
+    consumerAfterComputation(node, prevNode);
   }
 }
-function providerToRecord(provider) {
-  if (isValueProvider(provider)) {
-    return makeRecord(void 0, provider.useValue);
-  } else {
-    const factory = providerToFactory(provider);
-    return makeRecord(factory, NOT_YET);
-  }
+
+// src/primitives/signals/index.ts
+if (typeof ngDevMode === "undefined" || ngDevMode) {
+  installDevToolsSignalFormatter();
 }
-function providerToFactory(provider, ngModuleType, providers) {
-  let factory = void 0;
-  if (false) {
-  }
-  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) => ɵɵinject(resolveForwardRef(provider.useExisting), flags !== void 0 && flags & 8 /* Optional */ ? 8 /* Optional */ : void 0);
-    } else {
-      const classRef = resolveForwardRef(provider && (provider.useClass || provider.provide));
-      if (false) {
-      }
-      if (hasDeps(provider)) {
-        factory = () => new classRef(...injectArgs(provider.deps));
-      } else {
-        return getFactoryDef(classRef) || injectableDefOrInjectorDefFactory(classRef);
-      }
-    }
+
+// src/import/util/assert.ts
+function assertLessThan(actual, expected, msg) {
+  if (!(actual < expected)) {
+    throwError(msg, actual, expected, "<");
   }
-  return factory;
 }
-function assertNotDestroyed(injector) {
-  if (injector.destroyed) {
-    throw new RuntimeError(205 /* INJECTOR_ALREADY_DESTROYED */, void 0);
+function assertDefined(actual, msg) {
+  if (actual == null) {
+    throwError(msg, actual, null, "!=");
   }
 }
-function makeRecord(factory, value, multi = false) {
+function throwError(msg, actual, expected, comparison) {
+  throw new Error(`ASSERTION ERROR: ${msg}` + (comparison == null ? "" : ` [Expected=> ${expected} ${comparison} ${actual} <=Actual]`));
+}
+
+// src/import/di/interface/defs.ts
+function ɵɵdefineInjectable(opts) {
   return {
-    factory,
-    value,
-    multi: multi ? [] : void 0
+    token: opts.token,
+    providedIn: opts.providedIn || null,
+    factory: opts.factory,
+    value: void 0
   };
 }
-function hasDeps(value) {
-  return !!value.deps;
+function ɵɵdefineInjector(options) {
+  return { providers: options.providers || [], imports: options.imports || [] };
 }
-function hasOnDestroy(value) {
-  return value !== null && typeof value === "object" && typeof value.ngOnDestroy === "function";
+function getInjectableDef(type) {
+  return getOwnDefinition(type, NG_PROV_DEF) || { token: type, factory: () => new type(), ...type.injectOptions };
 }
-function couldBeInjectableType(value) {
-  return typeof value === "function" || typeof value === "object" && value.ngMetadataName === "InjectionToken";
+function isInjectable(type) {
+  return getInjectableDef(type) !== null;
 }
-function forEachSingleProvider(providers, fn) {
-  for (const provider of providers) {
-    if (Array.isArray(provider)) {
-      forEachSingleProvider(provider, fn);
-    } else if (provider && isEnvironmentProviders(provider)) {
-      forEachSingleProvider(provider.ɵproviders, fn);
-    } else {
-      fn(provider);
-    }
+function getOwnDefinition(type, field) {
+  return type.hasOwnProperty(field) && type[field] || null;
+}
+function getInheritedInjectableDef(type) {
+  const def = type?.[NG_PROV_DEF] ?? 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;
   }
 }
-
-// src/import/util/closure.ts
-function noSideEffects(fn) {
-  return { toString: fn }.toString();
+function getInjectorDef(type) {
+  return type && type.hasOwnProperty(NG_INJ_DEF) ? type[NG_INJ_DEF] : null;
 }
+var NG_PROV_DEF = getClosureSafeProperty({ ɵprov: getClosureSafeProperty });
+var NG_INJ_DEF = getClosureSafeProperty({ ɵinj: getClosureSafeProperty });
 
-// src/import/util/decorators.ts
-function makeMetadataCtor(props) {
-  return function ctor(...args) {
-    if (props) {
-      const values = props(...args);
-      for (const propName in values) {
-        this[propName] = values[propName];
-      }
+// src/import/di/injection_token.ts
+var InjectionToken = class {
+  constructor(_desc, options) {
+    this._desc = _desc;
+    this.ɵprov = void 0;
+    if (typeof options === "number") {
+      (typeof ngDevMode === "undefined" || ngDevMode) && assertLessThan(options, 0, "Only negative numbers are supported here");
+    } else if (options !== void 0) {
+      this.ɵprov = ɵɵdefineInjectable({
+        token: this,
+        providedIn: options.providedIn || "root",
+        factory: options.factory
+      });
     }
-  };
+  }
+  /** @internal */
+  ngMetadataName = "InjectionToken";
+  ɵprov;
+  /**
+   * @internal
+   */
+  get multi() {
+    return this;
+  }
+  toString() {
+    return `InjectionToken ${this._desc}`;
+  }
+};
+
+// src/import/render3/debug/injector_profiler.ts
+var _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;
 }
-function makeParamDecorator(name, props, parentClass) {
-  return noSideEffects(() => {
-    const metaCtor = makeMetadataCtor(props);
-    function ParamDecoratorFactory(...args) {
-      metaCtor.apply(this, args);
-      return this;
-    }
-    if (parentClass) {
-    }
-    return ParamDecoratorFactory;
+var injectorProfilerCallbacks = [];
+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.ɵprov || eventProvider;
+  }
+  injectorProfiler({
+    type: 2 /* ProviderConfigured */,
+    context: getInjectorProfilerContext(),
+    providerRecord: { token, provider, isViewProvider }
+  });
+}
+function emitInjectorToCreateInstanceEvent(token) {
+  !ngDevMode && throwError("Injector profiler should never be called in production mode");
+  injectorProfiler({
+    type: 5 /* InjectorToCreateInstanceEvent */,
+    context: getInjectorProfilerContext(),
+    token
   });
 }
+function emitInstanceCreatedByInjectorEvent(instance) {
+  !ngDevMode && throwError("Injector profiler should never be called in production mode");
+  injectorProfiler({
+    type: 1 /* InstanceCreatedByInjector */,
+    context: getInjectorProfilerContext(),
+    instance: { value: instance }
+  });
+}
+function emitInjectEvent(token, value, flags) {
+  !ngDevMode && throwError("Injector profiler should never be called in production mode");
+  injectorProfiler({
+    type: 0 /* Inject */,
+    context: getInjectorProfilerContext(),
+    service: { token, value, flags }
+  });
+}
+function emitEffectCreatedEvent(effect2) {
+  !ngDevMode && throwError("Injector profiler should never be called in production mode");
+  injectorProfiler({
+    type: 3 /* EffectCreated */,
+    context: getInjectorProfilerContext(),
+    effect: effect2
+  });
+}
+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);
+  }
+}
 
-// src/import/di/metadata.ts
-var Inject = attachInjectFlag(
-  // Disable tslint because `DecoratorFlags` is a const enum which gets inlined.
-  makeParamDecorator("Inject", (token) => ({ token })),
-  // tslint:disable-next-line: no-toplevel-property-access
-  -1 /* Inject */
-);
-var Optional = (
-  // Disable tslint because `InternalInjectFlags` is a const enum which gets inlined.
-  // tslint:disable-next-line: no-toplevel-property-access
-  attachInjectFlag(makeParamDecorator("Optional"), 8 /* Optional */)
-);
-var Self = (
-  // Disable tslint because `InternalInjectFlags` is a const enum which gets inlined.
-  // tslint:disable-next-line: no-toplevel-property-access
-  attachInjectFlag(makeParamDecorator("Self"), 2 /* Self */)
-);
-var SkipSelf = (
-  // Disable tslint because `InternalInjectFlags` is a const enum which gets inlined.
-  // tslint:disable-next-line: no-toplevel-property-access
-  attachInjectFlag(makeParamDecorator("SkipSelf"), 4 /* SkipSelf */)
-);
+// src/import/render3/definition_factory.ts
+function getFactoryDef(type, throwNotFound) {
+  return () => new type();
+}
 
-// src/import/di/create_injector.ts
-function createInjector(defType, parent = null, additionalProviders = null, name) {
-  const injector = createInjectorWithoutInjectorInstances(defType, parent, additionalProviders, name);
-  injector.resolveInjectorInitializers();
-  return injector;
+// src/import/render3/util/stringify_utils.ts
+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);
+}
+
+// src/import/render3/errors_di.ts
+var NG_RUNTIME_ERROR_CODE = getClosureSafeProperty({ ngErrorCode: getClosureSafeProperty });
+var NG_RUNTIME_ERROR_MESSAGE = getClosureSafeProperty({ ngErrorMessage: getClosureSafeProperty });
+var NG_TOKEN_PATH = getClosureSafeProperty({ ngTokenPath: getClosureSafeProperty });
+function cyclicDependencyError(token, path) {
+  const message = ngDevMode ? `Circular dependency detected for \`${token}\`.` : "";
+  return createRuntimeError(message, -200 /* CYCLIC_DI_DEPENDENCY */, path);
+}
+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.ɵfromNgModule) {
+      throw new RuntimeError(
+        -207 /* PROVIDER_IN_WRONG_CONTEXT */,
+        `Invalid providers from 'importProvidersFrom' present in a non-environment injector. 'importProvidersFrom' can't be used for component providers.`
+      );
+    } else {
+      throw new RuntimeError(-207 /* PROVIDER_IN_WRONG_CONTEXT */, `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 /* PROVIDER_NOT_FOUND */, errorMessage);
+}
+function prependTokenToDependencyPath(error, token) {
+  error[NG_TOKEN_PATH] ??= [];
+  const currentPath = error[NG_TOKEN_PATH];
+  let pathStr;
+  if (typeof token === "object" && "multi" in token && 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 createInjectorWithoutInjectorInstances(defType, parent = null, additionalProviders = null, name, scopes = /* @__PURE__ */ new Set()) {
-  const providers = [additionalProviders || EMPTY_ARRAY];
-  name = name || (typeof defType === "object" ? void 0 : stringify(defType));
-  return new R3Injector(providers, parent || getNullInjector(), name || null, scopes);
+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}`);
 }
 
-// src/import/di/injector.ts
-var Injector = class _Injector {
-  static THROW_IF_NOT_FOUND = THROW_IF_NOT_FOUND;
-  static NULL = /* @__PURE__ */ new NullInjector();
-  static create(options, parent) {
-    if (Array.isArray(options)) {
-      return createInjector({ name: "" }, parent, options, "");
-    } else {
-      const name = options.name ?? "";
-      return createInjector({ name }, options.parent, options.providers, name);
-    }
+// src/import/render3/fields.ts
+var NG_FACTORY_DEF = getClosureSafeProperty({ ɵfac: getClosureSafeProperty });
+var NG_ENV_ID = getClosureSafeProperty({ __NG_ENV_ID__: getClosureSafeProperty });
+
+// src/import/util/array_utils.ts
+function newArray(size, value) {
+  const list = [];
+  for (let i = 0; i < size; i++) {
+    list.push(value);
   }
-  /** @nocollapse */
-  static ɵprov = (
-    /** @pureOrBreakMyCode */
-    /* @__PURE__ */ ɵɵdefineInjectable({
-      token: _Injector,
-      providedIn: "any",
-      factory: () => ɵɵinject(INJECTOR)
-    })
-  );
-  /**
-   * @internal
-   * @nocollapse
-   */
-  static __NG_ELEMENT_ID__ = -1 /* Injector */;
-};
+  return list;
+}
 
-// src/import/render3/instructions/di.ts
-function ɵɵinvalidFactory() {
-  const msg = "invalid";
-  throw new Error(msg);
+// src/import/util/empty.ts
+var EMPTY_OBJ = {};
+var EMPTY_ARRAY = [];
+if ((typeof ngDevMode === "undefined" || ngDevMode) && true) {
+  Object.freeze(EMPTY_OBJ);
+  Object.freeze(EMPTY_ARRAY);
 }
 
-// src/primitives/signals/src/graph.ts
-var activeConsumer = null;
-var inNotificationPhase = false;
-var epoch = 1;
-var postProducerCreatedFn = null;
-var SIGNAL = /* @__PURE__ */ Symbol("SIGNAL");
-function setActiveConsumer(consumer) {
-  const prev = activeConsumer;
-  activeConsumer = consumer;
-  return prev;
+// src/import/di/initializer_token.ts
+var ENVIRONMENT_INITIALIZER = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "ENVIRONMENT_INITIALIZER" : "");
+
+// src/import/di/interface/injector.ts
+var DecoratorFlags = /* @__PURE__ */ ((DecoratorFlags2) => {
+  DecoratorFlags2[DecoratorFlags2["Inject"] = -1] = "Inject";
+  return DecoratorFlags2;
+})(DecoratorFlags || {});
+var InternalInjectFlags = /* @__PURE__ */ ((InternalInjectFlags2) => {
+  InternalInjectFlags2[InternalInjectFlags2["Default"] = 0] = "Default";
+  InternalInjectFlags2[InternalInjectFlags2["Host"] = 1] = "Host";
+  InternalInjectFlags2[InternalInjectFlags2["Self"] = 2] = "Self";
+  InternalInjectFlags2[InternalInjectFlags2["SkipSelf"] = 4] = "SkipSelf";
+  InternalInjectFlags2[InternalInjectFlags2["Optional"] = 8] = "Optional";
+  InternalInjectFlags2[InternalInjectFlags2["ForPipe"] = 16] = "ForPipe";
+  return InternalInjectFlags2;
+})(InternalInjectFlags || {});
+
+// src/import/di/inject_switch.ts
+var _injectImplementation;
+function getInjectImplementation() {
+  return _injectImplementation;
 }
-function getActiveConsumer() {
-  return activeConsumer;
+function setInjectImplementation(impl) {
+  const previous = _injectImplementation;
+  _injectImplementation = impl;
+  return previous;
 }
-var REACTIVE_NODE = {
-  version: 0,
-  lastCleanEpoch: 0,
-  dirty: false,
-  producers: void 0,
-  producersTail: void 0,
-  consumers: void 0,
-  consumersTail: void 0,
-  recomputing: false,
-  consumerAllowSignalWrites: false,
-  consumerIsAlwaysLive: false,
-  kind: "unknown",
-  producerMustRecompute: () => false,
-  producerRecomputeValue: () => {
-  },
-  consumerMarkedDirty: () => {
-  },
-  consumerOnSignalRead: () => {
-  }
-};
-function producerAccessed(node) {
-  if (inNotificationPhase) {
-    throw new Error(false ? `Assertion error: signal read during notification phase` : "");
-  }
-  if (activeConsumer === null) {
-    return;
+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;
   }
-  activeConsumer.consumerOnSignalRead(node);
-  const prevProducerLink = activeConsumer.producersTail;
-  if (prevProducerLink !== void 0 && prevProducerLink.producer === node) {
-    return;
+  if (flags & 8 /* Optional */) return null;
+  if (notFoundValue !== void 0) return notFoundValue;
+  throwProviderNotFoundError(token, typeof ngDevMode !== "undefined" && ngDevMode ? "Injector" : "");
+}
+
+// src/primitives/di/src/injector.ts
+var _currentInjector = void 0;
+function getCurrentInjector() {
+  return _currentInjector;
+}
+function setCurrentInjector(injector) {
+  const former = _currentInjector;
+  _currentInjector = injector;
+  return former;
+}
+
+// src/primitives/di/src/not_found.ts
+var NOT_FOUND = Symbol("NotFound");
+function isNotFound(e) {
+  return e === NOT_FOUND || e?.name === "ɵNotFound";
+}
+
+// src/import/di/injector_compatibility.ts
+var _THROW_IF_NOT_FOUND = {};
+var THROW_IF_NOT_FOUND = _THROW_IF_NOT_FOUND;
+var DI_DECORATOR_FLAG = "__NG_DI_FLAG__";
+var RetrievingInjector = class {
+  constructor(injector) {
+    this.injector = injector;
   }
-  let nextProducerLink = void 0;
-  const isRecomputing = activeConsumer.recomputing;
-  if (isRecomputing) {
-    nextProducerLink = prevProducerLink !== void 0 ? prevProducerLink.nextProducer : activeConsumer.producers;
-    if (nextProducerLink !== void 0 && nextProducerLink.producer === node) {
-      activeConsumer.producersTail = nextProducerLink;
-      nextProducerLink.lastReadVersion = node.version;
-      return;
+  retrieve(token, options) {
+    const flags = convertToBitFlags(options) || 0 /* Default */;
+    try {
+      return this.injector.get(
+        token,
+        // When a dependency is requested with an optional flag, DI returns null as the default value.
+        flags & 8 /* Optional */ ? null : THROW_IF_NOT_FOUND,
+        flags
+      );
+    } catch (e) {
+      if (isNotFound(e)) {
+        return e;
+      }
+      throw e;
     }
   }
-  const prevConsumerLink = node.consumersTail;
-  if (prevConsumerLink !== void 0 && prevConsumerLink.consumer === activeConsumer && // However, we have to make sure that the link we've discovered isn't from a node that is incrementally rebuilding its producer list
-  (!isRecomputing || isValidLink(prevConsumerLink, activeConsumer))) {
-    return;
-  }
-  const isLive = consumerIsLive(activeConsumer);
-  const newLink = {
-    producer: node,
-    consumer: activeConsumer,
-    // instead of eagerly destroying the previous link, we delay until we've finished recomputing
-    // the producers list, so that we can destroy all of the old links at once.
-    nextProducer: nextProducerLink,
-    prevConsumer: prevConsumerLink,
-    lastReadVersion: node.version,
-    nextConsumer: void 0
-  };
-  activeConsumer.producersTail = newLink;
-  if (prevProducerLink !== void 0) {
-    prevProducerLink.nextProducer = newLink;
+};
+var NG_TEMP_TOKEN_PATH = "ngTempTokenPath";
+var SOURCE = "__source";
+function injectInjectorOnly(token, flags = 0 /* Default */) {
+  const currentInjector = getCurrentInjector();
+  if (currentInjector === void 0) {
+    throw new RuntimeError(
+      -203 /* MISSING_INJECTION_CONTEXT */,
+      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 {
-    activeConsumer.producers = newLink;
-  }
-  if (isLive) {
-    producerAddLiveConsumer(node, newLink);
+    const options = convertToInjectOptions(flags);
+    const value = currentInjector.retrieve(token, options);
+    ngDevMode && emitInjectEvent(token, value, flags);
+    if (isNotFound(value)) {
+      if (options.optional) {
+        return null;
+      }
+      throw value;
+    }
+    return value;
   }
 }
-function producerIncrementEpoch() {
-  epoch++;
+function ɵɵinject(token, flags = 0 /* Default */) {
+  return (getInjectImplementation() || injectInjectorOnly)(resolveForwardRef(token), flags);
 }
-function producerUpdateValueVersion(node) {
-  if (consumerIsLive(node) && !node.dirty) {
-    return;
-  }
-  if (!node.dirty && node.lastCleanEpoch === epoch) {
-    return;
-  }
-  if (!node.producerMustRecompute(node) && !consumerPollProducersForChange(node)) {
-    producerMarkClean(node);
-    return;
-  }
-  node.producerRecomputeValue(node);
-  producerMarkClean(node);
+function ɵɵinvalidFactoryDep(index) {
+  throw new RuntimeError(
+    202 /* INVALID_FACTORY_DEPENDENCY */,
+    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 producerNotifyConsumers(node) {
-  if (node.consumers === void 0) {
-    return;
+function inject2(token, options) {
+  return ɵɵinject(token, convertToBitFlags(options));
+}
+function convertToBitFlags(flags) {
+  if (typeof flags === "undefined" || typeof flags === "number") {
+    return flags;
   }
-  const prev = inNotificationPhase;
-  inNotificationPhase = true;
-  try {
-    for (let link = node.consumers; link !== void 0; link = link.nextConsumer) {
-      const consumer = link.consumer;
-      if (!consumer.dirty) {
-        consumerMarkDirty(consumer);
+  return 0 /* Default */ | // comment to force a line break in the formatter
+  (flags.optional && 8 /* Optional */) | 0 | (flags.self && 2 /* Self */) | (flags.skipSelf && 4 /* SkipSelf */);
+}
+function convertToInjectOptions(flags) {
+  return {
+    optional: !!(flags & 8 /* Optional */),
+    host: !!(flags & 1 /* Host */),
+    self: !!(flags & 2 /* Self */),
+    skipSelf: !!(flags & 4 /* SkipSelf */)
+  };
+}
+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 /* INVALID_DIFFER_INPUT */, ngDevMode && "Arguments array must have arguments.");
       }
+      let type = void 0;
+      let flags = 0 /* Default */;
+      for (let j = 0; j < arg.length; j++) {
+        const meta = arg[j];
+        const flag = getInjectFlag(meta);
+        if (typeof flag === "number") {
+          if (flag === -1 /* Inject */) {
+            type = meta.token;
+          } else {
+            flags |= flag;
+          }
+        } else {
+          type = meta;
+        }
+      }
+      args.push(ɵɵinject(type, flags));
+    } else {
+      args.push(ɵɵinject(arg));
     }
-  } finally {
-    inNotificationPhase = prev;
   }
+  return args;
 }
-function producerUpdatesAllowed() {
-  return activeConsumer?.consumerAllowSignalWrites !== false;
+function attachInjectFlag(decorator, flag) {
+  decorator[DI_DECORATOR_FLAG] = flag;
+  decorator.prototype[DI_DECORATOR_FLAG] = flag;
+  return decorator;
 }
-function consumerMarkDirty(node) {
-  node.dirty = true;
-  producerNotifyConsumers(node);
-  node.consumerMarkedDirty?.(node);
+function getInjectFlag(token) {
+  return token[DI_DECORATOR_FLAG];
 }
-function producerMarkClean(node) {
-  node.dirty = false;
-  node.lastCleanEpoch = epoch;
+
+// src/import/di/injector_token.ts
+var INJECTOR = new InjectionToken(
+  typeof ngDevMode !== "undefined" && 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 /* Injector */
+  // Special value used by Ivy to identify `Injector`.
+);
+
+// src/import/di/internal_tokens.ts
+var INJECTOR_DEF_TYPES = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "INJECTOR_DEF_TYPES" : "");
+
+// src/import/di/null_injector.ts
+var NullInjector = class {
+  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 /* PROVIDER_NOT_FOUND */);
+      error.name = "ɵNotFound";
+      throw error;
+    }
+    return notFoundValue;
+  }
+};
+
+// src/import/di/provider_collection.ts
+function makeEnvironmentProviders(providers) {
+  return {
+    ɵproviders: providers
+  };
 }
-function consumerBeforeComputation(node) {
-  if (node) resetConsumerBeforeComputation(node);
-  return setActiveConsumer(node);
+var USE_VALUE = getClosureSafeProperty({
+  provide: String,
+  useValue: getClosureSafeProperty
+});
+function isValueProvider(value) {
+  return value !== null && typeof value === "object" && USE_VALUE in value;
 }
-function resetConsumerBeforeComputation(node) {
-  node.producersTail = void 0;
-  node.recomputing = true;
+function isExistingProvider(value) {
+  return !!(value && value.useExisting);
 }
-function consumerAfterComputation(node, prevConsumer) {
-  setActiveConsumer(prevConsumer);
-  if (node) finalizeConsumerAfterComputation(node);
+function isFactoryProvider(value) {
+  return !!(value && value.useFactory);
 }
-function finalizeConsumerAfterComputation(node) {
-  node.recomputing = false;
-  const producersTail = node.producersTail;
-  let toRemove = producersTail !== void 0 ? producersTail.nextProducer : node.producers;
-  if (toRemove !== void 0) {
-    if (consumerIsLive(node)) {
-      do {
-        toRemove = producerRemoveLiveConsumerLink(toRemove);
-      } while (toRemove !== void 0);
+function isTypeProvider(value) {
+  return typeof value === "function";
+}
+
+// src/import/di/scope.ts
+var INJECTOR_SCOPE = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "Set Injector scope." : "");
+
+// src/import/di/r3_injector.ts
+var NOT_YET = {};
+var CIRCULAR = {};
+var NULL_INJECTOR = void 0;
+function getNullInjector() {
+  if (NULL_INJECTOR === void 0) {
+    NULL_INJECTOR = new NullInjector();
+  }
+  return NULL_INJECTOR;
+}
+var EnvironmentInjector = class {
+};
+var R3Injector = class extends EnvironmentInjector {
+  constructor(providers, parent, source, scopes) {
+    super();
+    this.parent = parent;
+    this.source = source;
+    this.scopes = scopes;
+    forEachSingleProvider(providers, (provider) => this.processProvider(provider));
+    this.records.set(INJECTOR, makeRecord(void 0, this));
+    if (scopes.has("environment")) {
+      this.records.set(EnvironmentInjector, makeRecord(void 0, this));
     }
-    if (producersTail !== void 0) {
-      producersTail.nextProducer = void 0;
-    } else {
-      node.producers = void 0;
+    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 }));
   }
-}
-function consumerPollProducersForChange(node) {
-  for (let link = node.producers; link !== void 0; link = link.nextProducer) {
-    const producer = link.producer;
-    const seenVersion = link.lastReadVersion;
-    if (seenVersion !== producer.version) {
-      return true;
+  /**
+   * 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.
+   */
+  records = /* @__PURE__ */ new Map();
+  /**
+   * Set of values instantiated by this injector which contain `ngOnDestroy` lifecycle hooks.
+   */
+  _ngOnDestroyHooks = /* @__PURE__ */ new Set();
+  _onDestroyHooks = [];
+  /**
+   * Flag indicating that this injector was previously destroyed.
+   */
+  get destroyed() {
+    return this._destroyed;
+  }
+  _destroyed = false;
+  injectorDefTypes;
+  retrieve(token, options) {
+    const flags = convertToBitFlags(options) || 0 /* Default */;
+    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 (isNotFound(e)) {
+        return e;
+      }
+      throw e;
     }
-    producerUpdateValueVersion(producer);
-    if (seenVersion !== producer.version) {
-      return true;
+  }
+  /**
+   * 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;
+    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();
     }
   }
-  return false;
-}
-function consumerDestroy(node) {
-  if (consumerIsLive(node)) {
-    let link = node.producers;
-    while (link !== void 0) {
-      link = producerRemoveLiveConsumerLink(link);
+  onDestroy(callback) {
+    assertNotDestroyed(this);
+    this._onDestroyHooks.push(callback);
+    return () => this.removeOnDestroy(callback);
+  }
+  runInContext(fn) {
+    assertNotDestroyed(this);
+    const previousInjector = setCurrentInjector(this);
+    const previousInjectImplementation = setInjectImplementation(void 0);
+    let prevInjectContext;
+    if (ngDevMode) {
+      prevInjectContext = setInjectorProfilerContext({ injector: this, token: null });
+    }
+    try {
+      return fn();
+    } finally {
+      setCurrentInjector(previousInjector);
+      setInjectImplementation(previousInjectImplementation);
+      ngDevMode && setInjectorProfilerContext(prevInjectContext);
+    }
+  }
+  get(token, notFoundValue = THROW_IF_NOT_FOUND, 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 = setCurrentInjector(this);
+    const previousInjectImplementation = setInjectImplementation(void 0);
+    try {
+      if (!(flags & 4 /* SkipSelf */)) {
+        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 /* Self */) ? this.parent : getNullInjector();
+      notFoundValue = flags & 8 /* Optional */ && notFoundValue === THROW_IF_NOT_FOUND ? null : notFoundValue;
+      return nextInjector.get(token, notFoundValue);
+    } catch (error) {
+      const errorCode = getRuntimeErrorCode(error);
+      if (errorCode === -200 /* CYCLIC_DI_DEPENDENCY */ || errorCode === -201 /* PROVIDER_NOT_FOUND */) {
+        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);
+      setCurrentInjector(previousInjector);
+      ngDevMode && setInjectorProfilerContext(prevInjectContext);
     }
   }
-  node.producers = void 0;
-  node.producersTail = void 0;
-  node.consumers = void 0;
-  node.consumersTail = void 0;
-}
-function producerAddLiveConsumer(node, link) {
-  const consumersTail = node.consumersTail;
-  const wasLive = consumerIsLive(node);
-  if (consumersTail !== void 0) {
-    link.nextConsumer = consumersTail.nextConsumer;
-    consumersTail.nextConsumer = link;
-  } else {
-    link.nextConsumer = void 0;
-    node.consumers = link;
-  }
-  link.prevConsumer = consumersTail;
-  node.consumersTail = link;
-  if (!wasLive) {
-    for (let link2 = node.producers; link2 !== void 0; link2 = link2.nextProducer) {
-      producerAddLiveConsumer(link2.producer, link2);
+  /** @internal */
+  resolveInjectorInitializers() {
+    const previousInjector = 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 /* INVALID_MULTI_PROVIDER */,
+          `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 {
+      setCurrentInjector(previousInjector);
+      setInjectImplementation(previousInjectImplementation);
+      ngDevMode && setInjectorProfilerContext(prevInjectContext);
     }
   }
-}
-function producerRemoveLiveConsumerLink(link) {
-  const producer = link.producer;
-  const nextProducer = link.nextProducer;
-  const nextConsumer = link.nextConsumer;
-  const prevConsumer = link.prevConsumer;
-  link.nextConsumer = void 0;
-  link.prevConsumer = void 0;
-  if (nextConsumer !== void 0) {
-    nextConsumer.prevConsumer = prevConsumer;
-  } else {
-    producer.consumersTail = prevConsumer;
-  }
-  if (prevConsumer !== void 0) {
-    prevConsumer.nextConsumer = nextConsumer;
-  } else {
-    producer.consumers = nextConsumer;
-    if (!consumerIsLive(producer)) {
-      let producerLink = producer.producers;
-      while (producerLink !== void 0) {
-        producerLink = producerRemoveLiveConsumerLink(producerLink);
+  toString() {
+    if (ngDevMode) {
+      const tokens = [];
+      const records = this.records;
+      for (const token of records.keys()) {
+        tokens.push(stringify(token));
       }
+      return `R3Injector[${tokens.join(", ")}]`;
     }
+    return "R3Injector[...]";
   }
-  return nextProducer;
-}
-function consumerIsLive(node) {
-  return node.consumerIsAlwaysLive || node.consumers !== void 0;
-}
-function runPostProducerCreatedFn(node) {
-  postProducerCreatedFn?.(node);
-}
-function isValidLink(checkLink, consumer) {
-  const producersTail = consumer.producersTail;
-  if (producersTail !== void 0) {
-    let link = consumer.producers;
-    do {
-      if (link === checkLink) {
-        return true;
+  /**
+   * 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);
       }
-      if (link === producersTail) {
-        break;
+      token = provider;
+      multiRecord.multi.push(provider);
+    } else {
+      if (ngDevMode) {
+        const existing = this.records.get(token);
+        if (existing && existing.multi !== void 0) {
+          throwMixedMultiProviderError();
+        }
       }
-      link = link.nextProducer;
-    } while (link !== void 0);
-  }
-  return false;
-}
-
-// src/primitives/signals/src/equality.ts
-function defaultEquals(a, b) {
-  return Object.is(a, b);
-}
-
-// src/primitives/signals/src/computed.ts
-function createComputed(computation, equal) {
-  const node = Object.create(COMPUTED_NODE);
-  node.computation = computation;
-  if (equal !== void 0) {
-    node.equal = equal;
-  }
-  const computed2 = () => {
-    producerUpdateValueVersion(node);
-    producerAccessed(node);
-    if (node.value === ERRORED) {
-      throw node.error;
     }
-    return node.value;
-  };
-  computed2[SIGNAL] = node;
-  if (false) {
-    const debugName = node.debugName ? " (" + node.debugName + ")" : "";
-    computed2.toString = () => `[Computed${debugName}: ${node.value}]`;
+    this.records.set(token, record);
   }
-  runPostProducerCreatedFn(node);
-  return computed2;
-}
-var UNSET = /* @__PURE__ */ Symbol("UNSET");
-var COMPUTING = /* @__PURE__ */ Symbol("COMPUTING");
-var ERRORED = /* @__PURE__ */ Symbol("ERRORED");
-var COMPUTED_NODE = /* @__PURE__ */ (() => ({
-  ...REACTIVE_NODE,
-  value: UNSET,
-  dirty: true,
-  error: null,
-  equal: defaultEquals,
-  kind: "computed",
-  producerMustRecompute(node) {
-    return node.value === UNSET || node.value === COMPUTING;
-  },
-  producerRecomputeValue(node) {
-    if (node.value === COMPUTING) {
-      throw new Error(false ? "Detected cycle in computations." : "");
-    }
-    const oldValue = node.value;
-    node.value = COMPUTING;
-    const prevConsumer = consumerBeforeComputation(node);
-    let newValue;
-    let wasEqual = false;
+  hydrate(token, record, flags) {
     try {
-      newValue = node.computation();
-      setActiveConsumer(null);
-      wasEqual = oldValue !== UNSET && oldValue !== ERRORED && newValue !== ERRORED && node.equal(oldValue, newValue);
-    } catch (err) {
-      newValue = ERRORED;
-      node.error = err;
+      if (record.value === CIRCULAR) {
+        throw cyclicDependencyError(ngDevMode ? 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 {
-      consumerAfterComputation(node, prevConsumer);
     }
-    if (wasEqual) {
-      node.value = oldValue;
-      return;
+  }
+  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);
     }
-    node.value = newValue;
-    node.version++;
   }
-}))();
-
-// src/primitives/signals/src/errors.ts
-function defaultThrowError() {
-  throw new Error();
-}
-var throwInvalidWriteToSignalErrorFn = defaultThrowError;
-function throwInvalidWriteToSignalError(node) {
-  throwInvalidWriteToSignalErrorFn(node);
+  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 /* INVALID_INJECTION_TOKEN */, ngDevMode && `Token ${stringify(token)} is missing a ɵprov definition.`);
+  }
+  if (token instanceof Function) {
+    return getUndecoratedInjectableFactory(token);
+  }
+  throw new RuntimeError(-204 /* INVALID_INJECTION_TOKEN */, ngDevMode && "unreachable");
 }
-
-// src/primitives/signals/src/signal.ts
-var postSignalSetFn = null;
-function createSignal(initialValue, equal) {
-  const node = Object.create(SIGNAL_NODE);
-  node.value = initialValue;
-  if (equal !== void 0) {
-    node.equal = equal;
+function getUndecoratedInjectableFactory(token) {
+  const paramLength = token.length;
+  if (paramLength > 0) {
+    throw new RuntimeError(-204 /* INVALID_INJECTION_TOKEN */, ngDevMode && `Can't resolve all parameters for ${stringify(token)}: (${newArray(paramLength, "?").join(", ")}).`);
   }
-  const getter = () => signalGetFn(node);
-  getter[SIGNAL] = node;
-  if (false) {
-    const debugName = node.debugName ? " (" + node.debugName + ")" : "";
-    getter.toString = () => `[Signal${debugName}: ${node.value}]`;
+  const inheritedInjectableDef = getInheritedInjectableDef(token);
+  if (inheritedInjectableDef !== null) {
+    return () => inheritedInjectableDef.factory(token);
+  } else {
+    return () => new token();
   }
-  runPostProducerCreatedFn(node);
-  const set = (newValue) => signalSetFn(node, newValue);
-  const update = (updateFn) => signalUpdateFn(node, updateFn);
-  return [getter, set, update];
 }
-function signalGetFn(node) {
-  producerAccessed(node);
-  return node.value;
+function providerToRecord(provider) {
+  if (isValueProvider(provider)) {
+    return makeRecord(void 0, provider.useValue);
+  } else {
+    const factory = providerToFactory(provider);
+    return makeRecord(factory, NOT_YET);
+  }
 }
-function signalSetFn(node, newValue) {
-  if (!producerUpdatesAllowed()) {
-    throwInvalidWriteToSignalError(node);
+function providerToFactory(provider, ngModuleType, providers) {
+  let factory = void 0;
+  if (ngDevMode && isEnvironmentProviders(provider)) {
+    throwInvalidProviderError(void 0, providers, provider);
   }
-  if (!node.equal(node.value, newValue)) {
-    node.value = newValue;
-    signalValueChanged(node);
+  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) => ɵɵinject(resolveForwardRef(provider.useExisting), flags !== void 0 && flags & 8 /* Optional */ ? 8 /* Optional */ : 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 signalUpdateFn(node, updater) {
-  if (!producerUpdatesAllowed()) {
-    throwInvalidWriteToSignalError(node);
+function assertNotDestroyed(injector) {
+  if (injector.destroyed) {
+    throw new RuntimeError(-205 /* INJECTOR_ALREADY_DESTROYED */, ngDevMode && "Injector has already been destroyed.");
   }
-  signalSetFn(node, updater(node.value));
 }
-var SIGNAL_NODE = /* @__PURE__ */ (() => ({
-  ...REACTIVE_NODE,
-  equal: defaultEquals,
-  value: void 0,
-  kind: "signal"
-}))();
-function signalValueChanged(node) {
-  node.version++;
-  producerIncrementEpoch();
-  producerNotifyConsumers(node);
-  postSignalSetFn?.(node);
+function makeRecord(factory, value, multi = false) {
+  return {
+    factory,
+    value,
+    multi: multi ? [] : void 0
+  };
 }
-
-// src/primitives/signals/src/linked_signal.ts
-function createLinkedSignal(sourceFn, computationFn, equalityFn) {
-  const node = Object.create(LINKED_SIGNAL_NODE);
-  node.source = sourceFn;
-  node.computation = computationFn;
-  if (equalityFn != void 0) {
-    node.equal = equalityFn;
-  }
-  const linkedSignalGetter = () => {
-    producerUpdateValueVersion(node);
-    producerAccessed(node);
-    if (node.value === ERRORED) {
-      throw node.error;
+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.ɵproviders, fn);
+    } else {
+      fn(provider);
     }
-    return node.value;
-  };
-  const getter = linkedSignalGetter;
-  getter[SIGNAL] = node;
-  if (false) {
-    const debugName = node.debugName ? " (" + node.debugName + ")" : "";
-    getter.toString = () => `[LinkedSignal${debugName}: ${node.value}]`;
   }
-  runPostProducerCreatedFn(node);
-  return getter;
-}
-function linkedSignalSetFn(node, newValue) {
-  producerUpdateValueVersion(node);
-  signalSetFn(node, newValue);
-  producerMarkClean(node);
 }
-function linkedSignalUpdateFn(node, updater) {
-  producerUpdateValueVersion(node);
-  signalUpdateFn(node, updater);
-  producerMarkClean(node);
+
+// src/import/util/closure.ts
+function noSideEffects(fn) {
+  return { toString: fn }.toString();
 }
-var LINKED_SIGNAL_NODE = /* @__PURE__ */ (() => ({
-  ...REACTIVE_NODE,
-  value: UNSET,
-  dirty: true,
-  error: null,
-  equal: defaultEquals,
-  kind: "linkedSignal",
-  producerMustRecompute(node) {
-    return node.value === UNSET || node.value === COMPUTING;
-  },
-  producerRecomputeValue(node) {
-    if (node.value === COMPUTING) {
-      throw new Error(false ? "Detected cycle in computations." : "");
+
+// src/import/util/decorators.ts
+function makeMetadataCtor(props) {
+  return function ctor(...args) {
+    if (props) {
+      const values = props(...args);
+      for (const propName in values) {
+        this[propName] = values[propName];
+      }
     }
-    const oldValue = node.value;
-    node.value = COMPUTING;
-    const prevConsumer = consumerBeforeComputation(node);
-    let newValue;
-    try {
-      const newSourceValue = node.source();
-      const prev = oldValue === UNSET || oldValue === ERRORED ? void 0 : {
-        source: node.sourceValue,
-        value: oldValue
-      };
-      newValue = node.computation(newSourceValue, prev);
-      node.sourceValue = newSourceValue;
-    } catch (err) {
-      newValue = ERRORED;
-      node.error = err;
-    } finally {
-      consumerAfterComputation(node, prevConsumer);
+  };
+}
+function makeParamDecorator(name, props, parentClass) {
+  return noSideEffects(() => {
+    const metaCtor = makeMetadataCtor(props);
+    function ParamDecoratorFactory(...args) {
+      metaCtor.apply(this, args);
+      return this;
     }
-    if (oldValue !== UNSET && newValue !== ERRORED && node.equal(oldValue, newValue)) {
-      node.value = oldValue;
-      return;
+    if (parentClass) {
     }
-    node.value = newValue;
-    node.version++;
-  }
-}))();
+    return ParamDecoratorFactory;
+  });
+}
 
-// src/primitives/signals/src/untracked.ts
-function untracked(nonReactiveReadsFn) {
-  const prevConsumer = setActiveConsumer(null);
-  try {
-    return nonReactiveReadsFn();
-  } finally {
-    setActiveConsumer(prevConsumer);
+// src/import/di/metadata.ts
+var Inject = attachInjectFlag(
+  // Disable tslint because `DecoratorFlags` is a const enum which gets inlined.
+  makeParamDecorator("Inject", (token) => ({ token })),
+  // tslint:disable-next-line: no-toplevel-property-access
+  -1 /* Inject */
+);
+var Optional = (
+  // Disable tslint because `InternalInjectFlags` is a const enum which gets inlined.
+  // tslint:disable-next-line: no-toplevel-property-access
+  attachInjectFlag(makeParamDecorator("Optional"), 8 /* Optional */)
+);
+var Self = (
+  // Disable tslint because `InternalInjectFlags` is a const enum which gets inlined.
+  // tslint:disable-next-line: no-toplevel-property-access
+  attachInjectFlag(makeParamDecorator("Self"), 2 /* Self */)
+);
+var SkipSelf = (
+  // Disable tslint because `InternalInjectFlags` is a const enum which gets inlined.
+  // tslint:disable-next-line: no-toplevel-property-access
+  attachInjectFlag(makeParamDecorator("SkipSelf"), 4 /* SkipSelf */)
+);
+
+// src/import/di/create_injector.ts
+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];
+  let source = void 0;
+  if (ngDevMode) {
+    source = name || (typeof defType === "object" ? void 0 : stringify(defType));
   }
+  return new R3Injector(providers, parent || getNullInjector(), source || null, scopes);
 }
 
-// src/primitives/signals/src/effect.ts
-var BASE_EFFECT_NODE = /* @__PURE__ */ (() => ({
-  ...REACTIVE_NODE,
-  consumerIsAlwaysLive: true,
-  consumerAllowSignalWrites: true,
-  dirty: true,
-  kind: "effect"
-}))();
-function runEffect(node) {
-  node.dirty = false;
-  if (node.version > 0 && !consumerPollProducersForChange(node)) {
-    return;
+// src/import/render3/debug/special_providers.ts
+var specialProviders = /* @__PURE__ */ new Set();
+function registerSpecialProvider(clazz) {
+  if (typeof ngDevMode !== "undefined" && ngDevMode) {
+    specialProviders.add(clazz);
   }
-  node.version++;
-  const prevNode = consumerBeforeComputation(node);
-  try {
-    node.cleanup();
-    node.fn();
-  } finally {
-    consumerAfterComputation(node, prevNode);
+}
+
+// src/import/di/injector.ts
+var Injector = class _Injector {
+  static THROW_IF_NOT_FOUND = THROW_IF_NOT_FOUND;
+  static NULL = /* @__PURE__ */ new NullInjector();
+  static create(options, parent) {
+    if (Array.isArray(options)) {
+      return createInjector({ name: "" }, parent, options, "");
+    } else {
+      const name = options.name ?? "";
+      return createInjector({ name }, options.parent, options.providers, name);
+    }
   }
+  /** @nocollapse */
+  static ɵprov = (
+    /** @pureOrBreakMyCode */
+    /* @__PURE__ */ ɵɵdefineInjectable({
+      token: _Injector,
+      providedIn: "any",
+      factory: () => ɵɵinject(INJECTOR)
+    })
+  );
+  /**
+   * @internal
+   * @nocollapse
+   */
+  static __NG_ELEMENT_ID__ = -1 /* Injector */;
+};
+if (typeof ngDevMode === "undefined" || ngDevMode) {
+  registerSpecialProvider(Injector);
 }
 
-// src/primitives/signals/index.ts
-if (false) {
-  installDevToolsSignalFormatter();
+// src/import/render3/instructions/di.ts
+function ɵɵinvalidFactory() {
+  const msg = ngDevMode ? `This constructor was not compatible with Dependency Injection.` : "invalid";
+  throw new Error(msg);
 }
 
 // src/import/render3/reactivity/api.ts
-function isSignal(value) {
+function isSignal2(value) {
   return typeof value === "function" && value[SIGNAL] !== void 0;
 }
+function isWritableSignal(value) {
+  return isSignal2(value) && typeof value.set === "function";
+}
 
 // src/import/render3/reactivity/computed.ts
 function computed(computation, options) {
   const getter = createComputed(computation, options?.equal);
-  if (false) {
+  if (typeof ngDevMode !== "undefined" && ngDevMode) {
+    const debugName = options?.debugName;
+    getter[SIGNAL].debugName = debugName;
+    getter.toString = () => `[Computed${debugName ? " (" + debugName + ")" : ""}: ${getter()}]`;
   }
   return getter;
 }
@@ -1448,7 +1791,10 @@ function signal(initialValue, options) {
   signalFn.set = set;
   signalFn.update = update;
   signalFn.asReadonly = signalAsReadonlyFn.bind(signalFn);
-  if (false) {
+  if (typeof ngDevMode !== "undefined" && ngDevMode) {
+    const debugName = options?.debugName;
+    node.debugName = debugName;
+    signalFn.toString = () => `[Signal${debugName ? " (" + debugName + ")" : ""}: ${signalFn()}]`;
   }
   return signalFn;
 }
@@ -1474,7 +1820,9 @@ function linkedSignal(optionsOrComputation, options) {
   }
 }
 function upgradeLinkedSignalGetter(getter, debugName) {
-  if (false) {
+  if (typeof ngDevMode !== "undefined" && ngDevMode) {
+    getter[SIGNAL].debugName = debugName;
+    getter.toString = () => `[LinkedSignal${debugName ? " (" + debugName + ")" : ""}: ${getter()}]`;
   }
   const node = getter[SIGNAL];
   const upgradedGetter = getter;
@@ -1492,7 +1840,45 @@ function untracked2(nonReactiveReadsFn) {
 // src/import/render3/reactivity/asserts.ts
 function assertNotInReactiveContext(debugFn, extraContext) {
   if (getActiveConsumer() !== null) {
-    throw new RuntimeError(-602 /* ASSERTION_NOT_INSIDE_REACTIVE_CONTEXT */, void 0);
+    throw new RuntimeError(
+      -602 /* ASSERTION_NOT_INSIDE_REACTIVE_CONTEXT */,
+      ngDevMode && `${debugFn.name}() cannot be called from within a reactive context.${extraContext ? ` ${extraContext}` : ""}`
+    );
+  }
+}
+
+// src/import/di/contextual.ts
+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 = setCurrentInjector(internalInjector);
+  const previousInjectImplementation = setInjectImplementation(void 0);
+  try {
+    return fn();
+  } finally {
+    setCurrentInjector(prevInjector);
+    ngDevMode && setInjectorProfilerContext(prevInjectorProfilerContext);
+    setInjectImplementation(previousInjectImplementation);
+  }
+}
+function isInInjectionContext() {
+  return getInjectImplementation() !== void 0 || getCurrentInjector() != null;
+}
+function assertInInjectionContext(debugFn) {
+  if (!isInInjectionContext()) {
+    throw new RuntimeError(
+      -203 /* MISSING_INJECTION_CONTEXT */,
+      ngDevMode && debugFn.name + "() can only be used within an injection context such as a constructor, a factory function, a field initializer, or a function used with `runInInjectionContext`"
+    );
   }
 }
 
@@ -1508,9 +1894,8 @@ var DestroyRef = class {
    */
   static __NG_ENV_ID__ = (injector) => injector;
 };
-
-// src/import/util/noop.ts
-function noop(...args) {
+if (typeof ngDevMode === "undefined" || ngDevMode) {
+  registerSpecialProvider(DestroyRef);
 }
 
 // src/import/change_detection/scheduling/zoneless_scheduling.ts
@@ -1533,10 +1918,6 @@ var NotificationSource = /* @__PURE__ */ ((NotificationSource2) => {
 })(NotificationSource || {});
 var ChangeDetectionScheduler = class {
 };
-var ZONELESS_ENABLED = new InjectionToken("", { providedIn: "root", factory: () => false });
-var PROVIDED_ZONELESS = new InjectionToken("", { providedIn: "root", factory: () => false });
-var ZONELESS_SCHEDULER_DISABLED = new InjectionToken("");
-var SCHEDULE_IN_ROOT_ZONE = new InjectionToken("");
 
 // src/import/render3/reactivity/root_effect_scheduler.ts
 var EffectScheduler = class _EffectScheduler {
@@ -1631,10 +2012,11 @@ var EffectRefImpl = class {
   }
 };
 function effect(effectFn, options) {
-  if (false) {
+  ngDevMode && assertNotInReactiveContext(effect, "Call `effect` outside of a reactive context. For example, schedule the effect inside the component constructor.");
+  if (ngDevMode && !options?.injector) {
     assertInInjectionContext(effect);
   }
-  if (false) {
+  if (ngDevMode && options?.allowSignalWrites !== void 0) {
     console.warn(`The 'allowSignalWrites' flag is deprecated and no longer impacts effect() (writes are always allowed)`);
   }
   const injector = options?.injector ?? inject2(Injector);
@@ -1644,18 +2026,27 @@ function effect(effectFn, options) {
   node = createRootEffect(effectFn, injector.get(EffectScheduler), notifier);
   node.injector = injector;
   if (destroyRef !== null) {
-    node.onDestroyFn = destroyRef.onDestroy(() => node.destroy());
+    node.onDestroyFns = [destroyRef.onDestroy(() => node.destroy())];
   }
   const effectRef = new EffectRefImpl(node);
+  if (ngDevMode) {
+    node.debugName = options?.debugName ?? "";
+    const prevInjectorProfilerContext = setInjectorProfilerContext({ injector, token: null });
+    try {
+      emitEffectCreatedEvent(effectRef);
+    } finally {
+      setInjectorProfilerContext(prevInjectorProfilerContext);
+    }
+  }
   return effectRef;
 }
 var EFFECT_NODE = /* @__PURE__ */ (() => ({
   ...BASE_EFFECT_NODE,
   cleanupFns: void 0,
   zone: null,
-  onDestroyFn: noop,
+  onDestroyFns: null,
   run() {
-    if (false) {
+    if (ngDevMode && isInNotificationPhase()) {
       throw new Error(`Schedulers cannot synchronously execute watches while scheduling.`);
     }
     try {
@@ -1686,7 +2077,11 @@ var ROOT_EFFECT_NODE = /* @__PURE__ */ (() => ({
   },
   destroy() {
     consumerDestroy(this);
-    this.onDestroyFn();
+    if (this.onDestroyFns !== null) {
+      for (const fn of this.onDestroyFns) {
+        fn();
+      }
+    }
     this.cleanup();
     this.scheduler.remove(this);
   }
@@ -1707,6 +2102,10 @@ function createEffectFn(node, fn) {
   };
 }
 
+// src/import/util/noop.ts
+function noop(...args) {
+}
+
 // src/import/util/callback_scheduler.ts
 function scheduleCallbackWithMicrotask(callback) {
   queueMicrotask(() => callback());
@@ -1732,48 +2131,124 @@ var ChangeDetectionSchedulerImpl = class {
     this.cancelScheduledCallback?.();
     this.cancelScheduledCallback = null;
   }
-  ngOnDestroy() {
-    this.cleanup();
+  ngOnDestroy() {
+    this.cleanup();
+  }
+};
+
+// src/import/resource/api.ts
+var ResourceDependencyError = class extends Error {
+  /** The dependency that errored. */
+  dependency;
+  constructor(dependency) {
+    super("Dependency error", { cause: dependency.error() });
+    this.name = "ResourceDependencyError";
+    this.dependency = dependency;
+  }
+};
+var ResourceParamsStatus = class _ResourceParamsStatus extends Error {
+  _brand;
+  constructor(msg) {
+    super(msg);
+  }
+  /** Status code that transitions the resource to `idle` status. */
+  static IDLE = new _ResourceParamsStatus("IDLE");
+  /** Status code that transitions the resource to `loading` status. */
+  static LOADING = new _ResourceParamsStatus("LOADING");
+};
+
+// src/import/defer/idle_service.ts
+var _requestIdleCallback = () => (typeof requestIdleCallback !== "undefined" ? requestIdleCallback : (cb) => setTimeout(cb)).bind(globalThis);
+var _cancelIdleCallback = () => (typeof requestIdleCallback !== "undefined" ? cancelIdleCallback : clearTimeout).bind(globalThis);
+var IDLE_SERVICE = new InjectionToken(ngDevMode ? "IDLE_SERVICE" : "", {
+  factory: () => new RequestIdleCallbackService()
+});
+function provideIdleServiceWith(useExisting) {
+  return makeEnvironmentProviders([
+    {
+      provide: IDLE_SERVICE,
+      useExisting
+    }
+  ]);
+}
+var RequestIdleCallbackService = class {
+  requestIdleCallback = _requestIdleCallback();
+  cancelIdleCallback = _cancelIdleCallback();
+  requestOnIdle(callback, options) {
+    return this.requestIdleCallback(callback, options);
+  }
+  cancelOnIdle(id) {
+    return this.cancelIdleCallback(id);
   }
 };
 
-// src/import/pending_tasks.ts
-var import_rxjs = require("rxjs");
+// src/import/util/default_export.ts
+function maybeUnwrapDefaultExport(input) {
+  return isWrappedDefaultExport(input) ? input["default"] : input;
+}
+function isWrappedDefaultExport(value) {
+  return value && typeof value === "object" && "default" in value;
+}
 
-// src/import/error_handler.ts
-var ErrorHandler = class {
-  /**
-   * @internal
-   */
-  _console = console;
-  handleError(error) {
-    this._console.error("ERROR", error);
+// src/import/util/promise_with_resolvers.ts
+function promiseWithResolvers() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+
+// src/import/di/inject_async.ts
+function injectAsync(loader, options) {
+  if (ngDevMode) {
+    assertInInjectionContext(injectAsync);
+  }
+  const injector = inject2(Injector);
+  let loadedPromise = null;
+  const load = () => {
+    if (!loadedPromise) {
+      loadedPromise = loader();
+    }
+    return loadedPromise;
+  };
+  if (options?.prefetch) {
+    options.prefetch().then(() => load()).catch(() => {
+    });
   }
-};
-var INTERNAL_APPLICATION_ERROR_HANDLER = new InjectionToken("", {
-  providedIn: "root",
-  factory: () => {
-    const injector = inject2(EnvironmentInjector);
-    let userErrorHandler;
-    return (e) => {
-      if (injector.destroyed && !userErrorHandler) {
-        setTimeout(() => {
-          throw e;
-        });
-      } else {
-        userErrorHandler ??= injector.get(ErrorHandler);
-        userErrorHandler.handleError(e);
-      }
-    };
+  return () => load().then((loadedToken) => injector.get(maybeUnwrapDefaultExport(loadedToken)));
+}
+function onIdle(options) {
+  if (ngDevMode) {
+    assertInInjectionContext(onIdle);
   }
-});
+  const idleService = inject2(IDLE_SERVICE);
+  const { promise, resolve } = promiseWithResolvers();
+  idleService.requestOnIdle(() => resolve(), options);
+  return promise;
+}
 
-// src/import/pending_tasks.ts
+// src/import/hydration/cache.ts
+var CACHE_ACTIVE = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "STATE_CACHE_ACTIVE" : "");
+
+// src/import/event_emitter.ts
+var import_rxjs2 = require("rxjs");
+
+// src/import/pending_tasks_internal.ts
+var import_rxjs = require("rxjs");
+
+// src/import/application/stability_debug.ts
+var DEBUG_TASK_TRACKER = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "DEBUG_TASK_TRACKER" : "");
+
+// src/import/pending_tasks_internal.ts
 var PendingTasksInternal = class _PendingTasksInternal {
   taskId = 0;
   pendingTasks = /* @__PURE__ */ new Set();
   destroyed = false;
   pendingTask = new import_rxjs.BehaviorSubject(false);
+  debugTaskTracker = inject2(DEBUG_TASK_TRACKER, { optional: true });
   get hasPendingTasks() {
     return this.destroyed ? false : this.pendingTask.value;
   }
@@ -1796,6 +2271,7 @@ var PendingTasksInternal = class _PendingTasksInternal {
     }
     const taskId = this.taskId++;
     this.pendingTasks.add(taskId);
+    this.debugTaskTracker?.add(taskId);
     return taskId;
   }
   has(taskId) {
@@ -1803,6 +2279,7 @@ var PendingTasksInternal = class _PendingTasksInternal {
   }
   remove(taskId) {
     this.pendingTasks.delete(taskId);
+    this.debugTaskTracker?.remove(taskId);
     if (this.pendingTasks.size === 0 && this.hasPendingTasks) {
       this.pendingTask.next(false);
     }
@@ -1825,6 +2302,232 @@ var PendingTasksInternal = class _PendingTasksInternal {
     })
   );
 };
+
+// src/import/event_emitter.ts
+var EventEmitter_ = class extends import_rxjs2.Subject {
+  // tslint:disable-next-line:require-internal-with-underscore
+  __isAsync;
+  destroyRef = void 0;
+  pendingTasks = void 0;
+  constructor(isAsync = false) {
+    super();
+    this.__isAsync = isAsync;
+    if (isInInjectionContext()) {
+      this.destroyRef = inject2(DestroyRef, { optional: true }) ?? void 0;
+      this.pendingTasks = inject2(PendingTasksInternal, { optional: true }) ?? void 0;
+    }
+  }
+  emit(value) {
+    const prevConsumer = setActiveConsumer(null);
+    try {
+      super.next(value);
+    } finally {
+      setActiveConsumer(prevConsumer);
+    }
+  }
+  subscribe(observerOrNext, error, complete) {
+    let nextFn = observerOrNext;
+    let errorFn = error || (() => null);
+    let completeFn = complete;
+    if (observerOrNext && typeof observerOrNext === "object") {
+      const observer = observerOrNext;
+      nextFn = observer.next?.bind(observer);
+      errorFn = observer.error?.bind(observer);
+      completeFn = observer.complete?.bind(observer);
+    }
+    if (this.__isAsync) {
+      errorFn = this.wrapInTimeout(errorFn);
+      if (nextFn) {
+        nextFn = this.wrapInTimeout(nextFn);
+      }
+      if (completeFn) {
+        completeFn = this.wrapInTimeout(completeFn);
+      }
+    }
+    const sink = super.subscribe({ next: nextFn, error: errorFn, complete: completeFn });
+    if (observerOrNext instanceof import_rxjs2.Subscription) {
+      observerOrNext.add(sink);
+    }
+    return sink;
+  }
+  wrapInTimeout(fn) {
+    return (value) => {
+      const taskId = this.pendingTasks?.add();
+      setTimeout(() => {
+        try {
+          fn(value);
+        } finally {
+          if (taskId !== void 0) {
+            this.pendingTasks?.remove(taskId);
+          }
+        }
+      });
+    };
+  }
+};
+var EventEmitter = EventEmitter_;
+
+// src/import/zone/ng_zone.ts
+var isAngularZoneProperty = "isAngularZone";
+var angularZoneInstanceIdProperty = isAngularZoneProperty + "_ID";
+var NgZone = class _NgZone {
+  hasPendingMacrotasks = false;
+  hasPendingMicrotasks = false;
+  /**
+   * Whether there are no outstanding microtasks or macrotasks.
+   */
+  isStable = true;
+  /**
+   * Notifies when code enters Angular Zone. This gets fired first on VM Turn.
+   */
+  onUnstable = new EventEmitter(false);
+  /**
+   * Notifies when there is no more microtasks enqueued in the current VM Turn.
+   * This is a hint for Angular to do change detection, which may enqueue more microtasks.
+   * For this reason this event can fire multiple times per VM Turn.
+   */
+  onMicrotaskEmpty = new EventEmitter(false);
+  /**
+   * Notifies when the last `onMicrotaskEmpty` has run and there are no more microtasks, which
+   * implies we are about to relinquish VM turn.
+   * This event gets called just once.
+   */
+  onStable = new EventEmitter(false);
+  /**
+   * Notifies that an error has been delivered.
+   */
+  onError = new EventEmitter(false);
+  constructor(options) {
+  }
+  /**
+    This method checks whether the method call happens within an Angular Zone instance.
+  */
+  /**
+    Assures that the method is called within the Angular Zone, otherwise throws an error.
+  */
+  /**
+    Assures that the method is called outside of the Angular Zone, otherwise throws an error.
+  */
+  /**
+   * Executes the `fn` function synchronously within the Angular zone and returns value returned by
+   * the function.
+   *
+   * Running functions via `run` allows you to reenter Angular zone from a task that was executed
+   * outside of the Angular zone (typically started via {@link #runOutsideAngular}).
+   *
+   * Any future tasks or microtasks scheduled from within this function will continue executing from
+   * within the Angular zone.
+   *
+   * If a synchronous error happens it will be rethrown and not reported via `onError`.
+   */
+  run(fn, applyThis, applyArgs) {
+    return this._inner.run(fn, applyThis, applyArgs);
+  }
+  /**
+   * Executes the `fn` function synchronously within the Angular zone as a task and returns value
+   * returned by the function.
+   *
+   * Running functions via `runTask` allows you to reenter Angular zone from a task that was executed
+   * outside of the Angular zone (typically started via {@link #runOutsideAngular}).
+   *
+   * Any future tasks or microtasks scheduled from within this function will continue executing from
+   * within the Angular zone.
+   *
+   * If a synchronous error happens it will be rethrown and not reported via `onError`.
+   */
+  runTask(fn, applyThis, applyArgs, name) {
+    const zone = this._inner;
+    const task = zone.scheduleEventTask("NgZoneEvent: " + name, fn, EMPTY_PAYLOAD, noop, noop);
+    try {
+      return zone.runTask(task, applyThis, applyArgs);
+    } finally {
+      zone.cancelTask(task);
+    }
+  }
+  /**
+   * Same as `run`, except that synchronous errors are caught and forwarded via `onError` and not
+   * rethrown.
+   */
+  runGuarded(fn, applyThis, applyArgs) {
+    return this._inner.runGuarded(fn, applyThis, applyArgs);
+  }
+  /**
+   * Executes the `fn` function synchronously in Angular's parent zone and returns value returned by
+   * the function.
+   *
+   * Running functions via {@link #runOutsideAngular} allows you to escape Angular's zone and do
+   * work that
+   * doesn't trigger Angular change-detection or is subject to Angular's error handling.
+   *
+   * Any future tasks or microtasks scheduled from within this function will continue executing from
+   * outside of the Angular zone.
+   *
+   * Use {@link #run} to reenter the Angular zone and do work that updates the application model.
+   */
+  runOutsideAngular(fn) {
+    return this._outer.run(fn);
+  }
+  /** @nocollapse */
+  static ɵprov = ɵɵdefineInjectable({
+    token: _NgZone,
+    providedIn: "root",
+    factory: () => new NoopNgZone()
+  });
+};
+var EMPTY_PAYLOAD = {};
+var NoopNgZone = class {
+  hasPendingMicrotasks = false;
+  hasPendingMacrotasks = false;
+  isStable = true;
+  onUnstable = new EventEmitter();
+  onMicrotaskEmpty = new EventEmitter();
+  onStable = new EventEmitter();
+  onError = new EventEmitter();
+  run(fn, applyThis, applyArgs) {
+    return fn.apply(applyThis, applyArgs);
+  }
+  runGuarded(fn, applyThis, applyArgs) {
+    return fn.apply(applyThis, applyArgs);
+  }
+  runOutsideAngular(fn) {
+    return fn();
+  }
+  runTask(fn, applyThis, applyArgs, name) {
+    return fn.apply(applyThis, applyArgs);
+  }
+};
+
+// src/import/error_handler.ts
+var ErrorHandler = class {
+  /**
+   * @internal
+   */
+  _console = console;
+  handleError(error) {
+    this._console.error("ERROR", error);
+  }
+};
+var INTERNAL_APPLICATION_ERROR_HANDLER = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "internal error handler" : "", {
+  factory: () => {
+    const zone = inject2(NgZone);
+    const injector = inject2(EnvironmentInjector);
+    let userErrorHandler;
+    return (e) => {
+      zone.runOutsideAngular(() => {
+        if (injector.destroyed && !userErrorHandler) {
+          setTimeout(() => {
+            throw e;
+          });
+        } else {
+          userErrorHandler ??= injector.get(ErrorHandler);
+          userErrorHandler.handleError(e);
+        }
+      });
+    };
+  }
+});
+
+// src/import/pending_tasks.ts
 var PendingTasks = class _PendingTasks {
   internalPendingTasks = inject2(PendingTasksInternal);
   scheduler = inject2(ChangeDetectionScheduler);
@@ -1858,7 +2561,12 @@ var PendingTasks = class _PendingTasks {
    */
   run(fn) {
     const removeTask = this.add();
-    fn().catch(this.errorHandler).finally(removeTask);
+    try {
+      fn().catch(this.errorHandler).finally(removeTask);
+    } catch (err) {
+      this.errorHandler(err);
+      removeTask();
+    }
   }
   /** @nocollapse */
   static ɵprov = (
@@ -1871,27 +2579,122 @@ var PendingTasks = class _PendingTasks {
   );
 };
 
+// src/import/application/application_tokens.ts
+var APP_ID = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "AppId" : "", {
+  factory: () => DEFAULT_APP_ID
+});
+var DEFAULT_APP_ID = "ng";
+
+// src/import/document.ts
+var DOCUMENT = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "DocumentToken" : "");
+
+// src/import/transfer_state.ts
+function makeStateKey(key) {
+  return key;
+}
+var TransferState = class _TransferState {
+  /** @nocollapse */
+  static ɵprov = (
+    /** @pureOrBreakMyCode */
+    /* @__PURE__ */ ɵɵdefineInjectable({
+      token: _TransferState,
+      providedIn: "root",
+      factory: () => {
+        const transferState = new _TransferState();
+        if (false) {
+          transferState.store = retrieveTransferredState(inject3(DOCUMENT2), inject3(APP_ID2));
+        }
+        return transferState;
+      }
+    })
+  );
+  /** @internal */
+  store = {};
+  onSerializeCallbacks = {};
+  /**
+   * Get the value corresponding to a key. Return `defaultValue` if key is not found.
+   */
+  get(key, defaultValue) {
+    return this.store[key] !== void 0 ? this.store[key] : defaultValue;
+  }
+  /**
+   * Set the value corresponding to a key.
+   */
+  set(key, value) {
+    this.store[key] = value;
+  }
+  /**
+   * Remove a key from the store.
+   */
+  remove(key) {
+    delete this.store[key];
+  }
+  /**
+   * Test whether a key exists in the store.
+   */
+  hasKey(key) {
+    return this.store.hasOwnProperty(key);
+  }
+  /**
+   * Indicates whether the state is empty.
+   */
+  get isEmpty() {
+    return Object.keys(this.store).length === 0;
+  }
+  /**
+   * Register a callback to provide the value for a key when `toJson` is called.
+   */
+  onSerialize(key, callback) {
+    this.onSerializeCallbacks[key] = callback;
+  }
+  /**
+   * Serialize the current state of the store to JSON.
+   */
+  toJson() {
+    for (const key in this.onSerializeCallbacks) {
+      if (this.onSerializeCallbacks.hasOwnProperty(key)) {
+        try {
+          this.store[key] = this.onSerializeCallbacks[key]();
+        } catch (e) {
+          console.warn("Exception in onSerialize callback: ", e);
+        }
+      }
+    }
+    return JSON.stringify(this.store).replace(/</g, "\\u003C").replace(/\//g, "\\u002F");
+  }
+};
+
 // src/import/resource/resource.ts
 function resource(options) {
-  if (false) {
+  if (ngDevMode && !options?.injector) {
+    assertInInjectionContext(resource);
   }
   const oldNameForParams = options.request;
   const params = options.params ?? oldNameForParams ?? (() => null);
-  return new ResourceImpl(params, getLoader(options), options.defaultValue, options.equal ? wrapEqualityFn(options.equal) : void 0, options.injector ?? inject2(Injector));
+  return new ResourceImpl(
+    params,
+    getLoader(options),
+    options.defaultValue,
+    options.equal ? wrapEqualityFn(options.equal) : void 0,
+    options.debugName,
+    options.injector ?? inject2(Injector),
+    options.id
+  );
 }
 var BaseWritableResource = class {
   value;
-  constructor(value) {
+  isLoading;
+  constructor(value, debugName) {
     this.value = value;
     this.value.set = this.set.bind(this);
     this.value.update = this.update.bind(this);
     this.value.asReadonly = signalAsReadonlyFn;
+    this.isLoading = computed(() => this.status() === "loading" || this.status() === "reloading", ngDevMode ? createDebugNameObject(debugName, "isLoading") : void 0);
   }
   isError = computed(() => this.status() === "error");
   update(updateFn) {
     this.set(updateFn(untracked2(this.value)));
   }
-  isLoading = computed(() => this.status() === "loading" || this.status() === "reloading");
   // Use a computed here to avoid triggering reactive consumers if the value changes while staying
   // either defined or undefined.
   isValueDefined = computed(() => {
@@ -1900,6 +2703,17 @@ var BaseWritableResource = class {
     }
     return this.value() !== void 0;
   });
+  _snapshot;
+  get snapshot() {
+    return this._snapshot ??= computed(() => {
+      const status = this.status();
+      if (status === "error") {
+        return { status: "error", error: this.error() };
+      } else {
+        return { status, value: this.value() };
+      }
+    });
+  }
   hasValue() {
     return this.isValueDefined();
   }
@@ -1908,7 +2722,10 @@ var BaseWritableResource = class {
   }
 };
 var ResourceImpl = class extends BaseWritableResource {
-  constructor(request, loaderFn, defaultValue, equal, injector) {
+  constructor(request, loaderFn, defaultValue, equal, debugName, injector, transferCacheKey, getInitialStream) {
+    if (isInParamsFunction()) {
+      throw invalidResourceCreationInParams();
+    }
     super(
       // Feed a computed signal for the value to `BaseWritableResource`, which will upgrade it to a
       // `WritableSignal` that delegates to `ResourceImpl.set`.
@@ -1926,45 +2743,91 @@ var ResourceImpl = class extends BaseWritableResource {
           }
           return streamValue.value;
         },
-        { equal }
-      )
+        { equal, ...ngDevMode ? createDebugNameObject(debugName, "value") : void 0 }
+      ),
+      debugName
     );
     this.loaderFn = loaderFn;
     this.equal = equal;
-    this.extRequest = linkedSignal({
-      source: request,
-      computation: (request2) => ({ request: request2, reload: 0 })
-    });
+    this.debugName = debugName;
+    this.transferCacheKey = transferCacheKey;
+    const cacheState = injector.get(CACHE_ACTIVE, void 0, { optional: true }) ?? { isActive: false };
+    this.transferState = injector.get(TransferState, void 0, { optional: true }) ?? void 0;
+    this.extRequest = linkedSignal(
+      () => {
+        try {
+          setInParamsFunction(true);
+          return { request: request(paramsContext), reload: 0 };
+        } catch (error) {
+          rethrowFatalErrors(error);
+          if (error === ResourceParamsStatus.IDLE) {
+            return { status: "idle", reload: 0 };
+          } else if (error === ResourceParamsStatus.LOADING) {
+            return { status: "loading", reload: 0 };
+          }
+          return { error, reload: 0 };
+        } finally {
+          setInParamsFunction(false);
+        }
+      },
+      ngDevMode ? createDebugNameObject(debugName, "extRequest") : void 0
+    );
     this.state = linkedSignal({
       // Whenever the request changes,
       source: this.extRequest,
       // Compute the state of the resource given a change in status.
       computation: (extRequest, previous) => {
-        const status = extRequest.request === void 0 ? "idle" : "loading";
-        if (!previous) {
-          return {
-            extRequest,
-            status,
-            previousStatus: "idle",
-            stream: void 0
-          };
-        } else {
-          return {
-            extRequest,
-            status,
-            previousStatus: projectStatusOfState(previous.value),
-            // If the request hasn't changed, keep the previous stream.
-            stream: previous.value.extRequest.request === extRequest.request ? previous.value.stream : void 0
-          };
+        let { request: request2, status, error } = extRequest;
+        let stream;
+        if (error) {
+          status = "resolved";
+          stream = signal({ error: encapsulateResourceError(error) }, ngDevMode ? createDebugNameObject(this.debugName, "stream") : void 0);
+        } else if (!status) {
+          if (!previous) {
+            const transferState = this.transferState;
+            const cacheKey = this.transferCacheKey;
+            if (cacheState.isActive && cacheKey && transferState && request2 !== void 0) {
+              const key = this.transferCacheKey;
+              if (transferState.hasKey(cacheKey)) {
+                stream = signal({ value: transferState.get(cacheKey, defaultValue) }, ngDevMode ? createDebugNameObject(this.debugName, "stream") : void 0);
+              }
+            }
+            if (!stream) {
+              stream = getInitialStream?.(extRequest.request);
+            }
+            getInitialStream = void 0;
+            status = request2 === void 0 ? "idle" : stream ? "resolved" : "loading";
+          } else {
+            status = request2 === void 0 ? "idle" : "loading";
+            if (previous.value.extRequest.request === request2) {
+              stream = previous.value.stream;
+            }
+          }
         }
-      }
+        return {
+          extRequest,
+          status,
+          previousStatus: previous ? projectStatusOfState(previous.value) : "idle",
+          stream
+        };
+      },
+      ...ngDevMode ? createDebugNameObject(debugName, "state") : void 0
     });
     this.effectRef = effect(this.loadEffect.bind(this), {
       injector,
-      manualCleanup: true
+      manualCleanup: true,
+      ...ngDevMode ? createDebugNameObject(debugName, "loadEffect") : void 0
     });
     this.pendingTasks = injector.get(PendingTasks);
     this.unregisterOnDestroy = injector.get(DestroyRef).onDestroy(() => this.destroy());
+    this.status = computed(() => projectStatusOfState(this.state()), ngDevMode ? createDebugNameObject(debugName, "status") : void 0);
+    this.error = computed(
+      () => {
+        const stream = this.state().stream?.();
+        return stream && !isResolved(stream) ? stream.error : void 0;
+      },
+      ngDevMode ? createDebugNameObject(debugName, "error") : void 0
+    );
   }
   pendingTasks;
   /**
@@ -1981,11 +2844,9 @@ var ResourceImpl = class extends BaseWritableResource {
   resolvePendingTask = void 0;
   destroyed = false;
   unregisterOnDestroy;
-  status = computed(() => projectStatusOfState(this.state()));
-  error = computed(() => {
-    const stream = this.state().stream?.();
-    return stream && !isResolved(stream) ? stream.error : void 0;
-  });
+  status;
+  error;
+  transferState;
   /**
    * Called either directly via `WritableResource.set` or via `.value.set()`.
    */
@@ -2005,7 +2866,7 @@ var ResourceImpl = class extends BaseWritableResource {
       extRequest: state.extRequest,
       status: "local",
       previousStatus: "local",
-      stream: signal({ value })
+      stream: signal({ value }, ngDevMode ? createDebugNameObject(this.debugName, "stream") : void 0)
     });
     this.abortInProgressLoad();
   }
@@ -2041,27 +2902,48 @@ var ResourceImpl = class extends BaseWritableResource {
     let resolvePendingTask = this.resolvePendingTask = this.pendingTasks.add();
     const { signal: abortSignal } = this.pendingController = new AbortController();
     try {
-      const stream = await untracked2(
+      const stream = untracked2(
         () => this.loaderFn({
           params: extRequest.request,
-          // TODO(alxhub): cleanup after g3 removal of `request` alias.
-          request: extRequest.request,
           abortSignal,
           previous: {
             status: previousStatus
           }
         })
       );
-      if (abortSignal.aborted || untracked2(this.extRequest) !== extRequest) {
-        return;
+      const shouldDiscard = () => abortSignal.aborted || untracked2(this.extRequest) !== extRequest;
+      if (isSignal2(stream)) {
+        if (shouldDiscard()) {
+          return;
+        }
+        this.state.set({
+          extRequest,
+          status: "resolved",
+          previousStatus: "resolved",
+          stream
+        });
+        const result = untracked2(stream);
+        if (true) {
+          saveToTransferState(result, this.transferCacheKey, this.transferState);
+        }
+      } else {
+        const resolvedStream = await stream;
+        if (shouldDiscard()) {
+          return;
+        }
+        this.state.set({
+          extRequest,
+          status: "resolved",
+          previousStatus: "resolved",
+          stream: resolvedStream
+        });
+        const result = resolvedStream ? untracked2(resolvedStream) : void 0;
+        if (true) {
+          saveToTransferState(result, this.transferCacheKey, this.transferState);
+        }
       }
-      this.state.set({
-        extRequest,
-        status: "resolved",
-        previousStatus: "resolved",
-        stream
-      });
     } catch (err) {
+      rethrowFatalErrors(err);
       if (abortSignal.aborted || untracked2(this.extRequest) !== extRequest) {
         return;
       }
@@ -2069,7 +2951,7 @@ var ResourceImpl = class extends BaseWritableResource {
         extRequest,
         status: "resolved",
         previousStatus: "error",
-        stream: signal({ error: encapsulateResourceError(err) })
+        stream: signal({ error: encapsulateResourceError(err) }, ngDevMode ? createDebugNameObject(this.debugName, "stream") : void 0)
       });
     } finally {
       resolvePendingTask?.();
@@ -2083,6 +2965,11 @@ var ResourceImpl = class extends BaseWritableResource {
     this.resolvePendingTask = void 0;
   }
 };
+function saveToTransferState(result, transferCacheKey, transferState) {
+  if (transferCacheKey && transferState && result && isResolved(result)) {
+    transferState.set(transferCacheKey, result.value);
+  }
+}
 function wrapEqualityFn(equal) {
   return (a, b) => a === void 0 || b === void 0 ? a === b : equal(a, b);
 }
@@ -2092,9 +2979,9 @@ function getLoader(options) {
   }
   return async (params) => {
     try {
-      return signal({ value: await options.loader(params) });
+      return signal({ value: await options.loader(params) }, ngDevMode ? createDebugNameObject(options.debugName, "stream") : void 0);
     } catch (err) {
-      return signal({ error: encapsulateResourceError(err) });
+      return signal({ error: encapsulateResourceError(err) }, ngDevMode ? createDebugNameObject(options.debugName, "stream") : void 0);
     }
   };
 }
@@ -2114,23 +3001,171 @@ function projectStatusOfState(state) {
 function isResolved(state) {
   return state.error === void 0;
 }
+function createDebugNameObject(resourceDebugName, internalSignalDebugName) {
+  return {
+    debugName: `Resource${resourceDebugName ? "#" + resourceDebugName : ""}.${internalSignalDebugName}`
+  };
+}
 function encapsulateResourceError(error) {
-  if (error instanceof Error) {
+  if (isErrorLike(error)) {
     return error;
   }
   return new ResourceWrappedError(error);
 }
+function isErrorLike(error) {
+  return error instanceof Error || typeof error === "object" && typeof error.name === "string" && typeof error.message === "string";
+}
 var ResourceValueError = class extends Error {
   constructor(error) {
-    super(error.message, { cause: error });
+    super(ngDevMode ? `Resource is currently in an error state (see Error.cause for details): ${error.message}` : error.message, { cause: error });
   }
 };
 var ResourceWrappedError = class extends Error {
   constructor(error) {
-    super(String(error), { cause: error });
+    super(ngDevMode ? `Resource returned an error that's not an Error instance: ${String(error)}. Check this error's .cause for the actual error.` : String(error), { cause: error });
+  }
+};
+function chain(resource2) {
+  switch (resource2.status()) {
+    case "idle":
+      throw ResourceParamsStatus.IDLE;
+    case "error":
+      throw new ResourceDependencyError(resource2);
+    case "loading":
+    case "reloading":
+      throw ResourceParamsStatus.LOADING;
+  }
+  return resource2.value();
+}
+var paramsContext = {
+  chain
+};
+var inParamsFunction = false;
+function isInParamsFunction() {
+  return inParamsFunction;
+}
+function setInParamsFunction(value) {
+  inParamsFunction = value;
+}
+function invalidResourceCreationInParams() {
+  return new RuntimeError(992 /* INVALID_RESOURCE_CREATION_IN_PARAMS */, ngDevMode && `Cannot create a resource inside the \`params\` of another resource`);
+}
+function rethrowFatalErrors(error) {
+  if (error instanceof RuntimeError && error.code === 992 /* INVALID_RESOURCE_CREATION_IN_PARAMS */) {
+    throw error;
+  }
+}
+
+// src/import/resource/from_snapshots.ts
+function resourceFromSnapshots(source) {
+  return new SnapshotResource(isSignal2(source) ? source : computed(source));
+}
+var SnapshotResource = class {
+  constructor(snapshot) {
+    this.snapshot = snapshot;
+  }
+  get state() {
+    return this.snapshot();
+  }
+  value = computed(() => {
+    if (this.state.status === "error") {
+      throw new ResourceValueError(this.state.error);
+    }
+    return this.state.value;
+  });
+  status = computed(() => this.state.status);
+  error = computed(() => this.state.status === "error" ? this.state.error : void 0);
+  isLoading = computed(() => this.state.status === "loading" || this.state.status === "reloading");
+  isValueDefined = computed(() => this.state.status !== "error" && this.state.value !== void 0);
+  hasValue() {
+    return this.isValueDefined();
   }
 };
 
+// src/import/resource/debounce.ts
+function debounced(source, wait, options) {
+  if (isInParamsFunction()) {
+    throw invalidResourceCreationInParams();
+  }
+  if (ngDevMode && !options?.injector) {
+    assertInInjectionContext(debounced);
+  }
+  const injector = options?.injector ?? inject2(Injector);
+  let active;
+  let pendingValue;
+  injector.get(DestroyRef).onDestroy(() => {
+    active = void 0;
+  });
+  const state = linkedSignal({
+    source: () => {
+      try {
+        setInParamsFunction(true);
+        return { value: source(), thrown: false };
+      } catch (err) {
+        rethrowFatalErrors(err);
+        return { error: err, thrown: true };
+      } finally {
+        setInParamsFunction(false);
+      }
+    },
+    computation: (res, previous) => {
+      if (previous !== void 0) {
+        return previous.value;
+      }
+      if (res.thrown) {
+        return { status: "error", error: res.error };
+      }
+      return { status: "resolved", value: res.value };
+    }
+  });
+  effect(
+    () => {
+      let value;
+      try {
+        setInParamsFunction(true);
+        value = source();
+      } catch (err) {
+        rethrowFatalErrors(err);
+        state.set({ status: "error", error: err });
+        active = pendingValue = void 0;
+        return;
+      } finally {
+        setInParamsFunction(false);
+      }
+      const currentState = untracked2(state);
+      const equal = options?.equal ?? Object.is;
+      if (currentState.status === "reloading" || currentState.status === "loading") {
+        if (equal(value, pendingValue)) return;
+      } else if (currentState.status === "resolved") {
+        if (equal(value, currentState.value)) return;
+      }
+      const waitFn = typeof wait === "number" ? () => new Promise((resolve) => setTimeout(resolve, wait)) : wait;
+      const result = waitFn(value, currentState);
+      if (result === void 0) {
+        state.set({ status: "resolved", value });
+        active = pendingValue = void 0;
+      } else {
+        if (currentState.status !== "loading" && currentState.status !== "error") {
+          state.set({ status: "loading", value: currentState.value });
+        }
+        active = result;
+        pendingValue = value;
+        result.then(() => {
+          if (active === result) {
+            state.set({ status: "resolved", value });
+            active = pendingValue = void 0;
+          }
+        });
+      }
+    },
+    { injector }
+  );
+  return resourceFromSnapshots(state);
+}
+
+// src/import/interface/type.ts
+var Type = Function;
+
 // src/import/index.ts
 function Injectable(args) {
   return (constructor) => {
@@ -2163,6 +3198,7 @@ function createRootInjector(options) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  APP_ID,
   ChangeDetectionScheduler,
   ChangeDetectionSchedulerImpl,
   DecoratorFlags,
@@ -2170,6 +3206,7 @@ function createRootInjector(options) {
   EffectScheduler,
   EnvironmentInjector,
   ErrorHandler,
+  EventEmitter,
   INJECTOR_SCOPE,
   INTERNAL_APPLICATION_ERROR_HANDLER,
   Inject,
@@ -2183,20 +3220,20 @@ function createRootInjector(options) {
   NotificationSource,
   NullInjector,
   Optional,
-  PROVIDED_ZONELESS,
   PendingTasks,
-  PendingTasksInternal,
   R3Injector,
+  ResourceDependencyError,
+  ResourceParamsStatus,
   RetrievingInjector,
   RootStaticInjectOptions,
-  SCHEDULE_IN_ROOT_ZONE,
   SOURCE,
   Self,
   SkipSelf,
   StaticInjectOptions,
   THROW_IF_NOT_FOUND,
-  ZONELESS_ENABLED,
-  ZONELESS_SCHEDULER_DISABLED,
+  TransferState,
+  Type,
+  assertInInjectionContext,
   assertNotDestroyed,
   assertNotInReactiveContext,
   attachInjectFlag,
@@ -2204,8 +3241,9 @@ function createRootInjector(options) {
   convertToBitFlags,
   createInjector,
   createRootInjector,
+  debounced,
   effect,
-  formatError,
+  forwardRef,
   getCurrentInjector,
   getInheritedInjectableDef,
   getInjectFlag,
@@ -2214,12 +3252,20 @@ function createRootInjector(options) {
   getNullInjector,
   inject,
   injectArgs,
+  injectAsync,
   injectInjectorOnly,
   isInjectable,
   isSignal,
+  isWritableSignal,
   linkedSignal,
+  makeStateKey,
+  onIdle,
+  provideIdleServiceWith,
   providerToFactory,
+  resolveForwardRef,
   resource,
+  resourceFromSnapshots,
+  runInInjectionContext,
   setCurrentInjector,
   signal,
   untracked,
@@ -2239,11 +3285,4 @@ function createRootInjector(options) {
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.dev/license
  */
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
 //# sourceMappingURL=index.js.map