static-injector 6.3.1 → 6.4.0

package/index.mjs

@@ -1,3 +1,6 @@
+// script/shim.js
+var ngDevMode = typeof ngDevMode === "undefined" ? true : ngDevMode;
+
 // src/import/di/interface/provider.ts
 function isEnvironmentProviders(value) {
   return value && !!value.ɵproviders;
@@ -15,17 +18,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://v20.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) {
@@ -33,41 +34,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
@@ -109,1237 +76,1599 @@ 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;
+      return;
+    }
+  }
+  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;
   } 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;
+function consumerBeforeComputation(node) {
+  if (node) resetConsumerBeforeComputation(node);
+  return setActiveConsumer(node);
+}
+function resetConsumerBeforeComputation(node) {
+  node.producersTail = void 0;
+  node.recomputing = true;
+}
+function consumerAfterComputation(node, prevConsumer) {
+  setActiveConsumer(prevConsumer);
+  if (node) finalizeConsumerAfterComputation(node);
+}
+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;
+    }
   }
-  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;
+}
+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;
     }
   }
-};
-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);
+  return false;
+}
+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 producerAddLiveConsumer(node, link) {
+  const consumersTail = node.consumersTail;
+  const wasLive = consumerIsLive(node);
+  if (consumersTail !== void 0) {
+    link.nextConsumer = consumersTail.nextConsumer;
+    consumersTail.nextConsumer = link;
   } else {
-    const options = convertToInjectOptions(flags);
-    const value = currentInjector.retrieve(token, options);
-    if (isNotFound(value)) {
-      if (options.optional) {
-        return null;
-      }
-      throw value;
+    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);
     }
-    return value;
   }
 }
-function ɵɵinject(token, flags = 0 /* Default */) {
-  return (getInjectImplementation() || injectInjectorOnly)(resolveForwardRef(token), flags);
+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);
+      }
+    }
+  }
+  return nextProducer;
 }
-function ɵɵinvalidFactoryDep(index) {
-  throw new RuntimeError(202 /* INVALID_FACTORY_DEPENDENCY */, void 0);
+function consumerIsLive(node) {
+  return node.consumerIsAlwaysLive || node.consumers !== void 0;
 }
-function inject2(token, options) {
-  return ɵɵinject(token, convertToBitFlags(options));
+function runPostProducerCreatedFn(node) {
+  postProducerCreatedFn?.(node);
 }
-function convertToBitFlags(flags) {
-  if (typeof flags === "undefined" || typeof flags === "number") {
-    return flags;
+function isValidLink(checkLink, consumer) {
+  const producersTail = consumer.producersTail;
+  if (producersTail !== void 0) {
+    let link = consumer.producers;
+    do {
+      if (link === checkLink) {
+        return true;
+      }
+      if (link === producersTail) {
+        break;
+      }
+      link = link.nextProducer;
+    } while (link !== 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 */)
-  };
+  return false;
 }
-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;
-          }
+
+// 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 {
+      return ["span", "Signal(⚠️ Error)"];
+    }
+    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 {
-          type = meta;
+          return prettifyPreview(value);
         }
+      })(),
+      ["span", {}, `)`]
+    ];
+  },
+  hasBody: (sig, config) => {
+    if (!isSignal(sig)) return false;
+    try {
+      sig();
+    } catch {
+      return false;
+    }
+    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, skipFormatting: true } }]]
+    ];
+  }
+};
+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} {}`;
       }
-      args.push(ɵɵinject(type, flags));
-    } else {
-      args.push(ɵɵinject(arg));
+    }
+    default: {
+      return ["object", { object: value, config: { skipFormatting: true } }];
     }
   }
-  return args;
-}
-function attachInjectFlag(decorator, flag) {
-  decorator[DI_DECORATOR_FLAG] = flag;
-  decorator.prototype[DI_DECORATOR_FLAG] = flag;
-  return decorator;
 }
-function getInjectFlag(token) {
-  return token[DI_DECORATOR_FLAG];
+function isSignal(value) {
+  return value[SIGNAL] !== void 0;
 }
-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)));
-      }
-    }
-    context = `{${parts.join(", ")}}`;
+function installDevToolsSignalFormatter() {
+  globalThis.devtoolsFormatters ??= [];
+  if (!globalThis.devtoolsFormatters.some((f) => f === formatter)) {
+    globalThis.devtoolsFormatters.push(formatter);
   }
-  return `${injectorErrorName}${source ? "(" + source + ")" : ""}[${context}]: ${text.replace(NEW_LINE, "\n  ")}`;
 }
 
-// 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/primitives/signals/src/equality.ts
+function defaultEquals(a, b) {
+  return Object.is(a, b);
+}
 
-// 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;
-    }
-    return notFoundValue;
+// 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 (typeof ngDevMode !== "undefined" && ngDevMode) {
+    const debugName = node.debugName ? " (" + node.debugName + ")" : "";
+    computed2.toString = () => `[Computed${debugName}: ${node.value}]`;
+  }
+  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." : "");
+    }
+    const oldValue = node.value;
+    node.value = COMPUTING;
+    const prevConsumer = consumerBeforeComputation(node);
+    let newValue;
+    let wasEqual = false;
+    try {
+      newValue = node.computation();
+      setActiveConsumer(null);
+      wasEqual = oldValue !== UNSET && oldValue !== ERRORED && 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++;
+  }
+}))();
 
-// 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;
+// src/primitives/signals/src/errors.ts
+function defaultThrowError() {
+  throw new Error();
 }
-function isExistingProvider(value) {
-  return !!(value && value.useExisting);
+var throwInvalidWriteToSignalErrorFn = defaultThrowError;
+function throwInvalidWriteToSignalError(node) {
+  throwInvalidWriteToSignalErrorFn(node);
 }
-function isFactoryProvider(value) {
-  return !!(value && value.useFactory);
+
+// 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;
+  }
+  const getter = () => signalGetFn(node);
+  getter[SIGNAL] = node;
+  if (typeof ngDevMode !== "undefined" && ngDevMode) {
+    const debugName = node.debugName ? " (" + node.debugName + ")" : "";
+    getter.toString = () => `[Signal${debugName}: ${node.value}]`;
+  }
+  runPostProducerCreatedFn(node);
+  const set = (newValue) => signalSetFn(node, newValue);
+  const update = (updateFn) => signalUpdateFn(node, updateFn);
+  return [getter, set, update];
 }
-function isTypeProvider(value) {
-  return typeof value === "function";
+function signalGetFn(node) {
+  producerAccessed(node);
+  return node.value;
 }
-
-// src/import/di/scope.ts
-var INJECTOR_SCOPE = new InjectionToken("");
-
-// 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();
+function signalSetFn(node, newValue) {
+  if (!producerUpdatesAllowed()) {
+    throwInvalidWriteToSignalError(node);
+  }
+  if (!node.equal(node.value, newValue)) {
+    node.value = newValue;
+    signalValueChanged(node);
   }
-  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);
-    }
-    this.injectorDefTypes = new Set(this.get(INJECTOR_DEF_TYPES, EMPTY_ARRAY, { self: true }));
+function signalUpdateFn(node, updater) {
+  if (!producerUpdatesAllowed()) {
+    throwInvalidWriteToSignalError(node);
   }
-  /**
-   * 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;
+  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;
   }
-  _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;
+  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) {
+    const debugName = node.debugName ? " (" + node.debugName + ")" : "";
+    getter.toString = () => `[LinkedSignal${debugName}: ${node.value}]`;
   }
-  /**
-   * 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;
+  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);
+}
+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;
     try {
-      for (const service of this._ngOnDestroyHooks) {
-        service.ngOnDestroy();
-      }
-      const onDestroyHooks = this._onDestroyHooks;
-      this._onDestroyHooks = [];
-      for (const hook of onDestroyHooks) {
-        hook();
-      }
+      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 {
-      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) {
-    }
-    try {
-      return fn();
-    } finally {
-      setCurrentInjector(previousInjector);
-      setInjectImplementation(previousInjectImplementation);
-    }
-  }
-  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);
-    }
-  }
-  /** @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);
-    }
-  }
-  toString() {
-    const tokens = [];
-    const records = this.records;
-    for (const token of records.keys()) {
-      tokens.push(stringify(token));
-    }
-    return `R3Injector[${tokens.join(", ")}]`;
-  }
-  /**
-   * Process a `SingleProvider` and add it.
-   */
-  processProvider(provider) {
-    provider = resolveForwardRef(provider);
-    let token = isTypeProvider(provider) ? provider : resolveForwardRef(provider && provider.provide);
-    const record = providerToRecord(provider);
-    if (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);
-  }
-  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 {
-    }
-  }
-  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);
+      consumerAfterComputation(node, prevConsumer);
     }
-  }
-  removeOnDestroy(callback) {
-    const destroyCBIdx = this._onDestroyHooks.indexOf(callback);
-    if (destroyCBIdx !== -1) {
-      this._onDestroyHooks.splice(destroyCBIdx, 1);
+    if (oldValue !== UNSET && newValue !== ERRORED && node.equal(oldValue, newValue)) {
+      node.value = oldValue;
+      return;
     }
+    node.value = newValue;
+    node.version++;
   }
-};
-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 */, void 0);
-  }
-  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 hasOnDestroy(value) {
-  return value !== null && typeof value === "object" && typeof value.ngOnDestroy === "function";
+function ɵɵdefineInjector(options) {
+  return { providers: options.providers || [], imports: options.imports || [] };
 }
-function couldBeInjectableType(value) {
-  return typeof value === "function" || typeof value === "object" && value.ngMetadataName === "InjectionToken";
+function getInjectableDef(type) {
+  return getOwnDefinition(type, NG_PROV_DEF) || { token: type, factory: () => new type(), ...type.injectOptions };
 }
-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);
-    }
-  }
-}
-
-// src/import/util/closure.ts
-function noSideEffects(fn) {
-  return { toString: fn }.toString();
-}
-
-// 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];
-      }
-    }
-  };
+function isInjectable(type) {
+  return getInjectableDef(type) !== null;
 }
-function makeParamDecorator(name, props, parentClass) {
-  return noSideEffects(() => {
-    const metaCtor = makeMetadataCtor(props);
-    function ParamDecoratorFactory(...args) {
-      metaCtor.apply(this, args);
-      return this;
-    }
-    if (parentClass) {
-    }
-    return ParamDecoratorFactory;
-  });
+function getOwnDefinition(type, field) {
+  return type.hasOwnProperty(field) && type[field] || null;
 }
-
-// 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 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;
+  }
 }
-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 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/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/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") {
+      (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
+      });
     }
   }
-  /** @nocollapse */
-  static ɵprov = (
-    /** @pureOrBreakMyCode */
-    /* @__PURE__ */ ɵɵdefineInjectable({
-      token: _Injector,
-      providedIn: "any",
-      factory: () => ɵɵinject(INJECTOR)
-    })
-  );
+  /** @internal */
+  ngMetadataName = "InjectionToken";
+  ɵprov;
   /**
    * @internal
-   * @nocollapse
    */
-  static __NG_ELEMENT_ID__ = -1 /* Injector */;
+  get multi() {
+    return this;
+  }
+  toString() {
+    return `InjectionToken ${this._desc}`;
+  }
 };
 
-// src/import/render3/instructions/di.ts
-function ɵɵinvalidFactory() {
-  const msg = "invalid";
-  throw new Error(msg);
-}
-
-// 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 getActiveConsumer() {
-  return activeConsumer;
+// 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;
 }
-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: () => {
+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);
   }
-};
-function producerAccessed(node) {
-  if (inNotificationPhase) {
-    throw new Error(false ? `Assertion error: signal read during notification phase` : "");
+  let provider = eventProvider;
+  if (eventProvider instanceof InjectionToken) {
+    provider = eventProvider.ɵprov || eventProvider;
   }
-  if (activeConsumer === null) {
-    return;
+  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: 4 /* 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);
   }
-  activeConsumer.consumerOnSignalRead(node);
-  const prevProducerLink = activeConsumer.producersTail;
-  if (prevProducerLink !== void 0 && prevProducerLink.producer === node) {
-    return;
+}
+
+// src/import/render3/definition_factory.ts
+function getFactoryDef(type, throwNotFound) {
+  return () => new type();
+}
+
+// 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();
   }
-  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;
+  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.`);
     }
-  }
-  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;
   } else {
-    activeConsumer.producers = newLink;
-  }
-  if (isLive) {
-    producerAddLiveConsumer(node, newLink);
+    throw new Error("Invalid provider");
   }
 }
-function producerIncrementEpoch() {
-  epoch++;
+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 producerUpdateValueVersion(node) {
-  if (consumerIsLive(node) && !node.dirty) {
-    return;
+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 (!node.dirty && node.lastCleanEpoch === epoch) {
-    return;
+  if (currentPath[0] !== pathStr) {
+    error[NG_TOKEN_PATH].unshift(pathStr);
   }
-  if (!node.producerMustRecompute(node) && !consumerPollProducersForChange(node)) {
-    producerMarkClean(node);
-    return;
+}
+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;
   }
-  node.producerRecomputeValue(node);
-  producerMarkClean(node);
+  return error;
 }
-function producerNotifyConsumers(node) {
-  if (node.consumers === void 0) {
-    return;
+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 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);
+  const sourceDetails = source ? ` Source: ${source}.` : "";
+  return formatRuntimeError(code, `${text}${sourceDetails}${pathDetails}`);
+}
+
+// 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);
+  }
+  return list;
+}
+
+// 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/import/di/initializer_token.ts
+var ENVIRONMENT_INITIALIZER = new InjectionToken(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 setInjectImplementation(impl) {
+  const previous = _injectImplementation;
+  _injectImplementation = impl;
+  return previous;
+}
+function injectRootLimpMode(token, notFoundValue, flags) {
+  const injectableDef = getInjectableDef(token);
+  if (injectableDef && injectableDef.providedIn == "root") {
+    return injectableDef.value === void 0 ? injectableDef.value = injectableDef.factory() : injectableDef.value;
+  }
+  if (flags & 8 /* 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 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;
+  }
+  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 */,
+      ngDevMode && `The \`${stringify(token)}\` token injection failed. \`inject()\` function must be called from an injection context such as a constructor, a factory function, a field initializer, or a function used with \`runInInjectionContext\`.`
+    );
+  } else if (currentInjector === null) {
+    return injectRootLimpMode(token, void 0, flags);
+  } else {
+    const options = convertToInjectOptions(flags);
+    const value = currentInjector.retrieve(token, options);
+    ngDevMode && emitInjectEvent(token, value, flags);
+    if (isNotFound(value)) {
+      if (options.optional) {
+        return null;
+      }
+      throw value;
+    }
+    return value;
+  }
+}
+function ɵɵinject(token, flags = 0 /* Default */) {
+  return (getInjectImplementation() || injectInjectorOnly)(resolveForwardRef(token), flags);
+}
+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 inject2(token, options) {
+  return ɵɵinject(token, convertToBitFlags(options));
+}
+function convertToBitFlags(flags) {
+  if (typeof flags === "undefined" || typeof flags === "number") {
+    return flags;
+  }
+  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));
+    }
+  }
+  return args;
+}
+function attachInjectFlag(decorator, flag) {
+  decorator[DI_DECORATOR_FLAG] = flag;
+  decorator.prototype[DI_DECORATOR_FLAG] = flag;
+  return decorator;
+}
+function getInjectFlag(token) {
+  return token[DI_DECORATOR_FLAG];
+}
+function 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)));
+      }
+    }
+    context = `{${parts.join(", ")}}`;
+  }
+  return `${injectorErrorName}${source ? "(" + source + ")" : ""}[${context}]: ${text.replace(NEW_LINE, "\n  ")}`;
+}
+
+// src/import/di/injector_token.ts
+var INJECTOR = new InjectionToken(
+  ngDevMode ? "INJECTOR" : "",
+  // Disable tslint because this is const enum which gets inlined not top level prop access.
+  // tslint:disable-next-line: no-toplevel-property-access
+  -1 /* Injector */
+  // Special value used by Ivy to identify `Injector`.
+);
+
+// src/import/di/internal_tokens.ts
+var INJECTOR_DEF_TYPES = new InjectionToken(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
+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 isFactoryProvider(value) {
+  return !!(value && value.useFactory);
+}
+function isTypeProvider(value) {
+  return typeof value === "function";
+}
+
+// src/import/di/scope.ts
+var INJECTOR_SCOPE = new InjectionToken(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));
+    }
+    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 }));
+  }
+  /**
+   * 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;
+    }
+  }
+  /**
+   * 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();
+    }
+  }
+  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);
+    }
+  }
+  /** @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);
+    }
+  }
+  toString() {
+    const tokens = [];
+    const records = this.records;
+    for (const token of records.keys()) {
+      tokens.push(stringify(token));
+    }
+    return `R3Injector[${tokens.join(", ")}]`;
+  }
+  /**
+   * Process a `SingleProvider` and add it.
+   */
+  processProvider(provider) {
+    provider = resolveForwardRef(provider);
+    let token = isTypeProvider(provider) ? provider : resolveForwardRef(provider && provider.provide);
+    const record = providerToRecord(provider);
+    if (ngDevMode) {
+      runInInjectorProfilerContext(this, token, () => {
+        if (isValueProvider(provider)) {
+          emitInjectorToCreateInstanceEvent(token);
+          emitInstanceCreatedByInjectorEvent(provider.useValue);
+        }
+        emitProviderConfiguredEvent(provider);
+      });
+    }
+    if (!isTypeProvider(provider) && provider.multi === true) {
+      let multiRecord = this.records.get(token);
+      if (multiRecord) {
+        if (ngDevMode && multiRecord.multi === void 0) {
+          throwMixedMultiProviderError();
+        }
+      } else {
+        multiRecord = makeRecord(void 0, NOT_YET, true);
+        multiRecord.factory = () => injectArgs(multiRecord.multi);
+        this.records.set(token, multiRecord);
+      }
+      token = provider;
+      multiRecord.multi.push(provider);
+    } else {
+      if (ngDevMode) {
+        const existing = this.records.get(token);
+        if (existing && existing.multi !== void 0) {
+          throwMixedMultiProviderError();
+        }
+      }
+    }
+    this.records.set(token, record);
+  }
+  hydrate(token, record, flags) {
+    try {
+      if (record.value === CIRCULAR) {
+        throw cyclicDependencyError(stringify(token));
+      } else if (record.value === NOT_YET) {
+        record.value = CIRCULAR;
+        if (ngDevMode) {
+          runInInjectorProfilerContext(this, token, () => {
+            emitInjectorToCreateInstanceEvent(token);
+            record.value = record.factory(void 0, flags);
+            emitInstanceCreatedByInjectorEvent(record.value);
+          });
+        } else {
+          record.value = record.factory(void 0, flags);
+        }
+      }
+      if (typeof record.value === "object" && record.value && hasOnDestroy(record.value)) {
+        this._ngOnDestroyHooks.add(record.value);
       }
+      return record.value;
+    } finally {
     }
-  } finally {
-    inNotificationPhase = prev;
   }
-}
-function producerUpdatesAllowed() {
-  return activeConsumer?.consumerAllowSignalWrites !== false;
-}
-function consumerMarkDirty(node) {
-  node.dirty = true;
-  producerNotifyConsumers(node);
-  node.consumerMarkedDirty?.(node);
-}
-function producerMarkClean(node) {
-  node.dirty = false;
-  node.lastCleanEpoch = epoch;
-}
-function consumerBeforeComputation(node) {
-  if (node) resetConsumerBeforeComputation(node);
-  return setActiveConsumer(node);
-}
-function resetConsumerBeforeComputation(node) {
-  node.producersTail = void 0;
-  node.recomputing = true;
-}
-function consumerAfterComputation(node, prevConsumer) {
-  setActiveConsumer(prevConsumer);
-  if (node) finalizeConsumerAfterComputation(node);
-}
-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);
+  injectableDefInScope(def) {
+    if (!def.providedIn) {
+      return false;
     }
-    if (producersTail !== void 0) {
-      producersTail.nextProducer = void 0;
+    const providedIn = resolveForwardRef(def.providedIn);
+    if (typeof providedIn === "string") {
+      return providedIn === "any" || this.scopes.has(providedIn);
     } else {
-      node.producers = void 0;
+      return this.injectorDefTypes.has(providedIn);
     }
   }
-}
-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;
+  removeOnDestroy(callback) {
+    const destroyCBIdx = this._onDestroyHooks.indexOf(callback);
+    if (destroyCBIdx !== -1) {
+      this._onDestroyHooks.splice(destroyCBIdx, 1);
     }
   }
-  return false;
-}
-function consumerDestroy(node) {
-  if (consumerIsLive(node)) {
-    let link = node.producers;
-    while (link !== void 0) {
-      link = producerRemoveLiveConsumerLink(link);
-    }
+};
+function injectableDefOrInjectorDefFactory(token) {
+  const injectableDef = getInjectableDef(token);
+  const factory = injectableDef !== null ? injectableDef.factory : getFactoryDef(token);
+  if (factory !== null) {
+    return factory;
   }
-  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;
+  if (token instanceof InjectionToken) {
+    throw new RuntimeError(204 /* INVALID_INJECTION_TOKEN */, ngDevMode && `Token ${stringify(token)} is missing a ɵprov definition.`);
   }
-  link.prevConsumer = consumersTail;
-  node.consumersTail = link;
-  if (!wasLive) {
-    for (let link2 = node.producers; link2 !== void 0; link2 = link2.nextProducer) {
-      producerAddLiveConsumer(link2.producer, link2);
-    }
+  if (token instanceof Function) {
+    return getUndecoratedInjectableFactory(token);
   }
+  throw new RuntimeError(204 /* INVALID_INJECTION_TOKEN */, ngDevMode && "unreachable");
 }
-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;
+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(", ")}).`);
   }
-  if (prevConsumer !== void 0) {
-    prevConsumer.nextConsumer = nextConsumer;
+  const inheritedInjectableDef = getInheritedInjectableDef(token);
+  if (inheritedInjectableDef !== null) {
+    return () => inheritedInjectableDef.factory(token);
   } else {
-    producer.consumers = nextConsumer;
-    if (!consumerIsLive(producer)) {
-      let producerLink = producer.producers;
-      while (producerLink !== void 0) {
-        producerLink = producerRemoveLiveConsumerLink(producerLink);
-      }
-    }
-  }
-  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;
-      }
-      if (link === producersTail) {
-        break;
-      }
-      link = link.nextProducer;
-    } while (link !== void 0);
+    return () => new token();
   }
-  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}]`;
+function providerToRecord(provider) {
+  if (isValueProvider(provider)) {
+    return makeRecord(void 0, provider.useValue);
+  } else {
+    const factory = providerToFactory(provider);
+    return makeRecord(factory, NOT_YET);
   }
-  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;
-    try {
-      newValue = node.computation();
-      setActiveConsumer(null);
-      wasEqual = oldValue !== UNSET && oldValue !== ERRORED && 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++;
+function providerToFactory(provider, ngModuleType, providers) {
+  let factory = void 0;
+  if (ngDevMode && isEnvironmentProviders(provider)) {
+    throwInvalidProviderError(void 0, providers, provider);
   }
-}))();
-
-// 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;
+  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);
+      }
+    }
   }
-  const getter = () => signalGetFn(node);
-  getter[SIGNAL] = node;
-  if (false) {
-    const debugName = node.debugName ? " (" + node.debugName + ")" : "";
-    getter.toString = () => `[Signal${debugName}: ${node.value}]`;
+  return factory;
+}
+function assertNotDestroyed(injector) {
+  if (injector.destroyed) {
+    throw new RuntimeError(205 /* INJECTOR_ALREADY_DESTROYED */, ngDevMode && "Injector has already been destroyed.");
   }
-  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 makeRecord(factory, value, multi = false) {
+  return {
+    factory,
+    value,
+    multi: multi ? [] : void 0
+  };
 }
-function signalSetFn(node, newValue) {
-  if (!producerUpdatesAllowed()) {
-    throwInvalidWriteToSignalError(node);
-  }
-  if (!node.equal(node.value, newValue)) {
-    node.value = newValue;
-    signalValueChanged(node);
-  }
+function hasDeps(value) {
+  return !!value.deps;
 }
-function signalUpdateFn(node, updater) {
-  if (!producerUpdatesAllowed()) {
-    throwInvalidWriteToSignalError(node);
-  }
-  signalSetFn(node, updater(node.value));
+function hasOnDestroy(value) {
+  return value !== null && typeof value === "object" && typeof value.ngOnDestroy === "function";
 }
-var SIGNAL_NODE = /* @__PURE__ */ (() => ({
-  ...REACTIVE_NODE,
-  equal: defaultEquals,
-  value: void 0,
-  kind: "signal"
-}))();
-function signalValueChanged(node) {
-  node.version++;
-  producerIncrementEpoch();
-  producerNotifyConsumers(node);
-  postSignalSetFn?.(node);
+function couldBeInjectableType(value) {
+  return typeof value === "function" || typeof value === "object" && value.ngMetadataName === "InjectionToken";
 }
-
-// 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 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];
+  name = name || (typeof defType === "object" ? void 0 : stringify(defType));
+  return new R3Injector(providers, parent || getNullInjector(), name || 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;
-  }
-  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 */;
+};
 
-// 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;
 }
 
 // src/import/render3/reactivity/computed.ts
 function computed(computation, options) {
   const getter = createComputed(computation, options?.equal);
-  if (false) {
+  if (ngDevMode) {
+    getter.toString = () => `[Computed: ${getter()}]`;
+    getter[SIGNAL].debugName = options?.debugName;
   }
   return getter;
 }
@@ -1355,7 +1684,9 @@ function signal(initialValue, options) {
   signalFn.set = set;
   signalFn.update = update;
   signalFn.asReadonly = signalAsReadonlyFn.bind(signalFn);
-  if (false) {
+  if (ngDevMode) {
+    signalFn.toString = () => `[Signal: ${signalFn()}]`;
+    node.debugName = options?.debugName;
   }
   return signalFn;
 }
@@ -1381,7 +1712,9 @@ function linkedSignal(optionsOrComputation, options) {
   }
 }
 function upgradeLinkedSignalGetter(getter, debugName) {
-  if (false) {
+  if (ngDevMode) {
+    getter.toString = () => `[LinkedSignal: ${getter()}]`;
+    getter[SIGNAL].debugName = debugName;
   }
   const node = getter[SIGNAL];
   const upgradedGetter = getter;
@@ -1399,7 +1732,23 @@ 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 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`"
+    );
   }
 }
 
@@ -1440,10 +1789,10 @@ 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("");
+var ZONELESS_ENABLED = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "Zoneless enabled" : "", { providedIn: "root", factory: () => false });
+var PROVIDED_ZONELESS = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "Zoneless provided" : "", { providedIn: "root", factory: () => false });
+var ZONELESS_SCHEDULER_DISABLED = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "scheduler disabled" : "");
+var SCHEDULE_IN_ROOT_ZONE = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "run changes outside zone in root" : "");
 
 // src/import/render3/reactivity/root_effect_scheduler.ts
 var EffectScheduler = class _EffectScheduler {
@@ -1538,10 +1887,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);
@@ -1554,6 +1904,15 @@ function effect(effectFn, options) {
     node.onDestroyFn = 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__ */ (() => ({
@@ -1562,7 +1921,7 @@ var EFFECT_NODE = /* @__PURE__ */ (() => ({
   zone: null,
   onDestroyFn: noop,
   run() {
-    if (false) {
+    if (ngDevMode && isInNotificationPhase()) {
       throw new Error(`Schedulers cannot synchronously execute watches while scheduling.`);
     }
     try {
@@ -1657,7 +2016,7 @@ var ErrorHandler = class {
     this._console.error("ERROR", error);
   }
 };
-var INTERNAL_APPLICATION_ERROR_HANDLER = new InjectionToken("", {
+var INTERNAL_APPLICATION_ERROR_HANDLER = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "internal error handler" : "", {
   providedIn: "root",
   factory: () => {
     const injector = inject2(EnvironmentInjector);
@@ -1780,7 +2139,8 @@ var PendingTasks = class _PendingTasks {
 
 // 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);
@@ -2029,12 +2389,12 @@ function encapsulateResourceError(error) {
 }
 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 });
   }
 };
 
@@ -2122,7 +2482,7 @@ export {
   injectArgs,
   injectInjectorOnly,
   isInjectable,
-  isSignal,
+  isSignal2 as isSignal,
   linkedSignal,
   providerToFactory,
   resource,