@k8slens/injectable 26.0.0

package/dist/index.js

@@ -0,0 +1,2182 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// index.js
+var index_exports = {};
+__export(index_exports, {
+  createContainer: () => createContainer_default,
+  deregistrationCallbackToken: () => deregistrationCallbackToken,
+  deregistrationDecoratorToken: () => deregistrationDecoratorToken,
+  getInjectable: () => getInjectable_default,
+  getInjectable2: () => getInjectable2_default,
+  getInjectableBunch: () => getInjectableBunch_default,
+  getInjectionToken: () => getInjectionToken,
+  getInjectionToken2: () => getInjectionToken2,
+  getKeyedSingletonCompositeKey: () => getKeyedSingletonCompositeKey,
+  getSpecificInjectionToken: () => getSpecificInjectionToken,
+  getTypedSpecifier: () => getTypedSpecifier,
+  injectionDecoratorToken: () => injectionDecoratorToken,
+  injectionTokenTag: () => injectionTokenTag,
+  instancePurgeCallbackToken: () => instancePurgeCallbackToken,
+  instantiationDecoratorToken: () => instantiationDecoratorToken,
+  isInjectable: () => isInjectable_default,
+  isInjectableBunch: () => isInjectableBunch_default,
+  isInjectionToken: () => isInjectionToken_default,
+  lifecycleEnum: () => lifecycleEnum_default,
+  preInjectCallbackToken: () => preInjectCallbackToken,
+  registrationCallbackToken: () => registrationCallbackToken,
+  registrationDecoratorToken: () => registrationDecoratorToken,
+  toFlatInjectables: () => toFlatInjectables_default
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/dependency-injection-container/lifecycleEnum.js
+var nonStoredInstanceKey = Symbol("non-stored-instance-key");
+var storedInstanceKey = Symbol("stored-instance-key");
+var lifecycleEnum_default = {
+  singleton: {
+    id: "singleton",
+    getInstanceKey: () => storedInstanceKey
+  },
+  keyedSingleton: ({ getInstanceKey }) => ({
+    id: "keyedSingleton",
+    getInstanceKey
+  }),
+  transient: {
+    id: "transient",
+    getInstanceKey: () => nonStoredInstanceKey
+  }
+};
+
+// src/getCompositeKey/getCompositeKey.js
+var compositeKeySymbol = Symbol("composite-key");
+var getCompositeKey = (...keys) => ({
+  [compositeKeySymbol]: true,
+  keys
+});
+var isCompositeKey = (thing) => thing && thing[compositeKeySymbol] === true;
+
+// src/getInjectable/getInjectable.js
+var injectableSymbol = "injectable";
+var getInjectable_default = ({ lifecycle = lifecycleEnum_default.singleton, ...injectable }) => ({
+  aliasType: injectableSymbol,
+  lifecycle,
+  ...injectable
+});
+
+// src/getInjectable2/getInjectable2.js
+var injectableSymbol2 = "injectable2";
+var v2DefaultLifecycle = lifecycleEnum_default.keyedSingleton({
+  getInstanceKey: (di, ...args) => {
+    if (args.length === 0) return storedInstanceKey;
+    return getCompositeKey(...args);
+  }
+});
+v2DefaultLifecycle._isV2DefaultLifecycle = true;
+var getInjectable2_default = ({ instantiate: instantiate2, transient = false, ...rest }) => ({
+  aliasType: injectableSymbol2,
+  instantiate: instantiate2,
+  transient,
+  lifecycle: transient ? lifecycleEnum_default.transient : v2DefaultLifecycle,
+  ...rest
+});
+
+// src/getInjectionToken/injectionTokenTag.js
+var injectionTokenTag = "injectionToken";
+
+// src/getInjectionToken/getInjectionToken.js
+var injectionTokenSymbol = "injection-token";
+var getInjectionToken = ({
+  specificInjectionTokenFactory: specificTokenFactory = getSpecificTokenById,
+  target,
+  tags,
+  ...rest
+}) => {
+  const specificTokensBySpeciality = /* @__PURE__ */ new Map();
+  const specificTokensBySpecifier = /* @__PURE__ */ new Map();
+  const generalToken = Object.assign(target ?? {}, {
+    ...rest,
+    tags: [injectionTokenTag, ...tags ?? []],
+    aliasType: injectionTokenSymbol,
+    for: (...specifiers) => {
+      const memoizedToken = specifiers.length === 1 ? specificTokensBySpecifier.get(specifiers[0]) : void 0;
+      if (memoizedToken) {
+        return memoizedToken;
+      }
+      const specificTokenCandidate = specificTokenFactory(...specifiers);
+      const existingSpecificToken = specificTokensBySpeciality.get(
+        specificTokenCandidate.speciality
+      );
+      if (existingSpecificToken) {
+        if (specifiers.length === 1) {
+          specificTokensBySpecifier.set(specifiers[0], existingSpecificToken);
+        }
+        return existingSpecificToken;
+      }
+      const specificToken = specificTokenCandidate;
+      specificToken.id = `${generalToken.id}/${specificToken.id}`;
+      specificToken.specificTokenOf = generalToken;
+      specificToken.maxCacheSize = generalToken.maxCacheSize;
+      specificToken.tags = generalToken.tags;
+      specificTokensBySpeciality.set(specificToken.speciality, specificToken);
+      if (specifiers.length === 1) {
+        specificTokensBySpecifier.set(specifiers[0], specificToken);
+      }
+      return specificToken;
+    }
+  });
+  return generalToken;
+};
+var getSpecificInjectionToken = (...args) => getInjectionToken(...args);
+var getSpecificTokenById = (id) => getInjectionToken({ id, speciality: id });
+
+// src/getInjectionToken2/getInjectionToken2.js
+var injectionTokenSymbol2 = "injection-token2";
+var cardinalities = ["one", "zero-or-one", "zero-or-many", "one-or-many"];
+var buildToken = ({
+  specificInjectionTokenFactory,
+  target,
+  tags,
+  ...rest
+}) => {
+  if (rest.cardinality === void 0) {
+    if (rest.speciality === void 0) {
+      throw new Error(
+        `Tried to create injection token "${rest.id}" without cardinality.`
+      );
+    }
+  } else if (!cardinalities.includes(rest.cardinality)) {
+    throw new Error(
+      `Tried to create injection token "${rest.id}" with unknown cardinality "${rest.cardinality}".`
+    );
+  }
+  const specificTokensBySpeciality = /* @__PURE__ */ new Map();
+  const specificTokensBySpecifier = /* @__PURE__ */ new Map();
+  const generalToken = Object.assign(target ?? {}, {
+    ...rest,
+    tags: [injectionTokenTag, ...tags ?? []],
+    aliasType: injectionTokenSymbol2,
+    // No factory means no `.for()` at all, matching the type: a token isn't
+    // required to be part of a family. A factory also makes the token
+    // abstract: it's only ever useful resolved via a real `.for()`, so it
+    // cannot be injected/registered directly — see checkForAbstractTokenFor
+    // and register.js's `injectionToken?.abstract` check.
+    ...specificInjectionTokenFactory && {
+      abstract: true,
+      for: (...specifiers) => {
+        const memoizedToken = specifiers.length === 1 ? specificTokensBySpecifier.get(specifiers[0]) : void 0;
+        if (memoizedToken) {
+          return memoizedToken;
+        }
+        const specificTokenCandidate = specificInjectionTokenFactory(
+          ...specifiers
+        );
+        const existingSpecificToken = specificTokensBySpeciality.get(
+          specificTokenCandidate.speciality
+        );
+        if (existingSpecificToken) {
+          if (specifiers.length === 1) {
+            specificTokensBySpecifier.set(specifiers[0], existingSpecificToken);
+          }
+          return existingSpecificToken;
+        }
+        const specificToken = specificTokenCandidate;
+        specificToken.id = `${generalToken.id}/${specificToken.id}`;
+        specificToken.specificTokenOf = generalToken;
+        specificToken.maxCacheSize = generalToken.maxCacheSize;
+        specificToken.tags = generalToken.tags;
+        specificToken.cardinality = specificToken.cardinality ?? generalToken.cardinality;
+        specificTokensBySpeciality.set(specificToken.speciality, specificToken);
+        if (specifiers.length === 1) {
+          specificTokensBySpecifier.set(specifiers[0], specificToken);
+        }
+        return specificToken;
+      }
+    }
+  });
+  return generalToken;
+};
+var getInjectionToken2 = (...args) => {
+  var _a;
+  if (args.length !== 1) {
+    throw new Error(
+      `Tried to create injection token${((_a = args[0]) == null ? void 0 : _a.id) ? ` "${args[0].id}"` : ""} with ${args.length} arguments; getInjectionToken2 takes exactly one (options).`
+    );
+  }
+  const [options] = args;
+  return (specificInjectionTokenFactory) => buildToken({ ...options, specificInjectionTokenFactory });
+};
+
+// src/dependency-injection-container/tokens.js
+var untagged = (token) => {
+  token.tags = void 0;
+  return token;
+};
+var registrationCallbackToken = untagged(
+  getInjectionToken({
+    id: "registration-callback-token"
+  })
+);
+var deregistrationCallbackToken = untagged(
+  getInjectionToken({
+    id: "deregistration-callback-token"
+  })
+);
+var instantiationDecoratorToken = untagged(
+  getInjectionToken2({
+    id: "instantiate-decorator-token",
+    cardinality: "zero-or-many"
+  })((target) => getInjectionToken2({ id: target.id, speciality: target })())
+);
+var injectionDecoratorToken = untagged(
+  getInjectionToken2({
+    id: "injection-decorator-token",
+    cardinality: "zero-or-many"
+  })((target) => getInjectionToken2({ id: target.id, speciality: target })())
+);
+var instancePurgeCallbackToken = untagged(
+  getInjectionToken2({
+    id: "instance-purge-callback-token",
+    cardinality: "zero-or-many"
+  })((target) => getInjectionToken2({ id: target.id, speciality: target })())
+);
+var registrationDecoratorToken = untagged(
+  getInjectionToken2({
+    id: "registration-decorator-token",
+    cardinality: "zero-or-many"
+  })((target) => getInjectionToken2({ id: target.id, speciality: target })())
+);
+var deregistrationDecoratorToken = untagged(
+  getInjectionToken2({
+    id: "deregistration-decorator-token",
+    cardinality: "zero-or-many"
+  })((target) => getInjectionToken2({ id: target.id, speciality: target })())
+);
+var preInjectCallbackToken = untagged(
+  getInjectionToken2({
+    id: "pre-inject-callback-token",
+    cardinality: "zero-or-many"
+  })((target) => getInjectionToken2({ id: target.id, speciality: target })())
+);
+
+// src/composite-map/composite-map.js
+var isObjectKey = (key) => typeof key === "object" && key !== null || typeof key === "function";
+var makeNode = () => ({
+  layer: /* @__PURE__ */ new Map(),
+  weakLayer: /* @__PURE__ */ new WeakMap(),
+  children: /* @__PURE__ */ new Map(),
+  weakChildren: /* @__PURE__ */ new WeakMap(),
+  hasWeakEntries: false
+});
+var CompositeMap = class {
+  #internalMap = makeNode();
+  constructor(initialValues = []) {
+    for (const [key, value] of initialValues) {
+      this.set(key, value);
+    }
+  }
+  #layerFor(mapEntry, key) {
+    return isObjectKey(key) ? mapEntry.weakLayer : mapEntry.layer;
+  }
+  #childrenFor(mapEntry, key) {
+    return isObjectKey(key) ? mapEntry.weakChildren : mapEntry.children;
+  }
+  #set(mapEntry, key, value) {
+    if (key.length === 1) {
+      const first = key[0];
+      this.#layerFor(mapEntry, first).set(first, value);
+      if (isObjectKey(first)) mapEntry.hasWeakEntries = true;
+    } else {
+      const [first, ...rest] = key;
+      const childMap = this.#childrenFor(mapEntry, first);
+      let nextMapEntry = childMap.get(first);
+      if (!nextMapEntry) {
+        nextMapEntry = makeNode();
+        childMap.set(first, nextMapEntry);
+        if (isObjectKey(first)) mapEntry.hasWeakEntries = true;
+      }
+      this.#set(nextMapEntry, rest, value);
+    }
+  }
+  set(key, value) {
+    if (!Array.isArray(key)) {
+      throw new TypeError("Expected key to be an array");
+    }
+    if (key.length === 0) {
+      throw new TypeError("Keys must be at least length 1");
+    }
+    this.#set(this.#internalMap, key, value);
+  }
+  #get(mapEntry, key) {
+    if (key.length === 1) {
+      return this.#layerFor(mapEntry, key[0]).get(key[0]);
+    } else {
+      const [first, ...rest] = key;
+      const nextMapEntry = this.#childrenFor(mapEntry, first).get(first);
+      if (!nextMapEntry) {
+        return void 0;
+      }
+      return this.#get(nextMapEntry, rest);
+    }
+  }
+  get(key) {
+    if (!Array.isArray(key)) {
+      throw new TypeError("Expected key to be an array");
+    }
+    if (key.length === 0) {
+      return void 0;
+    }
+    return this.#get(this.#internalMap, key);
+  }
+  #has(mapEntry, key) {
+    if (key.length === 1) {
+      return this.#layerFor(mapEntry, key[0]).has(key[0]);
+    } else {
+      const [first, ...rest] = key;
+      const nextMapEntry = this.#childrenFor(mapEntry, first).get(first);
+      if (!nextMapEntry) {
+        return false;
+      }
+      return this.#has(nextMapEntry, rest);
+    }
+  }
+  has(key) {
+    if (!Array.isArray(key)) {
+      throw new TypeError("Expected key to be an array");
+    }
+    if (key.length === 0) {
+      return false;
+    }
+    return this.#has(this.#internalMap, key);
+  }
+  *values() {
+    for (const [, value] of this.entries()) {
+      yield value;
+    }
+  }
+  *keys() {
+    for (const [key] of this.entries()) {
+      yield key;
+    }
+  }
+  *#entries(mapEntry, key) {
+    for (const [layerKey, layerValue] of mapEntry.layer.entries()) {
+      yield [[...key, layerKey], layerValue];
+    }
+    for (const [layerKey, layerMapEntry] of mapEntry.children.entries()) {
+      yield* this.#entries(layerMapEntry, [...key, layerKey]);
+    }
+  }
+  *entries() {
+    yield* this.#entries(this.#internalMap, []);
+  }
+  #canPrune(node) {
+    return !node.hasWeakEntries && node.layer.size === 0 && node.children.size === 0;
+  }
+  #delete(mapEntry, key) {
+    if (key.length === 1) {
+      return this.#layerFor(mapEntry, key[0]).delete(key[0]);
+    }
+    const [first, ...rest] = key;
+    const childMap = this.#childrenFor(mapEntry, first);
+    const nextMapEntry = childMap.get(first);
+    if (!nextMapEntry) {
+      return false;
+    }
+    const deleted = this.#delete(nextMapEntry, rest);
+    if (deleted && this.#canPrune(nextMapEntry)) {
+      childMap.delete(first);
+    }
+    return deleted;
+  }
+  delete(key) {
+    if (!Array.isArray(key) || key.length === 0) {
+      return false;
+    }
+    return this.#delete(this.#internalMap, key);
+  }
+  #forEachInSubtree(mapEntry, onValue) {
+    for (const value of mapEntry.layer.values()) {
+      onValue(value);
+    }
+    for (const childEntry of mapEntry.children.values()) {
+      this.#forEachInSubtree(childEntry, onValue);
+    }
+  }
+  #deleteByPrefix(mapEntry, keyPrefix, onValue) {
+    if (keyPrefix.length === 1) {
+      const key = keyPrefix[0];
+      const layer = this.#layerFor(mapEntry, key);
+      const childMap2 = this.#childrenFor(mapEntry, key);
+      let deleted2 = false;
+      if (layer.has(key)) {
+        if (onValue) onValue(layer.get(key));
+        layer.delete(key);
+        deleted2 = true;
+      }
+      const childEntry = childMap2.get(key);
+      if (childEntry) {
+        if (onValue) this.#forEachInSubtree(childEntry, onValue);
+        childMap2.delete(key);
+        deleted2 = true;
+      }
+      return deleted2;
+    }
+    const [first, ...rest] = keyPrefix;
+    const childMap = this.#childrenFor(mapEntry, first);
+    const nextMapEntry = childMap.get(first);
+    if (!nextMapEntry) {
+      return false;
+    }
+    const deleted = this.#deleteByPrefix(nextMapEntry, rest, onValue);
+    if (deleted && this.#canPrune(nextMapEntry)) {
+      childMap.delete(first);
+    }
+    return deleted;
+  }
+  deleteByPrefix(keyPrefix, onValue) {
+    if (!Array.isArray(keyPrefix) || keyPrefix.length === 0) {
+      return false;
+    }
+    return this.#deleteByPrefix(this.#internalMap, keyPrefix, onValue);
+  }
+  clear() {
+    this.#internalMap = makeNode();
+  }
+};
+
+// src/composite-map/lru-composite-map.js
+var LruCompositeMap = class {
+  #inner = new CompositeMap();
+  #maxSize;
+  #size = 0;
+  #head = null;
+  #tail = null;
+  #onEvict;
+  constructor(maxSize, { onEvict } = {}) {
+    this.#maxSize = maxSize;
+    this.#onEvict = onEvict;
+  }
+  #addToHead(node) {
+    node.next = this.#head;
+    node.prev = null;
+    if (this.#head) {
+      this.#head.prev = node;
+    }
+    this.#head = node;
+    if (!this.#tail) {
+      this.#tail = node;
+    }
+  }
+  #removeNode(node) {
+    if (node.prev) {
+      node.prev.next = node.next;
+    } else {
+      this.#head = node.next;
+    }
+    if (node.next) {
+      node.next.prev = node.prev;
+    } else {
+      this.#tail = node.prev;
+    }
+    node.prev = null;
+    node.next = null;
+  }
+  #promoteNode(node) {
+    if (node === this.#head) return;
+    this.#removeNode(node);
+    this.#addToHead(node);
+  }
+  #evictLru() {
+    const lruNode = this.#tail;
+    const key = lruNode.key;
+    const wrapper = this.#inner.get(key);
+    this.#removeNode(lruNode);
+    this.#inner.delete(key);
+    this.#size--;
+    if (this.#onEvict) this.#onEvict(wrapper.value, key);
+  }
+  get(key) {
+    const wrapper = this.#inner.get(key);
+    if (wrapper === void 0) {
+      return void 0;
+    }
+    this.#promoteNode(wrapper.lruNode);
+    return wrapper.value;
+  }
+  set(key, value) {
+    const existing = this.#inner.get(key);
+    if (existing) {
+      existing.value = value;
+      this.#promoteNode(existing.lruNode);
+      return;
+    }
+    const lruNode = { key, prev: null, next: null };
+    this.#inner.set(key, { value, lruNode });
+    this.#addToHead(lruNode);
+    this.#size++;
+    if (this.#size > this.#maxSize) {
+      this.#evictLru();
+    }
+  }
+  has(key) {
+    return this.#inner.has(key);
+  }
+  *values() {
+    for (const wrapper of this.#inner.values()) {
+      yield wrapper.value;
+    }
+  }
+  *keys() {
+    yield* this.#inner.keys();
+  }
+  *entries() {
+    for (const [key, wrapper] of this.#inner.entries()) {
+      yield [key, wrapper.value];
+    }
+  }
+  deleteByPrefix(keyPrefix) {
+    return this.#inner.deleteByPrefix(keyPrefix, (wrapper) => {
+      this.#removeNode(wrapper.lruNode);
+      this.#size--;
+    });
+  }
+  clear() {
+    this.#inner.clear();
+    this.#head = null;
+    this.#tail = null;
+    this.#size = 0;
+  }
+};
+
+// src/dependency-injection-container/fastFlow.js
+var fastFlow_default = (...functions) => (x) => {
+  let val = x;
+  functions.forEach((f) => {
+    val = f(val);
+  });
+  return val;
+};
+
+// src/dependency-injection-container/privateInjectFor.js
+var singletonCompositeKey = [storedInstanceKey];
+var isCompositeStorage = (stored) => stored instanceof CompositeMap || stored instanceof LruCompositeMap;
+var privateInjectFor = ({
+  getRelatedInjectables,
+  injectableSet,
+  alreadyInjected,
+  overridingInjectables,
+  instancesByInjectableMap,
+  getDi,
+  checkForNoMatches,
+  checkForTooManyMatches,
+  checkForSideEffects,
+  checkForAbstractToken,
+  checkForNonMaybeCardinality,
+  namespacedIdByInjectableMap,
+  getNamespacedId,
+  getApplicableDecorators
+}) => ({ withMeta }) => ({ alias, instantiationParameters, injectingInjectable }) => {
+  const di = getDi();
+  let originalInjectable;
+  const aliasType = alias.aliasType;
+  if (aliasType === injectableSymbol || aliasType === injectableSymbol2) {
+    if (!injectableSet.has(alias)) {
+      checkForNoMatches([], alias, injectingInjectable);
+    }
+    originalInjectable = alias;
+  } else {
+    checkForAbstractToken(alias, injectingInjectable);
+    const relatedInjectables = getRelatedInjectables(alias);
+    checkForTooManyMatches(relatedInjectables, alias, injectingInjectable);
+    checkForNoMatches(relatedInjectables, alias, injectingInjectable);
+    originalInjectable = relatedInjectables[0];
+  }
+  alreadyInjected.add(originalInjectable);
+  const injectable = overridingInjectables.size > 0 ? overridingInjectables.get(originalInjectable) || originalInjectable : originalInjectable;
+  checkForSideEffects(injectable, injectingInjectable);
+  if (injectable.aliasType !== injectableSymbol2 && injectable.lifecycle.id === "singleton" && instantiationParameters.length > 0 && instantiationParameters.every((p) => p === void 0)) {
+    instantiationParameters = [];
+  }
+  if (instantiationParameters.length === 0) {
+    const stored = instancesByInjectableMap.get(
+      injectable.overriddenInjectable || injectable
+    );
+    let existingInstance;
+    if (injectable.lifecycle.id === "singleton") {
+      existingInstance = stored;
+    } else if (isCompositeStorage(stored)) {
+      existingInstance = stored.get(singletonCompositeKey);
+    } else {
+      existingInstance = stored;
+    }
+    if (existingInstance) {
+      if (!withMeta) {
+        return existingInstance;
+      }
+      return {
+        instance: existingInstance,
+        meta: { id: namespacedIdByInjectableMap.get(injectable) }
+      };
+    }
+  }
+  const instance = getInstance(
+    di,
+    injectable,
+    instantiationParameters,
+    instancesByInjectableMap,
+    injectingInjectable,
+    namespacedIdByInjectableMap,
+    getNamespacedId,
+    getApplicableDecorators,
+    checkForNonMaybeCardinality
+  );
+  if (!withMeta) {
+    return instance;
+  }
+  return {
+    instance,
+    meta: { id: namespacedIdByInjectableMap.get(injectable) }
+  };
+};
+var createMinimalDi = (di, injectableToBeInstantiated, injectingInjectable, namespacedIdByInjectableMap, checkForNonMaybeCardinality) => {
+  const shared = {
+    register: (...injectables) => {
+      di.register({
+        injectables,
+        context: [{ injectable: injectableToBeInstantiated }],
+        source: injectableToBeInstantiated
+      });
+    },
+    deregister: (...injectables) => {
+      di.deregister({
+        injectables,
+        context: [{ injectable: injectableToBeInstantiated }],
+        source: injectableToBeInstantiated
+      });
+    },
+    get sourceNamespace() {
+      const nsId = namespacedIdByInjectableMap.get(injectingInjectable);
+      const lastColon = nsId ? nsId.lastIndexOf(":") : -1;
+      return lastColon > 0 ? nsId.slice(0, lastColon) : void 0;
+    },
+    hasRegistrations: di.hasRegistrations,
+    getNumberOfRegistrations: di.getNumberOfRegistrations,
+    getNumberOfInstances: di.getNumberOfInstances,
+    purge: (alias, ...keyParts) => di.scopedPurge(injectableToBeInstantiated, alias, ...keyParts),
+    registeredInLocalScope: (alias) => di.registeredInScopeOf(injectableToBeInstantiated, alias),
+    registeredInLocalScopeSubtree: (alias) => di.registeredInSubtreeOf(injectableToBeInstantiated, alias)
+  };
+  if (injectableToBeInstantiated.aliasType === injectableSymbol2) {
+    return {
+      ...shared,
+      inject: (alias) => (...params) => di.inject({
+        alias,
+        instantiationParameters: params,
+        injectingInjectable: injectableToBeInstantiated
+      }),
+      injectMany: (alias) => (...params) => di.injectMany({
+        alias,
+        instantiationParameters: params,
+        injectingInjectable: injectableToBeInstantiated
+      }),
+      injectMaybe: (alias) => {
+        checkForNonMaybeCardinality(alias, injectableToBeInstantiated);
+        return (...params) => di.injectMany({
+          alias,
+          instantiationParameters: params,
+          injectingInjectable: injectableToBeInstantiated
+        })[0];
+      },
+      injectWithMeta: (alias) => (...params) => di.injectWithMeta({
+        alias,
+        instantiationParameters: params,
+        injectingInjectable: injectableToBeInstantiated
+      }),
+      injectManyWithMeta: (alias) => (...params) => di.injectManyWithMeta({
+        alias,
+        instantiationParameters: params,
+        injectingInjectable: injectableToBeInstantiated
+      }),
+      injectMaybeWithMeta: (alias) => {
+        checkForNonMaybeCardinality(alias, injectableToBeInstantiated);
+        return (...params) => di.injectManyWithMeta({
+          alias,
+          instantiationParameters: params,
+          injectingInjectable: injectableToBeInstantiated
+        })[0];
+      }
+    };
+  }
+  const minimalInject = (alias, ...args) => di.inject({
+    alias,
+    instantiationParameters: args,
+    injectingInjectable: injectableToBeInstantiated
+  });
+  const minimalInjectMany = (alias, ...args) => di.injectMany({
+    alias,
+    instantiationParameters: args,
+    injectingInjectable: injectableToBeInstantiated
+  });
+  const minimalInjectWithMeta = (alias, ...args) => di.injectWithMeta({
+    alias,
+    instantiationParameters: args,
+    injectingInjectable: injectableToBeInstantiated
+  });
+  const minimalInjectManyWithMeta = (alias, ...args) => di.injectManyWithMeta({
+    alias,
+    instantiationParameters: args,
+    injectingInjectable: injectableToBeInstantiated
+  });
+  return {
+    ...shared,
+    inject: minimalInject,
+    injectMany: minimalInjectMany,
+    injectWithMeta: minimalInjectWithMeta,
+    injectManyWithMeta: minimalInjectManyWithMeta,
+    injectFactory: (alias) => (...params) => minimalInject(alias, ...params)
+  };
+};
+var instantiate = (di, injectableToBeInstantiated, minimalDi, instantiationParameters, getApplicableDecorators) => {
+  const target = injectableToBeInstantiated.overriddenInjectable || injectableToBeInstantiated;
+  const decorators = getApplicableDecorators({
+    decoratorToken: instantiationDecoratorToken,
+    target,
+    injectingInjectable: injectableToBeInstantiated
+  });
+  const decorated = decorators.length === 0 ? injectableToBeInstantiated.instantiate : fastFlow_default(...decorators)(injectableToBeInstantiated.instantiate);
+  if (injectableToBeInstantiated.aliasType === injectableSymbol2) {
+    return decorated(minimalDi)(...instantiationParameters);
+  }
+  return decorated(minimalDi, ...instantiationParameters);
+};
+var ensureInstanceMap = (instancesByInjectableMap, key) => {
+  let instanceMap = instancesByInjectableMap.get(key);
+  if (!instanceMap) {
+    instanceMap = new CompositeMap();
+    instancesByInjectableMap.set(key, instanceMap);
+  }
+  return instanceMap;
+};
+var getInstance = (di, injectableToBeInstantiated, instantiationParameters, instancesByInjectableMap, injectingInjectable, namespacedIdByInjectableMap, getNamespacedId, getApplicableDecorators, checkForNonMaybeCardinality) => {
+  const cacheKey = injectableToBeInstantiated.overriddenInjectable || injectableToBeInstantiated;
+  const lifecycleId = injectableToBeInstantiated.lifecycle.id;
+  if (lifecycleId === "singleton") {
+    if (instantiationParameters.length > 0) {
+      throw new Error(
+        `Tried to inject singleton "${getNamespacedId(
+          injectableToBeInstantiated
+        )}" from "${getNamespacedId(
+          injectingInjectable
+        )}", but illegally to singletons, instantiationParameters were provided: "${instantiationParameters}".`
+      );
+    }
+    const minimalDi2 = createMinimalDi(
+      di,
+      injectableToBeInstantiated,
+      injectingInjectable,
+      namespacedIdByInjectableMap,
+      checkForNonMaybeCardinality
+    );
+    const newInstance2 = instantiate(
+      di,
+      injectableToBeInstantiated,
+      minimalDi2,
+      instantiationParameters,
+      getApplicableDecorators
+    );
+    instancesByInjectableMap.set(cacheKey, newInstance2);
+    return newInstance2;
+  }
+  if (lifecycleId === "transient") {
+    const minimalDi2 = createMinimalDi(
+      di,
+      injectableToBeInstantiated,
+      injectingInjectable,
+      namespacedIdByInjectableMap,
+      checkForNonMaybeCardinality
+    );
+    return instantiate(
+      di,
+      injectableToBeInstantiated,
+      minimalDi2,
+      instantiationParameters,
+      getApplicableDecorators
+    );
+  }
+  if (instantiationParameters.length === 0 && injectableToBeInstantiated.lifecycle._isV2DefaultLifecycle) {
+    const existing = instancesByInjectableMap.get(cacheKey);
+    if (!isCompositeStorage(existing)) {
+      const minimalDi2 = createMinimalDi(
+        di,
+        injectableToBeInstantiated,
+        injectingInjectable,
+        namespacedIdByInjectableMap,
+        checkForNonMaybeCardinality
+      );
+      const newInstance2 = instantiate(
+        di,
+        injectableToBeInstantiated,
+        minimalDi2,
+        instantiationParameters,
+        getApplicableDecorators
+      );
+      instancesByInjectableMap.set(cacheKey, newInstance2);
+      return newInstance2;
+    }
+  }
+  const minimalDi = createMinimalDi(
+    di,
+    injectableToBeInstantiated,
+    injectingInjectable,
+    namespacedIdByInjectableMap,
+    checkForNonMaybeCardinality
+  );
+  const instanceKey = injectableToBeInstantiated.lifecycle.getInstanceKey(
+    minimalDi,
+    ...instantiationParameters
+  );
+  const instanceCompositeKey = isCompositeKey(instanceKey) ? instanceKey.keys : [instanceKey];
+  let existingMap = instancesByInjectableMap.get(cacheKey);
+  if (injectableToBeInstantiated.lifecycle._isV2DefaultLifecycle && existingMap !== void 0 && !isCompositeStorage(existingMap)) {
+    const previousInstance = existingMap;
+    existingMap = new CompositeMap();
+    existingMap.set(singletonCompositeKey, previousInstance);
+    instancesByInjectableMap.set(cacheKey, existingMap);
+  }
+  const existingInstance = existingMap == null ? void 0 : existingMap.get(instanceCompositeKey);
+  if (existingInstance) {
+    return existingInstance;
+  }
+  const newInstance = instantiate(
+    di,
+    injectableToBeInstantiated,
+    minimalDi,
+    instantiationParameters,
+    getApplicableDecorators
+  );
+  if (instanceCompositeKey[0] !== nonStoredInstanceKey) {
+    ensureInstanceMap(instancesByInjectableMap, cacheKey).set(
+      instanceCompositeKey,
+      newInstance
+    );
+  }
+  return newInstance;
+};
+
+// src/dependency-injection-container/withInjectionDecoratorsFor.js
+var withInjectionDecoratorsFor = ({ decoratorCache, getApplicableDecorators }) => (toBeDecorated) => ({ alias, instantiationParameters, injectingInjectable }) => {
+  if (decoratorCache.injection === null) {
+    decoratorCache.injection = true;
+    decoratorCache.injectionByAlias = /* @__PURE__ */ new Map();
+  }
+  let decorated = decoratorCache.injectionByAlias.get(alias);
+  if (decorated === void 0) {
+    const decorators = getApplicableDecorators({
+      decoratorToken: injectionDecoratorToken,
+      target: alias,
+      injectingInjectable
+    });
+    if (decorators.length > 0) {
+      const boundInject = (...params) => toBeDecorated({
+        alias,
+        instantiationParameters: params,
+        injectingInjectable
+      });
+      decorated = fastFlow_default(...decorators)(boundInject);
+    } else {
+      decorated = null;
+    }
+    decoratorCache.injectionByAlias.set(alias, decorated);
+  }
+  if (decorated === null) {
+    return toBeDecorated({
+      alias,
+      instantiationParameters,
+      injectingInjectable
+    });
+  }
+  return decorated(...instantiationParameters);
+};
+
+// src/dependency-injection-container/privateInjectManyFor.js
+var privateInjectManyFor = ({ getRelatedInjectables, getInject, namespacedIdByInjectableMap }) => ({ withMeta }) => ({ alias, instantiationParameters, injectingInjectable }) => {
+  const inject = getInject();
+  const relatedInjectables = getRelatedInjectables(alias);
+  const n = relatedInjectables.length;
+  if (n === 0) {
+    return [];
+  }
+  const result = new Array(n);
+  const arg = {
+    alias: void 0,
+    instantiationParameters,
+    injectingInjectable: alias
+  };
+  if (withMeta) {
+    for (let i = 0; i < n; i++) {
+      const injectable = relatedInjectables[i];
+      arg.alias = injectable;
+      const instance = inject(arg);
+      result[i] = {
+        instance,
+        meta: { id: namespacedIdByInjectableMap.get(injectable) }
+      };
+    }
+  } else {
+    for (let i = 0; i < n; i++) {
+      arg.alias = relatedInjectables[i];
+      result[i] = inject(arg);
+    }
+  }
+  return result;
+};
+
+// src/getInjectionToken/isInjectionToken.js
+var isInjectionToken_default = (maybeInjectionToken) => (maybeInjectionToken == null ? void 0 : maybeInjectionToken.aliasType) === injectionTokenSymbol || (maybeInjectionToken == null ? void 0 : maybeInjectionToken.aliasType) === injectionTokenSymbol2;
+
+// src/dependency-injection-container/getNamespacedIdFor.js
+var getNamespacedIdFor = (injectableAndRegistrationContext) => {
+  return (alias) => {
+    const id = isInjectionToken_default(alias) ? `(${alias.id})` : alias.id;
+    const registrationContext = injectableAndRegistrationContext.get(alias);
+    if (!registrationContext) {
+      return id;
+    }
+    const immediateParent = registrationContext[registrationContext.length - 1];
+    if (!immediateParent || immediateParent.injectable.aliasType === "container") {
+      return id;
+    }
+    const ids = [immediateParent.injectable.id];
+    let current = immediateParent.injectable;
+    while (true) {
+      const parentContext = injectableAndRegistrationContext.get(current);
+      if (!parentContext) {
+        break;
+      }
+      const parent = parentContext[parentContext.length - 1];
+      if (!parent || parent.injectable.aliasType === "container") {
+        break;
+      }
+      ids.push(parent.injectable.id);
+      current = parent.injectable;
+    }
+    ids.reverse();
+    ids.push(id);
+    return ids.join(":");
+  };
+};
+
+// src/getInjectableBunch/getInjectableBunch.js
+var injectableBunchSymbol = "injectable-bunch";
+var getInjectableBunch_default = (bunch) => Object.assign(bunch, {
+  aliasType: injectableBunchSymbol
+});
+
+// src/getInjectableBunch/isInjectableBunch.js
+var isInjectableBunch_default = (maybeInjectableBunch) => (maybeInjectableBunch == null ? void 0 : maybeInjectableBunch.aliasType) === injectableBunchSymbol;
+
+// src/getInjectable/isInjectable.js
+var isInjectable_default = (maybeInjectable) => (maybeInjectable == null ? void 0 : maybeInjectable.aliasType) === injectableSymbol || (maybeInjectable == null ? void 0 : maybeInjectable.aliasType) === injectableSymbol2;
+
+// src/dependency-injection-container/toFlatInjectables.js
+var collectDeepBunchValues = (bunch, out) => {
+  const values = Object.values(bunch);
+  for (let i = 0; i < values.length; i++) {
+    const thing = values[i];
+    if (isInjectableBunch_default(thing)) {
+      collectDeepBunchValues(thing, out);
+    } else if (isInjectable_default(thing)) {
+      out.push(thing);
+    }
+  }
+};
+var toFlatInjectables_default = (injectables) => {
+  const result = [];
+  for (let i = 0; i < injectables.length; i++) {
+    const injectable = injectables[i];
+    if (isInjectableBunch_default(injectable)) {
+      collectDeepBunchValues(injectable, result);
+    } else {
+      result.push(injectable);
+    }
+  }
+  return result;
+};
+
+// src/dependency-injection-container/getRelatedTokens.js
+var tokenChainCache = /* @__PURE__ */ new WeakMap();
+var getRelatedTokens = (token) => {
+  if (token === void 0) {
+    return emptyArray;
+  }
+  let cached = tokenChainCache.get(token);
+  if (cached) {
+    return cached;
+  }
+  const tokens = [];
+  let current = token;
+  while (current !== void 0) {
+    tokens.push(current);
+    current = current.specificTokenOf;
+  }
+  tokenChainCache.set(token, tokens);
+  return tokens;
+};
+var isRelatedToToken = (token, ancestor) => {
+  let current = token;
+  while (current) {
+    if (current === ancestor) return true;
+    current = current.specificTokenOf;
+  }
+  return false;
+};
+var emptyArray = [];
+
+// src/dependency-injection-container/getRelatedInjectablesFor.js
+var arrayCache = /* @__PURE__ */ new WeakMap();
+var EMPTY = Object.freeze([]);
+var getCachedArray = (set) => {
+  let arr = arrayCache.get(set);
+  if (!arr) {
+    arr = [...set];
+    arrayCache.set(set, arr);
+  }
+  return arr;
+};
+var invalidateRelatedInjectablesCache = (set) => {
+  arrayCache.delete(set);
+};
+var getRelatedInjectablesFor = ({ injectablesByInjectionToken, injectableSet }) => (alias) => {
+  if (isInjectable_default(alias)) {
+    return injectableSet.has(alias) ? [alias] : EMPTY;
+  }
+  const set = injectablesByInjectionToken.get(alias);
+  if (!set || set.size === 0) {
+    return EMPTY;
+  }
+  return getCachedArray(set);
+};
+
+// src/dependency-injection-container/register.js
+var registerFor = ({ registerSingle, injectMany, getApplicableDecorators }) => ({ injectables, context, source }) => {
+  const flatInjectables = toFlatInjectables_default(injectables);
+  const phase0Injectables = [];
+  const registeredRegistrationDecoratorInjectables = [];
+  const phase2Injectables = [];
+  for (let i = 0; i < flatInjectables.length; i++) {
+    const injectable = flatInjectables[i];
+    if (isRelatedToToken(injectable.injectionToken, registrationDecoratorToken)) {
+      registerSingle(injectable, context);
+      registeredRegistrationDecoratorInjectables.push(injectable);
+    } else if (isRelatedToToken(injectable.injectionToken, instantiationDecoratorToken)) {
+      phase0Injectables.push(injectable);
+    } else {
+      phase2Injectables.push(injectable);
+    }
+  }
+  let batchInProgress = true;
+  const registeredInjectables = [];
+  const fireCallbacksFor = (injectable) => {
+    const callbacks2 = injectMany({
+      alias: registrationCallbackToken,
+      instantiationParameters: [],
+      injectingInjectable: source
+    });
+    for (let j = 0; j < callbacks2.length; j++) {
+      callbacks2[j](injectable);
+    }
+  };
+  const registerThroughPipeline = (injectable) => {
+    const decorators = getApplicableDecorators({
+      decoratorToken: registrationDecoratorToken,
+      target: injectable,
+      injectingInjectable: source
+    });
+    if (decorators.length === 0) {
+      registerSingle(injectable, context);
+      registeredInjectables.push(injectable);
+      return;
+    }
+    let wasRegisteredThisInjectable = false;
+    const boundRegisterSingle = (inj) => {
+      registerSingle(inj, context);
+      wasRegisteredThisInjectable = true;
+      if (!batchInProgress) {
+        fireCallbacksFor(inj);
+      }
+    };
+    const decoratedRegister = fastFlow_default(...decorators)(boundRegisterSingle);
+    decoratedRegister(injectable);
+    if (wasRegisteredThisInjectable) {
+      registeredInjectables.push(injectable);
+    }
+  };
+  phase0Injectables.forEach(registerThroughPipeline);
+  phase2Injectables.forEach(registerThroughPipeline);
+  batchInProgress = false;
+  const callbacks = injectMany({
+    alias: registrationCallbackToken,
+    instantiationParameters: [],
+    injectingInjectable: source
+  });
+  if (callbacks.length === 0) {
+    return;
+  }
+  const fireBatchCallbacks = (injectable) => {
+    for (let j = 0; j < callbacks.length; j++) {
+      callbacks[j](injectable);
+    }
+  };
+  registeredRegistrationDecoratorInjectables.forEach(fireBatchCallbacks);
+  registeredInjectables.forEach(fireBatchCallbacks);
+};
+var registerSingleFor = ({
+  injectableSet,
+  injectableIdSet,
+  instancesByInjectableMap,
+  namespacedIdByInjectableMap,
+  injectablesByInjectionToken,
+  injectableAndRegistrationContext,
+  childrenByParentMap,
+  firePurgeCallbacks
+}) => {
+  const getNamespacedId = getNamespacedIdFor(injectableAndRegistrationContext);
+  return (injectable, injectionContext) => {
+    var _a, _b, _c, _d;
+    const injectableId = injectable.id;
+    if (!injectableId) {
+      throw new Error("Tried to register injectable without ID.");
+    }
+    for (let i = 0; i < injectionContext.length; i++) {
+      const parent = injectionContext[i].injectable;
+      let children = childrenByParentMap.get(parent);
+      if (!children) {
+        children = /* @__PURE__ */ new Set();
+        childrenByParentMap.set(parent, children);
+      }
+      children.add(injectable);
+    }
+    const immediateParent = injectionContext.length > 0 ? injectionContext[injectionContext.length - 1] : void 0;
+    const isContainerLevel = !immediateParent || immediateParent.injectable.aliasType === "container";
+    if (!isContainerLevel) {
+      injectableAndRegistrationContext.set(injectable, injectionContext);
+    }
+    const namespacedId = isContainerLevel ? injectableId : getNamespacedId(injectable);
+    if (namespacedIdByInjectableMap.has(injectable)) {
+      throw new Error(
+        `Tried to register same injectable multiple times: "${namespacedIdByInjectableMap.get(
+          injectable
+        )}"`
+      );
+    }
+    if (injectableIdSet.has(namespacedId)) {
+      throw new Error(
+        `Tried to register multiple injectables for ID "${namespacedId}"`
+      );
+    }
+    const upperBoundedCardinality = ((_a = injectable.injectionToken) == null ? void 0 : _a.cardinality) === "one" || ((_b = injectable.injectionToken) == null ? void 0 : _b.cardinality) === "zero-or-one" ? injectable.injectionToken.cardinality : void 0;
+    if (upperBoundedCardinality) {
+      const token = injectable.injectionToken;
+      const registered = injectablesByInjectionToken.get(token);
+      if (registered) {
+        for (const member of registered) {
+          if (member.injectionToken === token) {
+            throw new Error(
+              `Tried to register injectable "${namespacedId}" with injection token "${token.id}", but its cardinality "${upperBoundedCardinality}" allows at most one registration and "${namespacedIdByInjectableMap.get(
+                member
+              )}" is already registered.`
+            );
+          }
+        }
+      }
+    }
+    injectableIdSet.add(namespacedId);
+    injectableSet.add(injectable);
+    namespacedIdByInjectableMap.set(injectable, namespacedId);
+    if ((_c = injectable.injectionToken) == null ? void 0 : _c.abstract) {
+      throw new Error(
+        `Tried to register injectable "${namespacedId}" with injection token "${injectable.injectionToken.id}", but it is abstract. Use ".for(specifier)" for a concrete token.`
+      );
+    }
+    const maxCacheSize = injectable.maxCacheSize ?? ((_d = injectable.injectionToken) == null ? void 0 : _d.maxCacheSize);
+    if (maxCacheSize > 0 && injectable.lifecycle.id !== "singleton") {
+      const instanceMap = new LruCompositeMap(maxCacheSize, {
+        onEvict: (instance, keyArray) => firePurgeCallbacks(injectable, instance, keyArray)
+      });
+      instancesByInjectableMap.set(injectable, instanceMap);
+    }
+    const tokens = getRelatedTokens(injectable.injectionToken);
+    for (let t = 0; t < tokens.length; t++) {
+      const token = tokens[t];
+      let injectablesSet = injectablesByInjectionToken.get(token);
+      if (!injectablesSet) {
+        injectablesSet = /* @__PURE__ */ new Set();
+        injectablesByInjectionToken.set(token, injectablesSet);
+      }
+      injectablesSet.add(injectable);
+      invalidateRelatedInjectablesCache(injectablesSet);
+    }
+  };
+};
+
+// src/dependency-injection-container/purgeInstances.js
+var singletonKeyArray = [storedInstanceKey];
+var keyArrayStartsWith = (keyArray, prefix) => {
+  if (prefix.length > keyArray.length) return false;
+  for (let i = 0; i < prefix.length; i++) {
+    if (keyArray[i] !== prefix[i]) return false;
+  }
+  return true;
+};
+var evict = (instancesByInjectableMap, injectablesInScope, keyParts) => {
+  for (const injectable of injectablesInScope) {
+    const stored = instancesByInjectableMap.get(injectable);
+    if (stored === void 0) continue;
+    if (!isCompositeStorage(stored)) {
+      if (keyParts.length === 0 || keyArrayStartsWith(singletonKeyArray, keyParts)) {
+        instancesByInjectableMap.delete(injectable);
+      }
+      continue;
+    }
+    if (keyParts.length === 0) {
+      stored.clear();
+    } else {
+      stored.deleteByPrefix(keyParts);
+    }
+  }
+};
+var purgeStoredInstancesFor = ({
+  instancesByInjectableMap,
+  firePurgeCallbacks,
+  anyPurgeCallbacksRegistered
+}) => (injectablesInScope, keyParts) => {
+  if (!anyPurgeCallbacksRegistered()) {
+    evict(instancesByInjectableMap, injectablesInScope, keyParts);
+    return;
+  }
+  const tuples = [];
+  for (const injectable of injectablesInScope) {
+    const stored = instancesByInjectableMap.get(injectable);
+    if (stored === void 0) continue;
+    if (!isCompositeStorage(stored)) {
+      if (keyParts.length > 0 && !keyArrayStartsWith(singletonKeyArray, keyParts)) {
+        continue;
+      }
+      tuples.push({
+        injectable,
+        instance: stored,
+        keyArray: singletonKeyArray
+      });
+      continue;
+    }
+    for (const [keyArray, instance] of stored.entries()) {
+      if (keyParts.length > 0 && !keyArrayStartsWith(keyArray, keyParts)) {
+        continue;
+      }
+      tuples.push({ injectable, instance, keyArray });
+    }
+  }
+  for (const { injectable, instance, keyArray } of tuples) {
+    firePurgeCallbacks(injectable, instance, keyArray);
+  }
+  evict(instancesByInjectableMap, injectablesInScope, keyParts);
+};
+var purgeInstancesFor = ({
+  getRelatedInjectables,
+  instancesByInjectableMap,
+  firePurgeCallbacks,
+  anyPurgeCallbacksRegistered
+}) => {
+  const purgeStoredInstances = purgeStoredInstancesFor({
+    instancesByInjectableMap,
+    firePurgeCallbacks,
+    anyPurgeCallbacksRegistered
+  });
+  return (alias, ...keyParts) => purgeStoredInstances(
+    alias === void 0 ? [...instancesByInjectableMap.keys()] : getRelatedInjectables(alias),
+    keyParts
+  );
+};
+
+// src/dependency-injection-container/deregister.js
+var deregisterFor = ({
+  injectMany,
+  getApplicableDecorators,
+  injectableSet,
+  injectableAndRegistrationContext,
+  injectablesByInjectionToken,
+  overridingInjectables,
+  purgeInstances,
+  injectableIdSet,
+  namespacedIdByInjectableMap,
+  childrenByParentMap,
+  // Todo: get rid of function usage.
+  getDi,
+  decoratorCache,
+  syncInjectWiring
+}) => ({ injectables, context, source }) => {
+  const callbacks = injectMany({
+    alias: deregistrationCallbackToken,
+    instantiationParameters: [],
+    injectingInjectable: source
+  });
+  const flatInjectables = toFlatInjectables_default(injectables);
+  flatInjectables.forEach((injectable) => {
+    callbacks.forEach((callback) => {
+      callback(injectable);
+    });
+  });
+  const di = getDi();
+  const deregisterSingle = deregisterSingleFor({
+    injectableSet,
+    injectableAndRegistrationContext,
+    injectablesByInjectionToken,
+    overridingInjectables,
+    purgeInstances,
+    injectableIdSet,
+    namespacedIdByInjectableMap,
+    childrenByParentMap,
+    di
+  });
+  let injectWiringChanged = false;
+  flatInjectables.forEach((injectable) => {
+    if (isRelatedToToken(injectable.injectionToken, injectionDecoratorToken)) {
+      decoratorCache.injection = null;
+      injectWiringChanged = true;
+    }
+    if (isRelatedToToken(injectable.injectionToken, preInjectCallbackToken)) {
+      decoratorCache.preInject = null;
+      injectWiringChanged = true;
+    }
+    const decorators = getApplicableDecorators({
+      decoratorToken: deregistrationDecoratorToken,
+      target: injectable,
+      injectingInjectable: source
+    });
+    if (decorators.length === 0) {
+      deregisterSingle(injectable);
+      return;
+    }
+    const decoratedDeregister = fastFlow_default(...decorators)(deregisterSingle);
+    decoratedDeregister(injectable);
+  });
+  if (injectWiringChanged) {
+    syncInjectWiring();
+  }
+};
+var deregisterSingleFor = ({
+  injectableSet,
+  injectableAndRegistrationContext,
+  injectablesByInjectionToken,
+  overridingInjectables,
+  purgeInstances,
+  injectableIdSet,
+  namespacedIdByInjectableMap,
+  childrenByParentMap,
+  di
+}) => (injectable) => {
+  if (isInjectionToken_default(injectable)) {
+    throw new Error(
+      `Tried to deregister using injection token "${injectable.id}", but deregistration using token is illegal.`
+    );
+  }
+  if (!injectableSet.has(injectable)) {
+    throw new Error(
+      `Tried to deregister non-registered injectable "${injectable.id}".`
+    );
+  }
+  const children = childrenByParentMap.get(injectable);
+  if (children) {
+    children.forEach((child) => {
+      injectableAndRegistrationContext.delete(child);
+      if (injectableSet.has(child)) {
+        di.deregister({
+          injectables: [child]
+        });
+      }
+    });
+    childrenByParentMap.delete(injectable);
+  }
+  purgeInstances(injectable);
+  injectableAndRegistrationContext.delete(injectable);
+  const namespacedId = namespacedIdByInjectableMap.get(injectable);
+  injectableIdSet.delete(namespacedId);
+  injectableSet.delete(injectable);
+  namespacedIdByInjectableMap.delete(injectable);
+  const tokens = getRelatedTokens(injectable.injectionToken);
+  tokens.forEach((token) => {
+    const tokenSet = injectablesByInjectionToken.get(token);
+    tokenSet.delete(injectable);
+    invalidateRelatedInjectablesCache(tokenSet);
+  });
+  overridingInjectables.delete(injectable);
+};
+
+// src/dependency-injection-container/override.js
+var overrideFor = ({ getRelatedInjectables, earlyOverride }) => (alias, instantiateStub) => {
+  const relatedInjectables = getRelatedInjectables(alias);
+  if (relatedInjectables.length === 0) {
+    if (alias.aliasType === "injection-token") {
+      throw new Error(
+        `Tried to override single implementation of injection token "${alias.id}", but found no registered implementations.`
+      );
+    }
+    throw new Error(
+      `Tried to override "${alias.id}" which is not registered.`
+    );
+  }
+  earlyOverride(alias, instantiateStub);
+};
+var unoverrideFor = ({ overridingInjectables, getRelatedInjectables, getNamespacedId }) => (alias) => {
+  const [injectable] = getRelatedInjectables(alias);
+  if (!injectable) {
+    throw new Error(
+      `Tried to unoverride "${alias.id}", but it was not registered.`
+    );
+  }
+  if (!overridingInjectables.has(injectable)) {
+    throw new Error(
+      `Tried to unoverride "${getNamespacedId(
+        injectable
+      )}", but it was not overridden.`
+    );
+  }
+  overridingInjectables.delete(injectable);
+};
+
+// src/dependency-injection-container/checkForNoMatchesFor.js
+var checkForNoMatchesFor = ({ getNamespacedId }) => (relatedInjectables, alias, injectingInjectable) => {
+  if (relatedInjectables.length === 0) {
+    throw new Error(
+      `Tried to inject non-registered injectable "${alias.id}" from "${getNamespacedId(injectingInjectable)}".`
+    );
+  }
+};
+
+// src/dependency-injection-container/checkForTooManyMatches.js
+var checkForTooManyMatchesFor = ({ getNamespacedId }) => (relatedInjectables, alias, injectingInjectable) => {
+  if (relatedInjectables.length > 1) {
+    throw new Error(
+      `Tried to inject single injectable for injection token "${alias.id}" from "${getNamespacedId(
+        injectingInjectable
+      )}" but found multiple injectables: "${relatedInjectables.map(getNamespacedId).join('", "')}"`
+    );
+  }
+};
+
+// src/dependency-injection-container/checkForSideEffectsFor.js
+var checkForSideEffectsFor = ({ getSideEffectsArePrevented, getNamespacedId }) => (injectable, injectingInjectable) => {
+  if (getSideEffectsArePrevented(injectable)) {
+    throw new Error(
+      `Tried to inject "${getNamespacedId(
+        injectable
+      )}" from "${getNamespacedId(
+        injectingInjectable
+      )}" when side-effects are prevented.`
+    );
+  }
+};
+
+// src/dependency-injection-container/checkForAbstractTokenFor.js
+var checkForAbstractTokenFor = ({ getNamespacedId }) => (alias, injectingInjectable) => {
+  if (alias.abstract) {
+    throw new Error(
+      `Tried to inject injection token "${alias.id}" from "${getNamespacedId(
+        injectingInjectable
+      )}", but it is abstract. Use ".for(specifier)" for a concrete token.`
+    );
+  }
+};
+
+// src/dependency-injection-container/checkForNonMaybeCardinalityFor.js
+var checkForNonMaybeCardinalityFor = ({ getNamespacedId }) => (alias, injectingInjectable) => {
+  if (alias.cardinality !== "zero-or-one") {
+    throw new Error(
+      `Tried to injectMaybe "${alias.id}" from "${getNamespacedId(
+        injectingInjectable
+      )}", but its cardinality is "${alias.cardinality}" instead of "zero-or-one".`
+    );
+  }
+};
+
+// src/dependency-injection-container/checkForUndeclaredConsumptionFor.js
+var declaredSetsByInjectable = /* @__PURE__ */ new WeakMap();
+var getDeclaredSet = (injectable) => {
+  let declared = declaredSetsByInjectable.get(injectable);
+  if (!declared) {
+    declared = new Set(injectable.consumptions ?? []);
+    declaredSetsByInjectable.set(injectable, declared);
+  }
+  return declared;
+};
+var checkForUndeclaredConsumptionFor = ({ getNamespacedId }) => ({ alias, injectingInjectable }) => {
+  if (injectingInjectable.aliasType !== injectableSymbol2) {
+    return;
+  }
+  if (isInjectable_default(alias)) {
+    return;
+  }
+  const declared = getDeclaredSet(injectingInjectable);
+  let candidate = alias;
+  while (candidate !== void 0) {
+    if (declared.has(candidate)) {
+      return;
+    }
+    candidate = candidate.specificTokenOf;
+  }
+  throw new Error(
+    `Tried to inject "${alias.id}" from "${getNamespacedId(
+      injectingInjectable
+    )}", but it is not a declared consumption.`
+  );
+};
+
+// src/dependency-injection-container/validate.js
+var isToken2 = (alias) => alias.aliasType === "injection-token2";
+var validateFor = ({
+  containerId,
+  injectableSet,
+  injectablesByInjectionToken,
+  namespacedIdByInjectableMap,
+  overridingInjectables
+}) => () => {
+  const verifiedIds = [];
+  const unverifiedIds = [];
+  const unverifiableConsumptions = [];
+  const violations = [];
+  for (const injectable of injectableSet) {
+    const namespacedId = namespacedIdByInjectableMap.get(injectable);
+    if (injectable.aliasType !== injectableSymbol2) {
+      unverifiedIds.push(namespacedId);
+      continue;
+    }
+    verifiedIds.push(namespacedId);
+    if (overridingInjectables.has(injectable)) {
+      continue;
+    }
+    for (const consumption of injectable.consumptions ?? []) {
+      if (!isToken2(consumption)) {
+        unverifiableConsumptions.push({
+          injectableId: namespacedId,
+          consumptionId: consumption.id
+        });
+        continue;
+      }
+      const { cardinality } = consumption;
+      if (cardinality !== "one" && cardinality !== "one-or-many") {
+        continue;
+      }
+      const registered = injectablesByInjectionToken.get(consumption);
+      if (registered === void 0 || registered.size === 0) {
+        violations.push(
+          `Injectable "${namespacedId}" consumes injection token "${consumption.id}" with cardinality "${cardinality}", but it has no registrations.`
+        );
+      }
+    }
+  }
+  if (violations.length > 0) {
+    throw new Error(
+      `Tried to validate container "${containerId}", but found violations:
+${violations.map((violation) => ` - ${violation}`).join("\n")}`
+    );
+  }
+  const sorted = (ids) => [...ids].sort();
+  return {
+    verifiedInjectables: {
+      count: verifiedIds.length,
+      ids: sorted(verifiedIds)
+    },
+    unverifiedInjectables: {
+      count: unverifiedIds.length,
+      ids: sorted(unverifiedIds)
+    },
+    unverifiableConsumptions
+  };
+};
+
+// src/dependency-injection-container/early-override.js
+var targetIsV2 = (injectable) => injectable.aliasType === injectableSymbol2 || injectable.aliasType === injectionTokenSymbol2;
+var asV1Shape = (stub, isV2Target) => isV2Target ? (di) => (...params) => stub(di, ...params) : stub;
+var asV2Shape = (stub, isV2Target) => isV2Target ? stub : (di, ...params) => stub(di)(...params);
+var earlyOverrideImplFor = (normalize) => ({
+  getRelatedInjectables,
+  alreadyInjected,
+  overridingInjectables,
+  getNamespacedId
+}) => (alias, instantiateStub) => {
+  const relatedInjectables = getRelatedInjectables(alias);
+  if (relatedInjectables.length > 1) {
+    throw new Error(
+      `Tried to override single implementation of injection token "${alias.id}", but found multiple registered implementations: "${relatedInjectables.map(getNamespacedId).join('", "')}".`
+    );
+  }
+  if (relatedInjectables.length === 0 && isInjectionToken_default(alias)) {
+    throw new Error(
+      `Tried to early-override an injection token "${alias.id}", but that is currently not supported.`
+    );
+  }
+  const originalInjectable = relatedInjectables[0] || alias;
+  if (alreadyInjected.has(alias) || alreadyInjected.has(originalInjectable)) {
+    throw new Error(
+      `Tried to override injectable "${getNamespacedId(
+        originalInjectable
+      )}", but it was already injected.`
+    );
+  }
+  overridingInjectables.set(originalInjectable, {
+    ...originalInjectable,
+    overriddenInjectable: originalInjectable,
+    causesSideEffects: false,
+    instantiate: normalize(instantiateStub, targetIsV2(originalInjectable))
+  });
+};
+var earlyOverrideFor = earlyOverrideImplFor(asV1Shape);
+var earlyOverride2For = earlyOverrideImplFor(asV2Shape);
+
+// src/dependency-injection-container/withPreInjectCallbacksFor.js
+var withPreInjectCallbacksFor = ({ decoratorCache, getApplicableDecorators }) => (kind) => (toBeCalled) => (args) => {
+  if (decoratorCache.preInject === null) {
+    decoratorCache.preInject = true;
+    decoratorCache.preInjectByAlias = /* @__PURE__ */ new Map();
+  }
+  let callbacks = decoratorCache.preInjectByAlias.get(args.alias);
+  if (callbacks === void 0) {
+    const applicable = getApplicableDecorators({
+      decoratorToken: preInjectCallbackToken,
+      target: args.alias,
+      injectingInjectable: args.injectingInjectable
+    });
+    callbacks = applicable.length > 0 ? applicable : null;
+    decoratorCache.preInjectByAlias.set(args.alias, callbacks);
+  }
+  if (callbacks !== null) {
+    for (const callback of callbacks) {
+      callback(args.alias, kind, args.injectingInjectable);
+    }
+  }
+  return toBeCalled(args);
+};
+
+// src/dependency-injection-container/firePurgeCallbacksFor.js
+var firePurgeCallbacksFor = ({ getApplicableDecorators }) => (injectable, instance, keyArray) => {
+  const payload = { instance };
+  const callbacks = getApplicableDecorators({
+    decoratorToken: instancePurgeCallbackToken,
+    target: injectable,
+    injectingInjectable: injectable
+  });
+  for (const cb of callbacks) {
+    cb(payload)(...keyArray);
+  }
+};
+
+// src/dependency-injection-container/getApplicableDecoratorsFor.js
+var EMPTY2 = Object.freeze([]);
+var getApplicableDecoratorsFor = ({ injectMany, injectablesByInjectionToken }) => ({ decoratorToken, target, injectingInjectable }) => {
+  const registered = injectablesByInjectionToken.get(decoratorToken);
+  if (!registered || registered.size === 0) {
+    return EMPTY2;
+  }
+  const out = [];
+  const dispatch = (alias) => {
+    const registeredForAlias = injectablesByInjectionToken.get(alias);
+    if (registeredForAlias && registeredForAlias.size > 0) {
+      out.push(
+        ...injectMany({
+          alias,
+          instantiationParameters: [],
+          injectingInjectable
+        })
+      );
+    }
+  };
+  dispatch(decoratorToken.for(target));
+  const chain = getRelatedTokens(
+    target.injectionToken ?? target.specificTokenOf
+  );
+  for (const t of chain) {
+    dispatch(decoratorToken.for(t));
+  }
+  const targetTags = target.tags;
+  if (targetTags) {
+    for (const tag of targetTags) {
+      dispatch(decoratorToken.for(tag));
+    }
+  }
+  let processedChainTags = targetTags;
+  for (const t of chain) {
+    const chainTags = t.tags;
+    if (!chainTags || chainTags === processedChainTags) {
+      continue;
+    }
+    processedChainTags = chainTags;
+    for (const tag of chainTags) {
+      if (targetTags && targetTags.indexOf(tag) !== -1) {
+        continue;
+      }
+      dispatch(decoratorToken.for(tag));
+    }
+  }
+  return out;
+};
+
+// src/dependency-injection-container/createContainer.js
+var createContainer_default = (containerId) => {
+  const injectableSet = /* @__PURE__ */ new Set();
+  const decoratorCache = {
+    injection: null,
+    injectionByAlias: /* @__PURE__ */ new Map(),
+    preInject: null,
+    preInjectByAlias: /* @__PURE__ */ new Map()
+  };
+  const overridingInjectables = /* @__PURE__ */ new Map();
+  let sideEffectsArePrevented = true;
+  const alreadyInjected = /* @__PURE__ */ new Set();
+  const injectablesWithPermittedSideEffects = /* @__PURE__ */ new Set();
+  const injectableIdSet = /* @__PURE__ */ new Set();
+  const injectableAndRegistrationContext = /* @__PURE__ */ new Map();
+  const instancesByInjectableMap = /* @__PURE__ */ new Map();
+  const injectablesByInjectionToken = /* @__PURE__ */ new Map();
+  const namespacedIdByInjectableMap = /* @__PURE__ */ new Map();
+  const childrenByParentMap = /* @__PURE__ */ new Map();
+  const getNamespacedId = getNamespacedIdFor(injectableAndRegistrationContext);
+  const getRelatedInjectables = getRelatedInjectablesFor({
+    injectablesByInjectionToken,
+    injectableSet
+  });
+  const containerRootContextItem = {
+    injectable: { id: containerId, aliasType: "container" }
+  };
+  const rootInjectable = containerRootContextItem.injectable;
+  const checkForAbstractToken = checkForAbstractTokenFor({ getNamespacedId });
+  const nonDecoratedPrivateInjectManyForUnknownMeta = privateInjectManyFor({
+    getRelatedInjectables,
+    // Elements go through the element slot, not `privateDi.inject`: entry
+    // wrappers (once-per-operation hooks) must not re-fire per element,
+    // while injection decorators still apply per element.
+    getInject: () => elementInject,
+    namespacedIdByInjectableMap
+  });
+  const nonDecoratedPrivateInjectMany = nonDecoratedPrivateInjectManyForUnknownMeta({
+    withMeta: false
+  });
+  const nonDecoratedPrivateInjectManyWithMeta = nonDecoratedPrivateInjectManyForUnknownMeta({
+    withMeta: true
+  });
+  const getApplicableDecorators = getApplicableDecoratorsFor({
+    injectMany: nonDecoratedPrivateInjectMany,
+    injectablesByInjectionToken
+  });
+  const getSideEffectsArePrevented = (injectable) => sideEffectsArePrevented && injectable.causesSideEffects && !injectablesWithPermittedSideEffects.has(injectable);
+  const checkForSideEffects = checkForSideEffectsFor({
+    getSideEffectsArePrevented,
+    getNamespacedId
+  });
+  const checkForNoMatches = checkForNoMatchesFor({
+    getNamespacedId
+  });
+  const checkForTooManyMatches = checkForTooManyMatchesFor({
+    getNamespacedId
+  });
+  const checkForNonMaybeCardinality = checkForNonMaybeCardinalityFor({
+    getNamespacedId
+  });
+  const checkForUndeclaredConsumption = checkForUndeclaredConsumptionFor({
+    getNamespacedId
+  });
+  const withConsumptionEnforcement = (toBeCalled) => (args) => {
+    checkForUndeclaredConsumption(args);
+    return toBeCalled(args);
+  };
+  const nonDecoratedPrivateInjectUnknownMeta = privateInjectFor({
+    getRelatedInjectables,
+    injectableSet,
+    alreadyInjected,
+    overridingInjectables,
+    instancesByInjectableMap,
+    getDi: () => privateDi,
+    checkForNoMatches,
+    checkForTooManyMatches,
+    checkForSideEffects,
+    checkForAbstractToken,
+    checkForNonMaybeCardinality,
+    namespacedIdByInjectableMap,
+    getNamespacedId,
+    getApplicableDecorators
+  });
+  const nonDecoratedPrivateInject = nonDecoratedPrivateInjectUnknownMeta({
+    withMeta: false
+  });
+  const nonDecoratedPrivateInjectWithMeta = nonDecoratedPrivateInjectUnknownMeta({
+    withMeta: true
+  });
+  const withInjectionDecorators = withInjectionDecoratorsFor({
+    decoratorCache,
+    getApplicableDecorators
+  });
+  const decoratedPrivateInject = withInjectionDecorators(
+    nonDecoratedPrivateInject
+  );
+  const decoratedPrivateInjectWithMeta = withInjectionDecorators(
+    nonDecoratedPrivateInjectWithMeta
+  );
+  const withPreInjectCallbacks = withPreInjectCallbacksFor({
+    decoratorCache,
+    getApplicableDecorators
+  });
+  const withPreInjectCallbacksForInject = withPreInjectCallbacks("inject");
+  const withPreInjectCallbacksForInjectMany = withPreInjectCallbacks("injectMany");
+  const preInjectNonDecoratedInject = withPreInjectCallbacksForInject(
+    nonDecoratedPrivateInject
+  );
+  const preInjectDecoratedInject = withPreInjectCallbacksForInject(
+    decoratedPrivateInject
+  );
+  const preInjectNonDecoratedInjectWithMeta = withPreInjectCallbacksForInject(
+    nonDecoratedPrivateInjectWithMeta
+  );
+  const preInjectDecoratedInjectWithMeta = withPreInjectCallbacksForInject(
+    decoratedPrivateInjectWithMeta
+  );
+  const preInjectInjectMany = withPreInjectCallbacksForInjectMany(
+    nonDecoratedPrivateInjectMany
+  );
+  const preInjectInjectManyWithMeta = withPreInjectCallbacksForInjectMany(
+    nonDecoratedPrivateInjectManyWithMeta
+  );
+  let elementInject = nonDecoratedPrivateInject;
+  const syncInjectWiring = () => {
+    const registeredDecorators = injectablesByInjectionToken.get(
+      injectionDecoratorToken
+    );
+    const decoratorsActive = registeredDecorators !== void 0 && registeredDecorators.size > 0;
+    const registeredPreInjectCallbacks = injectablesByInjectionToken.get(
+      preInjectCallbackToken
+    );
+    const preInjectActive = registeredPreInjectCallbacks !== void 0 && registeredPreInjectCallbacks.size > 0;
+    elementInject = decoratorsActive ? decoratedPrivateInject : nonDecoratedPrivateInject;
+    privateDi.inject = preInjectActive ? decoratorsActive ? preInjectDecoratedInject : preInjectNonDecoratedInject : elementInject;
+    privateDi.injectWithMeta = preInjectActive ? decoratorsActive ? preInjectDecoratedInjectWithMeta : preInjectNonDecoratedInjectWithMeta : decoratorsActive ? decoratedPrivateInjectWithMeta : nonDecoratedPrivateInjectWithMeta;
+    privateDi.injectMany = preInjectActive ? preInjectInjectMany : nonDecoratedPrivateInjectMany;
+    privateDi.injectManyWithMeta = preInjectActive ? preInjectInjectManyWithMeta : nonDecoratedPrivateInjectManyWithMeta;
+    privateDi.inject = withConsumptionEnforcement(privateDi.inject);
+    privateDi.injectWithMeta = withConsumptionEnforcement(
+      privateDi.injectWithMeta
+    );
+    privateDi.injectMany = withConsumptionEnforcement(privateDi.injectMany);
+    privateDi.injectManyWithMeta = withConsumptionEnforcement(
+      privateDi.injectManyWithMeta
+    );
+  };
+  const firePurgeCallbacks = firePurgeCallbacksFor({
+    getApplicableDecorators
+  });
+  const rawRegisterSingle = registerSingleFor({
+    injectableSet,
+    namespacedIdByInjectableMap,
+    instancesByInjectableMap,
+    injectablesByInjectionToken,
+    injectableIdSet,
+    injectableAndRegistrationContext,
+    childrenByParentMap,
+    firePurgeCallbacks
+  });
+  const registerSingle = (injectable, context) => {
+    rawRegisterSingle(injectable, context);
+    let wiringChanged = false;
+    if (isRelatedToToken(injectable.injectionToken, injectionDecoratorToken)) {
+      decoratorCache.injection = null;
+      wiringChanged = true;
+    }
+    if (isRelatedToToken(injectable.injectionToken, preInjectCallbackToken)) {
+      decoratorCache.preInject = null;
+      wiringChanged = true;
+    }
+    if (wiringChanged) {
+      syncInjectWiring();
+    }
+  };
+  const anyPurgeCallbacksRegistered = () => {
+    const registered = injectablesByInjectionToken.get(
+      instancePurgeCallbackToken
+    );
+    return registered !== void 0 && registered.size > 0;
+  };
+  const purgeInstances = purgeInstancesFor({
+    getRelatedInjectables,
+    instancesByInjectableMap,
+    firePurgeCallbacks,
+    anyPurgeCallbacksRegistered
+  });
+  const purgeStoredInstances = purgeStoredInstancesFor({
+    instancesByInjectableMap,
+    firePurgeCallbacks,
+    anyPurgeCallbacksRegistered
+  });
+  const deregister = deregisterFor({
+    injectMany: nonDecoratedPrivateInjectMany,
+    getApplicableDecorators,
+    injectableSet,
+    injectableAndRegistrationContext,
+    injectablesByInjectionToken,
+    overridingInjectables,
+    purgeInstances,
+    injectableIdSet,
+    namespacedIdByInjectableMap,
+    childrenByParentMap,
+    // Todo: get rid of function usage.
+    getDi: () => privateDi,
+    decoratorCache,
+    syncInjectWiring
+  });
+  const privateRegister = registerFor({
+    registerSingle,
+    injectMany: nonDecoratedPrivateInjectMany,
+    getApplicableDecorators
+  });
+  const earlyOverride = earlyOverrideFor({
+    getRelatedInjectables,
+    alreadyInjected,
+    overridingInjectables,
+    getNamespacedId
+  });
+  const earlyOverride2 = earlyOverride2For({
+    getRelatedInjectables,
+    alreadyInjected,
+    overridingInjectables,
+    getNamespacedId
+  });
+  const override = overrideFor({
+    getRelatedInjectables,
+    earlyOverride
+  });
+  const override2 = overrideFor({
+    getRelatedInjectables,
+    earlyOverride: earlyOverride2
+  });
+  const unoverride = unoverrideFor({
+    overridingInjectables,
+    getRelatedInjectables,
+    getNamespacedId
+  });
+  const purgeAllButOverrides = () => {
+    injectableSet.clear();
+    alreadyInjected.clear();
+    injectableIdSet.clear();
+    injectableAndRegistrationContext.clear();
+    instancesByInjectableMap.clear();
+    injectablesByInjectionToken.clear();
+    namespacedIdByInjectableMap.clear();
+    childrenByParentMap.clear();
+    decoratorCache.injection = null;
+    decoratorCache.preInject = null;
+    syncInjectWiring();
+  };
+  const getImmediateScopeOf = (injectable) => {
+    var _a;
+    const context = injectableAndRegistrationContext.get(injectable);
+    const immediateParent = (_a = context == null ? void 0 : context[context.length - 1]) == null ? void 0 : _a.injectable;
+    return !immediateParent || immediateParent.aliasType === "container" ? rootInjectable : immediateParent;
+  };
+  const privateDi = {
+    // Swapped by syncInjectWiring: the decorated variants are wired
+    // in only while at least one injection decorator is registered, so the
+    // common no-decorator case pays no wrapper frame at all.
+    inject: nonDecoratedPrivateInject,
+    injectWithMeta: nonDecoratedPrivateInjectWithMeta,
+    injectMany: nonDecoratedPrivateInjectMany,
+    injectManyWithMeta: nonDecoratedPrivateInjectManyWithMeta,
+    injectFactory: (alias) => (...params) => publicInject(alias, ...params),
+    register: privateRegister,
+    deregister,
+    override,
+    override2,
+    earlyOverride,
+    earlyOverride2,
+    unoverride,
+    reset: () => {
+      overridingInjectables.clear();
+    },
+    permitSideEffects: (alias) => {
+      if (alias === void 0) {
+        sideEffectsArePrevented = false;
+        return;
+      }
+      getRelatedInjectables(alias).forEach(
+        (injectable) => injectablesWithPermittedSideEffects.add(injectable)
+      );
+    },
+    purge: purgeInstances,
+    scopedPurge: (scopeInjectable, alias, ...keyParts) => {
+      if (alias === void 0) {
+        const children = childrenByParentMap.get(scopeInjectable);
+        purgeStoredInstances(
+          children === void 0 ? [scopeInjectable] : [scopeInjectable, ...children],
+          keyParts
+        );
+        return;
+      }
+      const injectables = getRelatedInjectables(alias);
+      const allowedChildren = childrenByParentMap.get(scopeInjectable);
+      for (let i = 0; i < injectables.length; i++) {
+        const injectable = injectables[i];
+        if (injectable !== scopeInjectable && !(allowedChildren == null ? void 0 : allowedChildren.has(injectable))) {
+          throw new Error(
+            `Tried to purge "${namespacedIdByInjectableMap.get(
+              injectable
+            )}" from "${namespacedIdByInjectableMap.get(
+              scopeInjectable
+            )}", but it is not within its registration context tree.`
+          );
+        }
+      }
+      purgeStoredInstances(injectables, keyParts);
+    },
+    purgeAllButOverrides,
+    hasRegistrations: (alias) => !!getRelatedInjectables(alias).length,
+    getNumberOfRegistrations: (alias) => getRelatedInjectables(alias).length,
+    registeredInScopeOf: (scopeInjectable, alias) => getRelatedInjectables(alias).some(
+      (injectable) => getImmediateScopeOf(injectable) === scopeInjectable
+    ),
+    registeredInSubtreeOf: (scopeInjectable, alias) => getRelatedInjectables(alias).some((injectable) => {
+      let scope = getImmediateScopeOf(injectable);
+      while (scope !== scopeInjectable && scope !== rootInjectable) {
+        scope = getImmediateScopeOf(scope);
+      }
+      return scope === scopeInjectable;
+    }),
+    getNumberOfInstances: () => {
+      const result = {};
+      for (const [injectable, stored] of instancesByInjectableMap) {
+        const namespacedId = namespacedIdByInjectableMap.get(injectable);
+        if (!namespacedId) continue;
+        let count = 0;
+        if (isCompositeStorage(stored)) {
+          for (const _ of stored.values()) count++;
+        } else {
+          count = 1;
+        }
+        if (count > 0) result[namespacedId] = count;
+      }
+      return result;
+    }
+  };
+  syncInjectWiring();
+  const publicInject = (alias, ...args) => privateDi.inject({
+    alias,
+    instantiationParameters: args,
+    injectingInjectable: rootInjectable
+  });
+  const publicInjectMany = (alias, ...args) => privateDi.injectMany({
+    alias,
+    instantiationParameters: args,
+    injectingInjectable: rootInjectable
+  });
+  const publicInjectWithMeta = (alias, ...args) => privateDi.injectWithMeta({
+    alias,
+    instantiationParameters: args,
+    injectingInjectable: rootInjectable
+  });
+  const publicInjectManyWithMeta = (alias, ...args) => privateDi.injectManyWithMeta({
+    alias,
+    instantiationParameters: args,
+    injectingInjectable: rootInjectable
+  });
+  const publicDi = {
+    ...privateDi,
+    inject: publicInject,
+    injectWithMeta: publicInjectWithMeta,
+    injectMany: publicInjectMany,
+    injectManyWithMeta: publicInjectManyWithMeta,
+    inject2: (alias) => (...params) => publicInject(alias, ...params),
+    injectMany2: (alias) => (...params) => publicInjectMany(alias, ...params),
+    // Resolves per call like injectMany, but unwraps to the single instance or
+    // undefined — the 'zero-or-one' upper bound guarantees at most one.
+    injectMaybe2: (alias) => {
+      checkForNonMaybeCardinality(alias, rootInjectable);
+      return (...params) => publicInjectMany(alias, ...params)[0];
+    },
+    injectWithMeta2: (alias) => (...params) => publicInjectWithMeta(alias, ...params),
+    injectManyWithMeta2: (alias) => (...params) => publicInjectManyWithMeta(alias, ...params),
+    // injectMaybe2 over the with-meta plane: unwraps to the single
+    // meta-wrapped instance or undefined.
+    injectMaybeWithMeta2: (alias) => {
+      checkForNonMaybeCardinality(alias, rootInjectable);
+      return (...params) => publicInjectManyWithMeta(alias, ...params)[0];
+    },
+    register: (...injectables) => {
+      privateDi.register({
+        injectables,
+        context: [containerRootContextItem],
+        source: rootInjectable
+      });
+    },
+    deregister: (...injectables) => {
+      privateDi.deregister({
+        injectables,
+        context: [containerRootContextItem],
+        source: rootInjectable
+      });
+    },
+    registeredInLocalScope: (alias) => privateDi.registeredInScopeOf(rootInjectable, alias),
+    validate: validateFor({
+      containerId,
+      injectableSet,
+      injectablesByInjectionToken,
+      namespacedIdByInjectableMap,
+      overridingInjectables
+    }),
+    registeredInLocalScopeSubtree: (alias) => privateDi.registeredInSubtreeOf(rootInjectable, alias)
+  };
+  return publicDi;
+};
+
+// src/getInjectionToken/getTypedSpecifier.js
+var import_fp = require("lodash/fp");
+var getTypedSpecifier = (0, import_fp.constant)(import_fp.identity);
+
+// index.js
+var getKeyedSingletonCompositeKey = getCompositeKey;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createContainer,
+  deregistrationCallbackToken,
+  deregistrationDecoratorToken,
+  getInjectable,
+  getInjectable2,
+  getInjectableBunch,
+  getInjectionToken,
+  getInjectionToken2,
+  getKeyedSingletonCompositeKey,
+  getSpecificInjectionToken,
+  getTypedSpecifier,
+  injectionDecoratorToken,
+  injectionTokenTag,
+  instancePurgeCallbackToken,
+  instantiationDecoratorToken,
+  isInjectable,
+  isInjectableBunch,
+  isInjectionToken,
+  lifecycleEnum,
+  preInjectCallbackToken,
+  registrationCallbackToken,
+  registrationDecoratorToken,
+  toFlatInjectables
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../index.js", "../src/dependency-injection-container/lifecycleEnum.js", "../src/getCompositeKey/getCompositeKey.js", "../src/getInjectable/getInjectable.js", "../src/getInjectable2/getInjectable2.js", "../src/getInjectionToken/injectionTokenTag.js", "../src/getInjectionToken/getInjectionToken.js", "../src/getInjectionToken2/getInjectionToken2.js", "../src/dependency-injection-container/tokens.js", "../src/composite-map/composite-map.js", "../src/composite-map/lru-composite-map.js", "../src/dependency-injection-container/fastFlow.js", "../src/dependency-injection-container/privateInjectFor.js", "../src/dependency-injection-container/withInjectionDecoratorsFor.js", "../src/dependency-injection-container/privateInjectManyFor.js", "../src/getInjectionToken/isInjectionToken.js", "../src/dependency-injection-container/getNamespacedIdFor.js", "../src/getInjectableBunch/getInjectableBunch.js", "../src/getInjectableBunch/isInjectableBunch.js", "../src/getInjectable/isInjectable.js", "../src/dependency-injection-container/toFlatInjectables.js", "../src/dependency-injection-container/getRelatedTokens.js", "../src/dependency-injection-container/getRelatedInjectablesFor.js", "../src/dependency-injection-container/register.js", "../src/dependency-injection-container/purgeInstances.js", "../src/dependency-injection-container/deregister.js", "../src/dependency-injection-container/override.js", "../src/dependency-injection-container/checkForNoMatchesFor.js", "../src/dependency-injection-container/checkForTooManyMatches.js", "../src/dependency-injection-container/checkForSideEffectsFor.js", "../src/dependency-injection-container/checkForAbstractTokenFor.js", "../src/dependency-injection-container/checkForNonMaybeCardinalityFor.js", "../src/dependency-injection-container/checkForUndeclaredConsumptionFor.js", "../src/dependency-injection-container/validate.js", "../src/dependency-injection-container/early-override.js", "../src/dependency-injection-container/withPreInjectCallbacksFor.js", "../src/dependency-injection-container/firePurgeCallbacksFor.js", "../src/dependency-injection-container/getApplicableDecoratorsFor.js", "../src/dependency-injection-container/createContainer.js", "../src/getInjectionToken/getTypedSpecifier.js"],
  "sourcesContent": ["import createContainer from './src/dependency-injection-container/createContainer';\n\nimport getInjectable from './src/getInjectable/getInjectable';\nimport getInjectable2 from './src/getInjectable2/getInjectable2';\nimport isInjectable from './src/getInjectable/isInjectable';\nimport lifecycleEnum from './src/dependency-injection-container/lifecycleEnum';\n\nimport {\n  getInjectionToken,\n  getSpecificInjectionToken,\n} from './src/getInjectionToken/getInjectionToken';\n\nimport { getInjectionToken2 } from './src/getInjectionToken2/getInjectionToken2';\n\nimport isInjectionToken from './src/getInjectionToken/isInjectionToken';\n\nimport getInjectableBunch from './src/getInjectableBunch/getInjectableBunch';\nimport isInjectableBunch from './src/getInjectableBunch/isInjectableBunch';\nimport toFlatInjectables from './src/dependency-injection-container/toFlatInjectables';\nimport { getCompositeKey } from './src/getCompositeKey/getCompositeKey';\n\nexport { getTypedSpecifier } from './src/getInjectionToken/getTypedSpecifier';\nexport { injectionTokenTag } from './src/getInjectionToken/injectionTokenTag';\n\nexport const getKeyedSingletonCompositeKey = getCompositeKey;\n\n\n\nexport {\n  deregistrationCallbackToken,\n  deregistrationDecoratorToken,\n  injectionDecoratorToken,\n  instancePurgeCallbackToken,\n  instantiationDecoratorToken,\n  preInjectCallbackToken,\n  registrationCallbackToken,\n  registrationDecoratorToken,\n} from './src/dependency-injection-container/tokens';\n\nexport {\n  createContainer,\n  getInjectable,\n  getInjectable2,\n  isInjectable,\n  getInjectableBunch,\n  isInjectableBunch,\n  getInjectionToken,\n  getInjectionToken2,\n  getSpecificInjectionToken,\n  isInjectionToken,\n  lifecycleEnum,\n  toFlatInjectables,\n};\n", "export const nonStoredInstanceKey = Symbol('non-stored-instance-key');\nexport const storedInstanceKey = Symbol('stored-instance-key');\n\nexport default {\n  singleton: {\n    id: 'singleton',\n\n    getInstanceKey: () => storedInstanceKey,\n  },\n\n  keyedSingleton: ({ getInstanceKey }) => ({\n    id: 'keyedSingleton',\n    getInstanceKey,\n  }),\n\n  transient: {\n    id: 'transient',\n    getInstanceKey: () => nonStoredInstanceKey,\n  },\n};\n", "export const compositeKeySymbol = Symbol('composite-key');\nexport const getCompositeKey = (...keys) => ({\n  [compositeKeySymbol]: true,\n  keys,\n});\n\nexport const isCompositeKey = thing =>\n  thing && thing[compositeKeySymbol] === true;\n", "import lifecycleEnum from '../dependency-injection-container/lifecycleEnum';\n\nexport const injectableSymbol = 'injectable';\n\nexport default ({ lifecycle = lifecycleEnum.singleton, ...injectable }) => ({\n  aliasType: injectableSymbol,\n  lifecycle,\n  ...injectable,\n});\n", "import lifecycleEnum from '../dependency-injection-container/lifecycleEnum';\nimport { storedInstanceKey } from '../dependency-injection-container/lifecycleEnum';\nimport { getCompositeKey } from '../getCompositeKey/getCompositeKey';\n\nexport const injectableSymbol2 = 'injectable2';\n\n// Hoisted and shared across every non-transient getInjectable2 \u2014 saves a\n// per-call lifecycle allocation, and the `_isV2DefaultLifecycle` tag lets\n// privateInjectFor skip the getInstanceKey call + key-array allocation when\n// a v2 injectable is injected with no args (the common case for\n// non-parametric v2). The tag is the *only* signal we trust to bypass\n// getInstanceKey because user-provided getInstanceKey may legitimately\n// return something other than `storedInstanceKey` for empty args.\nconst v2DefaultLifecycle = lifecycleEnum.keyedSingleton({\n  getInstanceKey: (di, ...args) => {\n    if (args.length === 0) return storedInstanceKey;\n    return getCompositeKey(...args);\n  },\n});\n\nv2DefaultLifecycle._isV2DefaultLifecycle = true;\n\nexport default ({ instantiate, transient = false, ...rest }) => ({\n  aliasType: injectableSymbol2,\n  instantiate,\n  transient,\n  lifecycle: transient ? lifecycleEnum.transient : v2DefaultLifecycle,\n  ...rest,\n});\n", "// The initial tag carried by every injection token (v1 and v2), permitting\n// tag-keyed decorators to target any token, e.g.\n// `injectionDecoratorToken.for(injectionTokenTag)`.\nexport const injectionTokenTag = 'injectionToken';\n", "import { injectionTokenTag } from './injectionTokenTag';\n\nexport const injectionTokenSymbol = 'injection-token';\n\nexport const getInjectionToken = ({\n  specificInjectionTokenFactory: specificTokenFactory = getSpecificTokenById,\n\n  target,\n\n  tags,\n\n  ...rest\n}) => {\n  const specificTokensBySpeciality = new Map();\n\n  // The factory is assumed pure and deterministic: a specifier always maps\n  // to the same token, so single-specifier calls are memoized by specifier\n  // to skip constructing a throwaway candidate on repeat `.for()` calls.\n  const specificTokensBySpecifier = new Map();\n\n  const generalToken = Object.assign(target ?? {}, {\n    ...rest,\n\n    tags: [injectionTokenTag, ...(tags ?? [])],\n\n    aliasType: injectionTokenSymbol,\n\n    for: (...specifiers) => {\n      const memoizedToken =\n        specifiers.length === 1\n          ? specificTokensBySpecifier.get(specifiers[0])\n          : undefined;\n\n      if (memoizedToken) {\n        return memoizedToken;\n      }\n\n      const specificTokenCandidate = specificTokenFactory(...specifiers);\n\n      const existingSpecificToken = specificTokensBySpeciality.get(\n        specificTokenCandidate.speciality,\n      );\n\n      if (existingSpecificToken) {\n        if (specifiers.length === 1) {\n          specificTokensBySpecifier.set(specifiers[0], existingSpecificToken);\n        }\n\n        return existingSpecificToken;\n      }\n\n      const specificToken = specificTokenCandidate;\n\n      specificToken.id = `${generalToken.id}/${specificToken.id}`;\n      specificToken.specificTokenOf = generalToken;\n      specificToken.maxCacheSize = generalToken.maxCacheSize;\n      specificToken.tags = generalToken.tags;\n\n      specificTokensBySpeciality.set(specificToken.speciality, specificToken);\n\n      if (specifiers.length === 1) {\n        specificTokensBySpecifier.set(specifiers[0], specificToken);\n      }\n\n      return specificToken;\n    },\n  });\n\n  return generalToken;\n};\n\nexport const getSpecificInjectionToken = (...args) =>\n  getInjectionToken(...args);\n\nconst getSpecificTokenById = id => getInjectionToken({ id, speciality: id });\n", "import { injectionTokenTag } from '../getInjectionToken/injectionTokenTag';\n\nexport const injectionTokenSymbol2 = 'injection-token2';\n\nconst cardinalities = ['one', 'zero-or-one', 'zero-or-many', 'one-or-many'];\n\nconst buildToken = ({\n  specificInjectionTokenFactory,\n  target,\n  tags,\n  ...rest\n}) => {\n  // A specific token may declare its own cardinality \u2014 its family's general\n  // token often has a different one \u2014 and inherits when it does not, which\n  // is why only general tokens are required to declare.\n  if (rest.cardinality === undefined) {\n    if (rest.speciality === undefined) {\n      throw new Error(\n        `Tried to create injection token \"${rest.id}\" without cardinality.`,\n      );\n    }\n  } else if (!cardinalities.includes(rest.cardinality)) {\n    throw new Error(\n      `Tried to create injection token \"${rest.id}\" with unknown cardinality \"${rest.cardinality}\".`,\n    );\n  }\n\n  const specificTokensBySpeciality = new Map();\n\n  // The factory is assumed pure and deterministic: a specifier always maps\n  // to the same token, so single-specifier calls are memoized by specifier\n  // to skip constructing a throwaway candidate on repeat `.for()` calls.\n  const specificTokensBySpecifier = new Map();\n\n  const generalToken = Object.assign(target ?? {}, {\n    ...rest,\n\n    tags: [injectionTokenTag, ...(tags ?? [])],\n\n    aliasType: injectionTokenSymbol2,\n\n    // No factory means no `.for()` at all, matching the type: a token isn't\n    // required to be part of a family. A factory also makes the token\n    // abstract: it's only ever useful resolved via a real `.for()`, so it\n    // cannot be injected/registered directly \u2014 see checkForAbstractTokenFor\n    // and register.js's `injectionToken?.abstract` check.\n    ...(specificInjectionTokenFactory && {\n      abstract: true,\n\n      for: (...specifiers) => {\n        const memoizedToken =\n          specifiers.length === 1\n            ? specificTokensBySpecifier.get(specifiers[0])\n            : undefined;\n\n        if (memoizedToken) {\n          return memoizedToken;\n        }\n\n        const specificTokenCandidate = specificInjectionTokenFactory(\n          ...specifiers,\n        );\n\n        const existingSpecificToken = specificTokensBySpeciality.get(\n          specificTokenCandidate.speciality,\n        );\n\n        if (existingSpecificToken) {\n          if (specifiers.length === 1) {\n            specificTokensBySpecifier.set(specifiers[0], existingSpecificToken);\n          }\n\n          return existingSpecificToken;\n        }\n\n        const specificToken = specificTokenCandidate;\n\n        specificToken.id = `${generalToken.id}/${specificToken.id}`;\n        specificToken.specificTokenOf = generalToken;\n        specificToken.maxCacheSize = generalToken.maxCacheSize;\n        specificToken.tags = generalToken.tags;\n        specificToken.cardinality =\n          specificToken.cardinality ?? generalToken.cardinality;\n\n        specificTokensBySpeciality.set(specificToken.speciality, specificToken);\n\n        if (specifiers.length === 1) {\n          specificTokensBySpecifier.set(specifiers[0], specificToken);\n        }\n\n        return specificToken;\n      },\n    }),\n  });\n\n  return generalToken;\n};\n\nexport const getInjectionToken2 = (...args) => {\n  // A single, non-curried call: options given directly, factory curried as\n  // its own trailing call \u2014 getInjectionToken2(options)(factory), or\n  // getInjectionToken2(options)() for a concrete token with no `.for()` at\n  // all. Passing a factory also makes the token abstract \u2014 see buildToken.\n  // The explicit-SF escape hatch (getInjectionToken2<F, MF, SF>(options))\n  // uses this exact same shape, factory just optional on the trailing call\n  // instead of required \u2014 nothing distinguishes them at runtime, since SF\n  // being spelled out explicitly vs inferred from the factory value is\n  // erased by the time this code runs.\n  //\n  // A `speciality` in options builds a specific token directly \u2014 this is how\n  // getSpecificInjectionToken2 used to be its own function; folded in here\n  // since buildToken already threads `speciality` through via `...rest`\n  // regardless of which creator is called. Unlike the old\n  // getSpecificInjectionToken2, this also accepts a factory, so a specific\n  // token can itself be a family root for nested specificity \u2014 see the\n  // comment on buildToken for why that makes it abstract too.\n  if (args.length !== 1) {\n    throw new Error(\n      `Tried to create injection token${\n        args[0]?.id ? ` \"${args[0].id}\"` : ''\n      } with ${\n        args.length\n      } arguments; getInjectionToken2 takes exactly one (options).`,\n    );\n  }\n\n  const [options] = args;\n\n  return specificInjectionTokenFactory =>\n    buildToken({ ...options, specificInjectionTokenFactory });\n};\n", "import { getInjectionToken } from '../getInjectionToken/getInjectionToken';\nimport { getInjectionToken2 } from '../getInjectionToken2/getInjectionToken2';\n\n// Machinery tokens carry no tags: tag dispatch reads the target's token\n// chain, so a decorator registered under e.g.\n// `instantiationDecoratorToken.for('injectionToken')` would otherwise be\n// found via its own registration token during its own instantiation \u2014\n// infinite recursion. `.for()` children copy the general token's tags at\n// creation, so the exemption propagates to them. (Same role the removed\n// `decorable: false` flag had.)\nconst untagged = token => {\n  token.tags = undefined;\n  return token;\n};\n\nexport const registrationCallbackToken = untagged(\n  getInjectionToken({\n    id: 'registration-callback-token',\n  }),\n);\n\nexport const deregistrationCallbackToken = untagged(\n  getInjectionToken({\n    id: 'deregistration-callback-token',\n  }),\n);\n\nexport const instantiationDecoratorToken = untagged(\n  getInjectionToken2({\n    id: 'instantiate-decorator-token',\n    cardinality: 'zero-or-many',\n  })(target => getInjectionToken2({ id: target.id, speciality: target })()),\n);\n\nexport const injectionDecoratorToken = untagged(\n  getInjectionToken2({\n    id: 'injection-decorator-token',\n    cardinality: 'zero-or-many',\n  })(target => getInjectionToken2({ id: target.id, speciality: target })()),\n);\n\nexport const instancePurgeCallbackToken = untagged(\n  getInjectionToken2({\n    id: 'instance-purge-callback-token',\n    cardinality: 'zero-or-many',\n  })(target => getInjectionToken2({ id: target.id, speciality: target })()),\n);\n\nexport const registrationDecoratorToken = untagged(\n  getInjectionToken2({\n    id: 'registration-decorator-token',\n    cardinality: 'zero-or-many',\n  })(target => getInjectionToken2({ id: target.id, speciality: target })()),\n);\n\nexport const deregistrationDecoratorToken = untagged(\n  getInjectionToken2({\n    id: 'deregistration-decorator-token',\n    cardinality: 'zero-or-many',\n  })(target => getInjectionToken2({ id: target.id, speciality: target })()),\n);\n\nexport const preInjectCallbackToken = untagged(\n  getInjectionToken2({\n    id: 'pre-inject-callback-token',\n    cardinality: 'zero-or-many',\n  })(target => getInjectionToken2({ id: target.id, speciality: target })()),\n);\n", "const isObjectKey = key =>\n  (typeof key === 'object' && key !== null) || typeof key === 'function';\n\nconst makeNode = () => ({\n  layer: new Map(),\n  weakLayer: new WeakMap(),\n  children: new Map(),\n  weakChildren: new WeakMap(),\n  hasWeakEntries: false,\n});\n\nexport class CompositeMap {\n  #internalMap = makeNode();\n\n  constructor(initialValues = []) {\n    for (const [key, value] of initialValues) {\n      this.set(key, value);\n    }\n  }\n\n  #layerFor(mapEntry, key) {\n    return isObjectKey(key) ? mapEntry.weakLayer : mapEntry.layer;\n  }\n\n  #childrenFor(mapEntry, key) {\n    return isObjectKey(key) ? mapEntry.weakChildren : mapEntry.children;\n  }\n\n  #set(mapEntry, key, value) {\n    if (key.length === 1) {\n      const first = key[0];\n      this.#layerFor(mapEntry, first).set(first, value);\n      if (isObjectKey(first)) mapEntry.hasWeakEntries = true;\n    } else {\n      const [first, ...rest] = key;\n      const childMap = this.#childrenFor(mapEntry, first);\n      let nextMapEntry = childMap.get(first);\n\n      if (!nextMapEntry) {\n        nextMapEntry = makeNode();\n        childMap.set(first, nextMapEntry);\n        if (isObjectKey(first)) mapEntry.hasWeakEntries = true;\n      }\n\n      this.#set(nextMapEntry, rest, value);\n    }\n  }\n\n  set(key, value) {\n    if (!Array.isArray(key)) {\n      throw new TypeError('Expected key to be an array');\n    }\n\n    if (key.length === 0) {\n      throw new TypeError('Keys must be at least length 1');\n    }\n\n    this.#set(this.#internalMap, key, value);\n  }\n\n  #get(mapEntry, key) {\n    if (key.length === 1) {\n      return this.#layerFor(mapEntry, key[0]).get(key[0]);\n    } else {\n      const [first, ...rest] = key;\n      const nextMapEntry = this.#childrenFor(mapEntry, first).get(first);\n\n      if (!nextMapEntry) {\n        return undefined;\n      }\n\n      return this.#get(nextMapEntry, rest);\n    }\n  }\n\n  get(key) {\n    if (!Array.isArray(key)) {\n      throw new TypeError('Expected key to be an array');\n    }\n\n    if (key.length === 0) {\n      return undefined;\n    }\n\n    return this.#get(this.#internalMap, key);\n  }\n\n  #has(mapEntry, key) {\n    if (key.length === 1) {\n      return this.#layerFor(mapEntry, key[0]).has(key[0]);\n    } else {\n      const [first, ...rest] = key;\n      const nextMapEntry = this.#childrenFor(mapEntry, first).get(first);\n\n      if (!nextMapEntry) {\n        return false;\n      }\n\n      return this.#has(nextMapEntry, rest);\n    }\n  }\n\n  has(key) {\n    if (!Array.isArray(key)) {\n      throw new TypeError('Expected key to be an array');\n    }\n\n    if (key.length === 0) {\n      return false;\n    }\n\n    return this.#has(this.#internalMap, key);\n  }\n\n  *values() {\n    for (const [, value] of this.entries()) {\n      yield value;\n    }\n  }\n\n  *keys() {\n    for (const [key] of this.entries()) {\n      yield key;\n    }\n  }\n\n  *#entries(mapEntry, key) {\n    for (const [layerKey, layerValue] of mapEntry.layer.entries()) {\n      yield [[...key, layerKey], layerValue];\n    }\n\n    for (const [layerKey, layerMapEntry] of mapEntry.children.entries()) {\n      yield* this.#entries(layerMapEntry, [...key, layerKey]);\n    }\n  }\n\n  *entries() {\n    yield* this.#entries(this.#internalMap, []);\n  }\n\n  #canPrune(node) {\n    return (\n      !node.hasWeakEntries && node.layer.size === 0 && node.children.size === 0\n    );\n  }\n\n  #delete(mapEntry, key) {\n    if (key.length === 1) {\n      return this.#layerFor(mapEntry, key[0]).delete(key[0]);\n    }\n\n    const [first, ...rest] = key;\n    const childMap = this.#childrenFor(mapEntry, first);\n    const nextMapEntry = childMap.get(first);\n\n    if (!nextMapEntry) {\n      return false;\n    }\n\n    const deleted = this.#delete(nextMapEntry, rest);\n\n    if (deleted && this.#canPrune(nextMapEntry)) {\n      childMap.delete(first);\n    }\n\n    return deleted;\n  }\n\n  delete(key) {\n    if (!Array.isArray(key) || key.length === 0) {\n      return false;\n    }\n\n    return this.#delete(this.#internalMap, key);\n  }\n\n  #forEachInSubtree(mapEntry, onValue) {\n    for (const value of mapEntry.layer.values()) {\n      onValue(value);\n    }\n\n    for (const childEntry of mapEntry.children.values()) {\n      this.#forEachInSubtree(childEntry, onValue);\n    }\n  }\n\n  #deleteByPrefix(mapEntry, keyPrefix, onValue) {\n    if (keyPrefix.length === 1) {\n      const key = keyPrefix[0];\n      const layer = this.#layerFor(mapEntry, key);\n      const childMap = this.#childrenFor(mapEntry, key);\n      let deleted = false;\n\n      if (layer.has(key)) {\n        if (onValue) onValue(layer.get(key));\n        layer.delete(key);\n        deleted = true;\n      }\n\n      const childEntry = childMap.get(key);\n\n      if (childEntry) {\n        if (onValue) this.#forEachInSubtree(childEntry, onValue);\n        childMap.delete(key);\n        deleted = true;\n      }\n\n      return deleted;\n    }\n\n    const [first, ...rest] = keyPrefix;\n    const childMap = this.#childrenFor(mapEntry, first);\n    const nextMapEntry = childMap.get(first);\n\n    if (!nextMapEntry) {\n      return false;\n    }\n\n    const deleted = this.#deleteByPrefix(nextMapEntry, rest, onValue);\n\n    if (deleted && this.#canPrune(nextMapEntry)) {\n      childMap.delete(first);\n    }\n\n    return deleted;\n  }\n\n  deleteByPrefix(keyPrefix, onValue) {\n    if (!Array.isArray(keyPrefix) || keyPrefix.length === 0) {\n      return false;\n    }\n\n    return this.#deleteByPrefix(this.#internalMap, keyPrefix, onValue);\n  }\n\n  clear() {\n    this.#internalMap = makeNode();\n  }\n}\n", "import { CompositeMap } from './composite-map';\n\nexport class LruCompositeMap {\n  #inner = new CompositeMap();\n  #maxSize;\n  #size = 0;\n  #head = null;\n  #tail = null;\n  #onEvict;\n\n  constructor(maxSize, { onEvict } = {}) {\n    this.#maxSize = maxSize;\n    this.#onEvict = onEvict;\n  }\n\n  #addToHead(node) {\n    node.next = this.#head;\n    node.prev = null;\n\n    if (this.#head) {\n      this.#head.prev = node;\n    }\n\n    this.#head = node;\n\n    if (!this.#tail) {\n      this.#tail = node;\n    }\n  }\n\n  #removeNode(node) {\n    if (node.prev) {\n      node.prev.next = node.next;\n    } else {\n      this.#head = node.next;\n    }\n\n    if (node.next) {\n      node.next.prev = node.prev;\n    } else {\n      this.#tail = node.prev;\n    }\n\n    node.prev = null;\n    node.next = null;\n  }\n\n  #promoteNode(node) {\n    if (node === this.#head) return;\n    this.#removeNode(node);\n    this.#addToHead(node);\n  }\n\n  #evictLru() {\n    const lruNode = this.#tail;\n    const key = lruNode.key;\n    const wrapper = this.#inner.get(key);\n    this.#removeNode(lruNode);\n    this.#inner.delete(key);\n    this.#size--;\n\n    if (this.#onEvict) this.#onEvict(wrapper.value, key);\n  }\n\n  get(key) {\n    const wrapper = this.#inner.get(key);\n\n    if (wrapper === undefined) {\n      return undefined;\n    }\n\n    this.#promoteNode(wrapper.lruNode);\n\n    return wrapper.value;\n  }\n\n  set(key, value) {\n    const existing = this.#inner.get(key);\n\n    if (existing) {\n      existing.value = value;\n      this.#promoteNode(existing.lruNode);\n      return;\n    }\n\n    const lruNode = { key, prev: null, next: null };\n    this.#inner.set(key, { value, lruNode });\n    this.#addToHead(lruNode);\n    this.#size++;\n\n    if (this.#size > this.#maxSize) {\n      this.#evictLru();\n    }\n  }\n\n  has(key) {\n    return this.#inner.has(key);\n  }\n\n  *values() {\n    for (const wrapper of this.#inner.values()) {\n      yield wrapper.value;\n    }\n  }\n\n  *keys() {\n    yield* this.#inner.keys();\n  }\n\n  *entries() {\n    for (const [key, wrapper] of this.#inner.entries()) {\n      yield [key, wrapper.value];\n    }\n  }\n\n  deleteByPrefix(keyPrefix) {\n    return this.#inner.deleteByPrefix(keyPrefix, wrapper => {\n      this.#removeNode(wrapper.lruNode);\n      this.#size--;\n    });\n  }\n\n  clear() {\n    this.#inner.clear();\n    this.#head = null;\n    this.#tail = null;\n    this.#size = 0;\n  }\n}\n", "export default (...functions) =>\n  x => {\n    let val = x;\n\n    functions.forEach(f => {\n      val = f(val);\n    });\n\n    return val;\n  };\n", "import { nonStoredInstanceKey, storedInstanceKey } from './lifecycleEnum';\nimport { isCompositeKey } from '../getCompositeKey/getCompositeKey';\nimport { injectableSymbol } from '../getInjectable/getInjectable';\nimport { injectableSymbol2 } from '../getInjectable2/getInjectable2';\nimport { instantiationDecoratorToken } from './tokens';\nimport { CompositeMap } from '../composite-map/composite-map';\nimport { LruCompositeMap } from '../composite-map/lru-composite-map';\nimport flow from './fastFlow';\n\n// Pre-allocated key for singleton instance lookup \u2014 avoids array creation per inject()\nconst singletonCompositeKey = [storedInstanceKey];\n\n// Detects the keyedSingleton storage shape. Singletons (and v2-default\n// injectables that have only ever been called without args) store the\n// instance directly; keyedSingleton with-args storage uses a CompositeMap.\nexport const isCompositeStorage = stored =>\n  stored instanceof CompositeMap || stored instanceof LruCompositeMap;\n\nexport const privateInjectFor =\n  ({\n    getRelatedInjectables,\n    injectableSet,\n    alreadyInjected,\n    overridingInjectables,\n    instancesByInjectableMap,\n    getDi,\n    checkForNoMatches,\n    checkForTooManyMatches,\n    checkForSideEffects,\n    checkForAbstractToken,\n    checkForNonMaybeCardinality,\n    namespacedIdByInjectableMap,\n    getNamespacedId,\n    getApplicableDecorators,\n  }) =>\n  ({ withMeta }) =>\n  ({ alias, instantiationParameters, injectingInjectable }) => {\n    const di = getDi();\n\n    let originalInjectable;\n\n    // Fast path: alias is itself an injectable (the dominant case \u2014 every\n    // call from privateInjectMany lands here because it iterates resolved\n    // injectables). Skip getRelatedInjectables (which would allocate a\n    // single-element [alias] array), the single-match/no-match validators,\n    // and the abstract-token check (injectables are never abstract).\n    const aliasType = alias.aliasType;\n\n    if (aliasType === injectableSymbol || aliasType === injectableSymbol2) {\n      if (!injectableSet.has(alias)) {\n        // Reuse the existing throw with the same wording as the token path.\n        checkForNoMatches([], alias, injectingInjectable);\n      }\n      originalInjectable = alias;\n    } else {\n      checkForAbstractToken(alias, injectingInjectable);\n\n      const relatedInjectables = getRelatedInjectables(alias);\n\n      checkForTooManyMatches(relatedInjectables, alias, injectingInjectable);\n      checkForNoMatches(relatedInjectables, alias, injectingInjectable);\n\n      originalInjectable = relatedInjectables[0];\n    }\n\n    alreadyInjected.add(originalInjectable);\n\n    const injectable =\n      overridingInjectables.size > 0\n        ? overridingInjectables.get(originalInjectable) || originalInjectable\n        : originalInjectable;\n\n    checkForSideEffects(injectable, injectingInjectable);\n\n    // Backward compat: old-style singletons tolerated `inject(alias, undefined)`.\n    // Normalize all-undefined args to [] so fast-path and singleton guard behave\n    // as if no parameter was supplied.\n    if (\n      injectable.aliasType !== injectableSymbol2 &&\n      injectable.lifecycle.id === 'singleton' &&\n      instantiationParameters.length > 0 &&\n      instantiationParameters.every(p => p === undefined)\n    ) {\n      instantiationParameters = [];\n    }\n\n    // Fast path: singleton cache hit \u2014 avoid creating minimalDi entirely.\n    // The stored value is one of:\n    //   - undefined: nothing cached yet\n    //   - CompositeMap / LruCompositeMap: keyedSingleton cache, look up by\n    //     singletonCompositeKey for a no-args call\n    //   - any other value: instance directly (singleton lifecycle, or v2\n    //     default lifecycle that has only ever been called with no args)\n    //\n    // We dispatch on lifecycle.id first so plain singletons (the dominant\n    // case) skip the instanceof checks entirely; only keyedSingleton-shaped\n    // lifecycles fall through to the structural check.\n    if (instantiationParameters.length === 0) {\n      const stored = instancesByInjectableMap.get(\n        injectable.overriddenInjectable || injectable,\n      );\n\n      let existingInstance;\n\n      if (injectable.lifecycle.id === 'singleton') {\n        existingInstance = stored;\n      } else if (isCompositeStorage(stored)) {\n        existingInstance = stored.get(singletonCompositeKey);\n      } else {\n        existingInstance = stored;\n      }\n\n      if (existingInstance) {\n        if (!withMeta) {\n          return existingInstance;\n        }\n\n        return {\n          instance: existingInstance,\n          meta: { id: namespacedIdByInjectableMap.get(injectable) },\n        };\n      }\n    }\n\n    const instance = getInstance(\n      di,\n      injectable,\n      instantiationParameters,\n      instancesByInjectableMap,\n      injectingInjectable,\n      namespacedIdByInjectableMap,\n      getNamespacedId,\n      getApplicableDecorators,\n      checkForNonMaybeCardinality,\n    );\n\n    if (!withMeta) {\n      return instance;\n    }\n\n    return {\n      instance,\n      meta: { id: namespacedIdByInjectableMap.get(injectable) },\n    };\n  };\n\nconst createMinimalDi = (\n  di,\n  injectableToBeInstantiated,\n  injectingInjectable,\n  namespacedIdByInjectableMap,\n  checkForNonMaybeCardinality,\n) => {\n  // Closure-captured methods are fixed up-front (`shared` plus inject*),\n  // so user code can detach them \u2014 `const { register } = di; register(...)`\n  // and similar patterns appear in tests. A class-with-prototype dispatcher\n  // would be cheaper to allocate but loses that detach-friendly behavior.\n  const shared = {\n    register: (...injectables) => {\n      di.register({\n        injectables,\n        context: [{ injectable: injectableToBeInstantiated }],\n        source: injectableToBeInstantiated,\n      });\n    },\n\n    deregister: (...injectables) => {\n      di.deregister({\n        injectables,\n        context: [{ injectable: injectableToBeInstantiated }],\n        source: injectableToBeInstantiated,\n      });\n    },\n\n    get sourceNamespace() {\n      const nsId = namespacedIdByInjectableMap.get(injectingInjectable);\n      const lastColon = nsId ? nsId.lastIndexOf(':') : -1;\n\n      return lastColon > 0 ? nsId.slice(0, lastColon) : undefined;\n    },\n\n    hasRegistrations: di.hasRegistrations,\n    getNumberOfRegistrations: di.getNumberOfRegistrations,\n    getNumberOfInstances: di.getNumberOfInstances,\n\n    purge: (alias, ...keyParts) =>\n      di.scopedPurge(injectableToBeInstantiated, alias, ...keyParts),\n\n    registeredInLocalScope: alias =>\n      di.registeredInScopeOf(injectableToBeInstantiated, alias),\n\n    registeredInLocalScopeSubtree: alias =>\n      di.registeredInSubtreeOf(injectableToBeInstantiated, alias),\n  };\n\n  if (injectableToBeInstantiated.aliasType === injectableSymbol2) {\n    // V2 minimalDi: inject/injectMany/etc are factory-returning. Each method\n    // is inlined directly against `di` (no minimalInject* intermediary) so\n    // we don't allocate four extra closures per minimalDi just to forward.\n    return {\n      ...shared,\n\n      inject:\n        alias =>\n        (...params) =>\n          di.inject({\n            alias,\n            instantiationParameters: params,\n            injectingInjectable: injectableToBeInstantiated,\n          }),\n\n      injectMany:\n        alias =>\n        (...params) =>\n          di.injectMany({\n            alias,\n            instantiationParameters: params,\n            injectingInjectable: injectableToBeInstantiated,\n          }),\n\n      injectMaybe: alias => {\n        checkForNonMaybeCardinality(alias, injectableToBeInstantiated);\n\n        return (...params) =>\n          di.injectMany({\n            alias,\n            instantiationParameters: params,\n            injectingInjectable: injectableToBeInstantiated,\n          })[0];\n      },\n\n      injectWithMeta:\n        alias =>\n        (...params) =>\n          di.injectWithMeta({\n            alias,\n            instantiationParameters: params,\n            injectingInjectable: injectableToBeInstantiated,\n          }),\n\n      injectManyWithMeta:\n        alias =>\n        (...params) =>\n          di.injectManyWithMeta({\n            alias,\n            instantiationParameters: params,\n            injectingInjectable: injectableToBeInstantiated,\n          }),\n\n      injectMaybeWithMeta: alias => {\n        checkForNonMaybeCardinality(alias, injectableToBeInstantiated);\n\n        return (...params) =>\n          di.injectManyWithMeta({\n            alias,\n            instantiationParameters: params,\n            injectingInjectable: injectableToBeInstantiated,\n          })[0];\n      },\n    };\n  }\n\n  // V1 minimalDi: inject/injectMany/etc return instances directly.\n  const minimalInject = (alias, ...args) =>\n    di.inject({\n      alias,\n      instantiationParameters: args,\n      injectingInjectable: injectableToBeInstantiated,\n    });\n\n  const minimalInjectMany = (alias, ...args) =>\n    di.injectMany({\n      alias,\n      instantiationParameters: args,\n      injectingInjectable: injectableToBeInstantiated,\n    });\n\n  const minimalInjectWithMeta = (alias, ...args) =>\n    di.injectWithMeta({\n      alias,\n      instantiationParameters: args,\n      injectingInjectable: injectableToBeInstantiated,\n    });\n\n  const minimalInjectManyWithMeta = (alias, ...args) =>\n    di.injectManyWithMeta({\n      alias,\n      instantiationParameters: args,\n      injectingInjectable: injectableToBeInstantiated,\n    });\n\n  return {\n    ...shared,\n\n    inject: minimalInject,\n    injectMany: minimalInjectMany,\n    injectWithMeta: minimalInjectWithMeta,\n    injectManyWithMeta: minimalInjectManyWithMeta,\n\n    injectFactory:\n      alias =>\n      (...params) =>\n        minimalInject(alias, ...params),\n  };\n};\n\nconst instantiate = (\n  di,\n  injectableToBeInstantiated,\n  minimalDi,\n  instantiationParameters,\n  getApplicableDecorators,\n) => {\n  // Decorators always look up against the original injectable so that an\n  // imperative override (di.override / di.earlyOverride) is wrapped by any\n  // decorators registered against the original target \u2014 composing decorators\n  // rely on this.\n  const target =\n    injectableToBeInstantiated.overriddenInjectable ||\n    injectableToBeInstantiated;\n\n  const decorators = getApplicableDecorators({\n    decoratorToken: instantiationDecoratorToken,\n    target,\n    injectingInjectable: injectableToBeInstantiated,\n  });\n\n  const decorated =\n    decorators.length === 0\n      ? injectableToBeInstantiated.instantiate\n      : flow(...decorators)(injectableToBeInstantiated.instantiate);\n\n  // New-style injectable2: curried (di) => (...params) => instance\n  if (injectableToBeInstantiated.aliasType === injectableSymbol2) {\n    return decorated(minimalDi)(...instantiationParameters);\n  }\n\n  // Old-style: (di, ...params) => instance\n  return decorated(minimalDi, ...instantiationParameters);\n};\n\nconst ensureInstanceMap = (instancesByInjectableMap, key) => {\n  let instanceMap = instancesByInjectableMap.get(key);\n\n  if (!instanceMap) {\n    instanceMap = new CompositeMap();\n    instancesByInjectableMap.set(key, instanceMap);\n  }\n\n  return instanceMap;\n};\n\nconst getInstance = (\n  di,\n  injectableToBeInstantiated,\n  instantiationParameters,\n  instancesByInjectableMap,\n  injectingInjectable,\n  namespacedIdByInjectableMap,\n  getNamespacedId,\n  getApplicableDecorators,\n  checkForNonMaybeCardinality,\n) => {\n  const cacheKey =\n    injectableToBeInstantiated.overriddenInjectable ||\n    injectableToBeInstantiated;\n\n  const lifecycleId = injectableToBeInstantiated.lifecycle.id;\n\n  // Singleton: fast path in privateInjectFor already checked cache and missed.\n  // Skip redundant getInstanceKey + cache check \u2014 go straight to instantiation.\n  if (lifecycleId === 'singleton') {\n    if (instantiationParameters.length > 0) {\n      throw new Error(\n        `Tried to inject singleton \"${getNamespacedId(\n          injectableToBeInstantiated,\n        )}\" from \"${getNamespacedId(\n          injectingInjectable,\n        )}\", but illegally to singletons, instantiationParameters were provided: \"${instantiationParameters}\".`,\n      );\n    }\n\n    const minimalDi = createMinimalDi(\n      di,\n      injectableToBeInstantiated,\n      injectingInjectable,\n      namespacedIdByInjectableMap,\n      checkForNonMaybeCardinality,\n    );\n\n    const newInstance = instantiate(\n      di,\n      injectableToBeInstantiated,\n      minimalDi,\n      instantiationParameters,\n      getApplicableDecorators,\n    );\n\n    // Singletons store the instance directly in the map \u2014 no per-injectable\n    // CompositeMap wrapper. Saves ~5 object allocations per first-inject.\n    instancesByInjectableMap.set(cacheKey, newInstance);\n\n    return newInstance;\n  }\n\n  // Transient: never cached \u2014 skip key resolution, cache check, and cache store.\n  if (lifecycleId === 'transient') {\n    const minimalDi = createMinimalDi(\n      di,\n      injectableToBeInstantiated,\n      injectingInjectable,\n      namespacedIdByInjectableMap,\n      checkForNonMaybeCardinality,\n    );\n\n    return instantiate(\n      di,\n      injectableToBeInstantiated,\n      minimalDi,\n      instantiationParameters,\n      getApplicableDecorators,\n    );\n  }\n\n  // V2-default + no-args fast path: behaves like a singleton. Skip\n  // getInstanceKey + key-array allocation + CompositeMap allocation. The\n  // instance is stored directly under cacheKey, matching the singleton\n  // shape. If the same v2 injectable is later called with args (rare mixed\n  // usage), the keyedSingleton path below migrates the existing instance\n  // into a CompositeMap under singletonCompositeKey before adding the new\n  // keyed entry.\n  if (\n    instantiationParameters.length === 0 &&\n    injectableToBeInstantiated.lifecycle._isV2DefaultLifecycle\n  ) {\n    const existing = instancesByInjectableMap.get(cacheKey);\n\n    if (!isCompositeStorage(existing)) {\n      const minimalDi = createMinimalDi(\n        di,\n        injectableToBeInstantiated,\n        injectingInjectable,\n        namespacedIdByInjectableMap,\n        checkForNonMaybeCardinality,\n      );\n\n      const newInstance = instantiate(\n        di,\n        injectableToBeInstantiated,\n        minimalDi,\n        instantiationParameters,\n        getApplicableDecorators,\n      );\n\n      instancesByInjectableMap.set(cacheKey, newInstance);\n      return newInstance;\n    }\n    // existing is a CompositeMap (mixed usage path) \u2014 fall through.\n  }\n\n  // keyedSingleton / custom lifecycle: full key resolution + cache check.\n  const minimalDi = createMinimalDi(\n    di,\n    injectableToBeInstantiated,\n    injectingInjectable,\n    namespacedIdByInjectableMap,\n    checkForNonMaybeCardinality,\n  );\n\n  const instanceKey = injectableToBeInstantiated.lifecycle.getInstanceKey(\n    minimalDi,\n    ...instantiationParameters,\n  );\n\n  const instanceCompositeKey = isCompositeKey(instanceKey)\n    ? instanceKey.keys\n    : [instanceKey];\n\n  let existingMap = instancesByInjectableMap.get(cacheKey);\n\n  // Mixed-usage migration: only v2-default injectables can have arrived\n  // here with an instance in the slot (from a prior no-args call). For\n  // every other keyedSingleton, the slot is either undefined or a\n  // CompositeMap, so skip the structural check.\n  if (\n    injectableToBeInstantiated.lifecycle._isV2DefaultLifecycle &&\n    existingMap !== undefined &&\n    !isCompositeStorage(existingMap)\n  ) {\n    const previousInstance = existingMap;\n    existingMap = new CompositeMap();\n    existingMap.set(singletonCompositeKey, previousInstance);\n    instancesByInjectableMap.set(cacheKey, existingMap);\n  }\n\n  const existingInstance = existingMap?.get(instanceCompositeKey);\n\n  if (existingInstance) {\n    return existingInstance;\n  }\n\n  const newInstance = instantiate(\n    di,\n    injectableToBeInstantiated,\n    minimalDi,\n    instantiationParameters,\n    getApplicableDecorators,\n  );\n\n  if (instanceCompositeKey[0] !== nonStoredInstanceKey) {\n    ensureInstanceMap(instancesByInjectableMap, cacheKey).set(\n      instanceCompositeKey,\n      newInstance,\n    );\n  }\n\n  return newInstance;\n};\n", "import flow from './fastFlow';\nimport { injectionDecoratorToken } from './tokens';\n\nexport const withInjectionDecoratorsFor =\n  ({ decoratorCache, getApplicableDecorators }) =>\n  toBeDecorated =>\n  ({ alias, instantiationParameters, injectingInjectable }) => {\n    // When decoratorCache.injection is null, a decorator was registered or\n    // deregistered \u2014 invalidate all per-alias cached compositions.\n    if (decoratorCache.injection === null) {\n      decoratorCache.injection = true;\n      decoratorCache.injectionByAlias = new Map();\n    }\n\n    let decorated = decoratorCache.injectionByAlias.get(alias);\n\n    if (decorated === undefined) {\n      const decorators = getApplicableDecorators({\n        decoratorToken: injectionDecoratorToken,\n        target: alias,\n        injectingInjectable,\n      });\n\n      if (decorators.length > 0) {\n        const boundInject = (...params) =>\n          toBeDecorated({\n            alias,\n            instantiationParameters: params,\n            injectingInjectable,\n          });\n\n        decorated = flow(...decorators)(boundInject);\n      } else {\n        decorated = null;\n      }\n\n      decoratorCache.injectionByAlias.set(alias, decorated);\n    }\n\n    if (decorated === null) {\n      return toBeDecorated({\n        alias,\n        instantiationParameters,\n        injectingInjectable,\n      });\n    }\n\n    return decorated(...instantiationParameters);\n  };\n", "export const privateInjectManyFor =\n  ({ getRelatedInjectables, getInject, namespacedIdByInjectableMap }) =>\n  ({ withMeta }) =>\n  ({ alias, instantiationParameters, injectingInjectable }) => {\n    const inject = getInject();\n\n    const relatedInjectables = getRelatedInjectables(alias);\n    const n = relatedInjectables.length;\n\n    if (n === 0) {\n      return [];\n    }\n\n    const result = new Array(n);\n\n    // The arg object is reused across iterations \u2014 privateInjectFor\n    // destructures it on entry and never retains a reference, so mutating\n    // .alias between calls is safe.\n    const arg = {\n      alias: undefined,\n      instantiationParameters,\n      injectingInjectable: alias,\n    };\n\n    if (withMeta) {\n      for (let i = 0; i < n; i++) {\n        const injectable = relatedInjectables[i];\n        arg.alias = injectable;\n        const instance = inject(arg);\n        result[i] = {\n          instance,\n          meta: { id: namespacedIdByInjectableMap.get(injectable) },\n        };\n      }\n    } else {\n      for (let i = 0; i < n; i++) {\n        arg.alias = relatedInjectables[i];\n        result[i] = inject(arg);\n      }\n    }\n\n    return result;\n  };\n", "import { injectionTokenSymbol } from './getInjectionToken';\nimport { injectionTokenSymbol2 } from '../getInjectionToken2/getInjectionToken2';\n\nexport default maybeInjectionToken =>\n  maybeInjectionToken?.aliasType === injectionTokenSymbol ||\n  maybeInjectionToken?.aliasType === injectionTokenSymbol2;\n", "import isInjectionToken from '../getInjectionToken/isInjectionToken';\n\nexport const getNamespacedIdFor = injectableAndRegistrationContext => {\n  return alias => {\n    const id = isInjectionToken(alias) ? `(${alias.id})` : alias.id;\n\n    // Fast path: container-level registration (the common case).\n    // Context is [containerRootContextItem] \u2014 parent is the container itself.\n    const registrationContext = injectableAndRegistrationContext.get(alias);\n\n    if (!registrationContext) {\n      return id;\n    }\n\n    const immediateParent = registrationContext[registrationContext.length - 1];\n\n    if (\n      !immediateParent ||\n      immediateParent.injectable.aliasType === 'container'\n    ) {\n      return id;\n    }\n\n    // Slow path: nested registration \u2014 walk the parent chain.\n    const ids = [immediateParent.injectable.id];\n    let current = immediateParent.injectable;\n\n    while (true) {\n      const parentContext = injectableAndRegistrationContext.get(current);\n\n      if (!parentContext) {\n        break;\n      }\n\n      const parent = parentContext[parentContext.length - 1];\n\n      if (!parent || parent.injectable.aliasType === 'container') {\n        break;\n      }\n\n      ids.push(parent.injectable.id);\n      current = parent.injectable;\n    }\n\n    ids.reverse();\n    ids.push(id);\n    return ids.join(':');\n  };\n};\n", "export const injectableBunchSymbol = 'injectable-bunch';\n\nexport default bunch =>\n  Object.assign(bunch, {\n    aliasType: injectableBunchSymbol,\n  });\n", "import { injectableBunchSymbol } from './getInjectableBunch';\n\nexport default maybeInjectableBunch =>\n  maybeInjectableBunch?.aliasType === injectableBunchSymbol;\n", "import { injectableSymbol } from './getInjectable';\nimport { injectableSymbol2 } from '../getInjectable2/getInjectable2';\n\nexport default maybeInjectable =>\n  maybeInjectable?.aliasType === injectableSymbol ||\n  maybeInjectable?.aliasType === injectableSymbol2;\n", "import isInjectableBunch from '../getInjectableBunch/isInjectableBunch';\nimport isInjectable from '../getInjectable/isInjectable';\n\nconst collectDeepBunchValues = (bunch, out) => {\n  const values = Object.values(bunch);\n\n  for (let i = 0; i < values.length; i++) {\n    const thing = values[i];\n\n    if (isInjectableBunch(thing)) {\n      collectDeepBunchValues(thing, out);\n    } else if (isInjectable(thing)) {\n      out.push(thing);\n    }\n  }\n};\n\nexport default injectables => {\n  const result = [];\n\n  for (let i = 0; i < injectables.length; i++) {\n    const injectable = injectables[i];\n\n    if (isInjectableBunch(injectable)) {\n      collectDeepBunchValues(injectable, result);\n    } else {\n      result.push(injectable);\n    }\n  }\n\n  return result;\n};\n", "// Token hierarchies (specificTokenOf chains) are immutable \u2014 cache per token.\nconst tokenChainCache = new WeakMap();\n\nexport const getRelatedTokens = token => {\n  if (token === undefined) {\n    return emptyArray;\n  }\n\n  let cached = tokenChainCache.get(token);\n\n  if (cached) {\n    return cached;\n  }\n\n  const tokens = [];\n  let current = token;\n\n  while (current !== undefined) {\n    tokens.push(current);\n    current = current.specificTokenOf;\n  }\n\n  tokenChainCache.set(token, tokens);\n\n  return tokens;\n};\n\nexport const isRelatedToToken = (token, ancestor) => {\n  let current = token;\n\n  while (current) {\n    if (current === ancestor) return true;\n    current = current.specificTokenOf;\n  }\n\n  return false;\n};\n\nconst emptyArray = [];\n", "import isInjectable from '../getInjectable/isInjectable';\n\n// Cached array per token \u2014 avoids spreading Set to Array on every inject() call.\n// Invalidated by setting to null when the Set is mutated (register/deregister).\nconst arrayCache = new WeakMap();\n\nconst EMPTY = Object.freeze([]);\n\nconst getCachedArray = set => {\n  let arr = arrayCache.get(set);\n\n  if (!arr) {\n    arr = [...set];\n    arrayCache.set(set, arr);\n  }\n\n  return arr;\n};\n\nexport const invalidateRelatedInjectablesCache = set => {\n  arrayCache.delete(set);\n};\n\nexport const getRelatedInjectablesFor =\n  ({ injectablesByInjectionToken, injectableSet }) =>\n  alias => {\n    if (isInjectable(alias)) {\n      return injectableSet.has(alias) ? [alias] : EMPTY;\n    }\n\n    const set = injectablesByInjectionToken.get(alias);\n\n    if (!set || set.size === 0) {\n      return EMPTY;\n    }\n\n    return getCachedArray(set);\n  };\n", "import { getNamespacedIdFor } from './getNamespacedIdFor';\nimport {\n  instantiationDecoratorToken,\n  registrationCallbackToken,\n  registrationDecoratorToken,\n} from './tokens';\nimport toFlatInjectables from './toFlatInjectables';\nimport { LruCompositeMap } from '../composite-map/lru-composite-map';\nimport { getRelatedTokens, isRelatedToToken } from './getRelatedTokens';\nimport { invalidateRelatedInjectablesCache } from './getRelatedInjectablesFor';\nimport flow from './fastFlow';\n\nexport const registerFor =\n  ({ registerSingle, injectMany, getApplicableDecorators }) =>\n  ({ injectables, context, source }) => {\n    const flatInjectables = toFlatInjectables(injectables);\n\n    // Phase 0: instantiation-decorator-tagged injectables. They register\n    //   first so that any same-batch overrides of (registration-)decorators\n    //   are already in place by the time those decorators are instantiated\n    //   in phase 2. They go through the registration-decorator pipeline so\n    //   production code can opt them out via tag/target-keyed decorators.\n    // Phase 1: registration-decorator-tagged injectables. They register\n    //   directly via registerSingle (no recursive decoration) to avoid\n    //   bootstrap chaos.\n    // Phase 2: regular injectables register through the decorator pipeline.\n    const phase0Injectables = [];\n    const registeredRegistrationDecoratorInjectables = [];\n    const phase2Injectables = [];\n\n    for (let i = 0; i < flatInjectables.length; i++) {\n      const injectable = flatInjectables[i];\n\n      if (\n        isRelatedToToken(injectable.injectionToken, registrationDecoratorToken)\n      ) {\n        registerSingle(injectable, context);\n        registeredRegistrationDecoratorInjectables.push(injectable);\n      } else if (\n        isRelatedToToken(injectable.injectionToken, instantiationDecoratorToken)\n      ) {\n        phase0Injectables.push(injectable);\n      } else {\n        phase2Injectables.push(injectable);\n      }\n    }\n\n    let batchInProgress = true;\n    const registeredInjectables = [];\n\n    const fireCallbacksFor = injectable => {\n      const callbacks = injectMany({\n        alias: registrationCallbackToken,\n        instantiationParameters: [],\n        injectingInjectable: source,\n      });\n\n      for (let j = 0; j < callbacks.length; j++) {\n        callbacks[j](injectable);\n      }\n    };\n\n    const registerThroughPipeline = injectable => {\n      const decorators = getApplicableDecorators({\n        decoratorToken: registrationDecoratorToken,\n        target: injectable,\n        injectingInjectable: source,\n      });\n\n      if (decorators.length === 0) {\n        registerSingle(injectable, context);\n        registeredInjectables.push(injectable);\n        return;\n      }\n\n      let wasRegisteredThisInjectable = false;\n\n      const boundRegisterSingle = inj => {\n        registerSingle(inj, context);\n        wasRegisteredThisInjectable = true;\n\n        if (!batchInProgress) {\n          fireCallbacksFor(inj);\n        }\n      };\n\n      const decoratedRegister = flow(...decorators)(boundRegisterSingle);\n\n      decoratedRegister(injectable);\n\n      if (wasRegisteredThisInjectable) {\n        registeredInjectables.push(injectable);\n      }\n    };\n\n    phase0Injectables.forEach(registerThroughPipeline);\n    phase2Injectables.forEach(registerThroughPipeline);\n\n    batchInProgress = false;\n\n    const callbacks = injectMany({\n      alias: registrationCallbackToken,\n      instantiationParameters: [],\n      injectingInjectable: source,\n    });\n\n    // Skip the per-injectable forEach loop entirely when no registration\n    // callbacks are wired up \u2014 this avoids 30k+ trivial function calls\n    // during a 30k-injectable bootstrap with no callbacks (the perf-test\n    // case and the common case).\n    if (callbacks.length === 0) {\n      return;\n    }\n\n    const fireBatchCallbacks = injectable => {\n      for (let j = 0; j < callbacks.length; j++) {\n        callbacks[j](injectable);\n      }\n    };\n\n    registeredRegistrationDecoratorInjectables.forEach(fireBatchCallbacks);\n    registeredInjectables.forEach(fireBatchCallbacks);\n  };\n\nexport const registerSingleFor = ({\n  injectableSet,\n  injectableIdSet,\n  instancesByInjectableMap,\n  namespacedIdByInjectableMap,\n  injectablesByInjectionToken,\n  injectableAndRegistrationContext,\n  childrenByParentMap,\n  firePurgeCallbacks,\n}) => {\n  const getNamespacedId = getNamespacedIdFor(injectableAndRegistrationContext);\n\n  return (injectable, injectionContext) => {\n    const injectableId = injectable.id;\n\n    if (!injectableId) {\n      throw new Error('Tried to register injectable without ID.');\n    }\n\n    // Build reverse index: for each parent in the context, record this injectable as a child.\n    for (let i = 0; i < injectionContext.length; i++) {\n      const parent = injectionContext[i].injectable;\n      let children = childrenByParentMap.get(parent);\n\n      if (!children) {\n        children = new Set();\n        childrenByParentMap.set(parent, children);\n      }\n\n      children.add(injectable);\n    }\n\n    // Fast path: container-level registration (the dominant case) yields a\n    // namespaced id equal to the bare id \u2014 skip the Map roundtrip + parent\n    // walk inside getNamespacedId, and skip recording the registration\n    // context altogether (`getNamespacedIdFor` and `deregister` both treat\n    // a missing entry as \"no nested context\" already).\n    const immediateParent =\n      injectionContext.length > 0\n        ? injectionContext[injectionContext.length - 1]\n        : undefined;\n\n    const isContainerLevel =\n      !immediateParent || immediateParent.injectable.aliasType === 'container';\n\n    if (!isContainerLevel) {\n      injectableAndRegistrationContext.set(injectable, injectionContext);\n    }\n\n    const namespacedId = isContainerLevel\n      ? injectableId\n      : getNamespacedId(injectable);\n\n    if (namespacedIdByInjectableMap.has(injectable)) {\n      throw new Error(\n        `Tried to register same injectable multiple times: \"${namespacedIdByInjectableMap.get(\n          injectable,\n        )}\"`,\n      );\n    }\n\n    if (injectableIdSet.has(namespacedId)) {\n      throw new Error(\n        `Tried to register multiple injectables for ID \"${namespacedId}\"`,\n      );\n    }\n\n    const upperBoundedCardinality =\n      injectable.injectionToken?.cardinality === 'one' ||\n      injectable.injectionToken?.cardinality === 'zero-or-one'\n        ? injectable.injectionToken.cardinality\n        : undefined;\n\n    if (upperBoundedCardinality) {\n      const token = injectable.injectionToken;\n      const registered = injectablesByInjectionToken.get(token);\n\n      if (registered) {\n        for (const member of registered) {\n          // Exact registrations only: the index also holds `.for()`\n          // descendants of the token, and specialization must not be\n          // outlawed by the base token's bound.\n          if (member.injectionToken === token) {\n            throw new Error(\n              `Tried to register injectable \"${namespacedId}\" with injection token \"${\n                token.id\n              }\", but its cardinality \"${upperBoundedCardinality}\" allows at most one registration and \"${namespacedIdByInjectableMap.get(\n                member,\n              )}\" is already registered.`,\n            );\n          }\n        }\n      }\n    }\n\n    injectableIdSet.add(namespacedId);\n    injectableSet.add(injectable);\n    namespacedIdByInjectableMap.set(injectable, namespacedId);\n    if (injectable.injectionToken?.abstract) {\n      throw new Error(\n        `Tried to register injectable \"${namespacedId}\" with injection token \"${injectable.injectionToken.id}\", but it is abstract. Use \".for(specifier)\" for a concrete token.`,\n      );\n    }\n\n    const maxCacheSize =\n      injectable.maxCacheSize ?? injectable.injectionToken?.maxCacheSize;\n\n    // LRU is only meaningful for keyed lifecycles \u2014 singletons hold one\n    // instance and would never overflow. For keyed lifecycles with a size\n    // cap, allocate eagerly so the eviction callback is wired before any\n    // store. For everything else, the map is allocated lazily on first\n    // store (singletons store the instance directly; keyedSingleton stores\n    // a CompositeMap \u2014 see privateInjectFor.js).\n    if (maxCacheSize > 0 && injectable.lifecycle.id !== 'singleton') {\n      const instanceMap = new LruCompositeMap(maxCacheSize, {\n        onEvict: (instance, keyArray) =>\n          firePurgeCallbacks(injectable, instance, keyArray),\n      });\n\n      instancesByInjectableMap.set(injectable, instanceMap);\n    }\n\n    const tokens = getRelatedTokens(injectable.injectionToken);\n\n    for (let t = 0; t < tokens.length; t++) {\n      const token = tokens[t];\n      let injectablesSet = injectablesByInjectionToken.get(token);\n\n      if (!injectablesSet) {\n        injectablesSet = new Set();\n        injectablesByInjectionToken.set(token, injectablesSet);\n      }\n\n      injectablesSet.add(injectable);\n      invalidateRelatedInjectablesCache(injectablesSet);\n    }\n  };\n};\n", "import { storedInstanceKey } from './lifecycleEnum';\nimport { isCompositeStorage } from './privateInjectFor';\n\nconst singletonKeyArray = [storedInstanceKey];\n\nconst keyArrayStartsWith = (keyArray, prefix) => {\n  if (prefix.length > keyArray.length) return false;\n  for (let i = 0; i < prefix.length; i++) {\n    if (keyArray[i] !== prefix[i]) return false;\n  }\n  return true;\n};\n\nconst evict = (instancesByInjectableMap, injectablesInScope, keyParts) => {\n  for (const injectable of injectablesInScope) {\n    const stored = instancesByInjectableMap.get(injectable);\n    if (stored === undefined) continue;\n\n    if (!isCompositeStorage(stored)) {\n      if (\n        keyParts.length === 0 ||\n        keyArrayStartsWith(singletonKeyArray, keyParts)\n      ) {\n        instancesByInjectableMap.delete(injectable);\n      }\n      continue;\n    }\n\n    if (keyParts.length === 0) {\n      stored.clear();\n    } else {\n      stored.deleteByPrefix(keyParts);\n    }\n  }\n};\n\n// Purges the stored instances of a given set of injectables. Shared by the\n// container-wide purge and the scope-restricted one, so that both fire\n// instance-purge callbacks the same way.\nexport const purgeStoredInstancesFor =\n  ({\n    instancesByInjectableMap,\n    firePurgeCallbacks,\n    anyPurgeCallbacksRegistered,\n  }) =>\n  (injectablesInScope, keyParts) => {\n    // Nothing can observe this purge, so skip gathering the snapshot and go\n    // straight to eviction \u2014 the same rule the inject wiring follows, where a\n    // container with no decorators pays for none.\n    if (!anyPurgeCallbacksRegistered()) {\n      evict(instancesByInjectableMap, injectablesInScope, keyParts);\n      return;\n    }\n\n    // Phase 1 \u2014 Gather snapshot tuples without mutating caches. The stored\n    // value is dispatched structurally: a CompositeMap-shape stores keyed\n    // entries; anything else is a directly-stored instance (singleton or\n    // v2-default-no-args).\n    const tuples = [];\n\n    for (const injectable of injectablesInScope) {\n      const stored = instancesByInjectableMap.get(injectable);\n      if (stored === undefined) continue;\n\n      if (!isCompositeStorage(stored)) {\n        if (\n          keyParts.length > 0 &&\n          !keyArrayStartsWith(singletonKeyArray, keyParts)\n        ) {\n          continue;\n        }\n        tuples.push({\n          injectable,\n          instance: stored,\n          keyArray: singletonKeyArray,\n        });\n        continue;\n      }\n\n      for (const [keyArray, instance] of stored.entries()) {\n        if (keyParts.length > 0 && !keyArrayStartsWith(keyArray, keyParts)) {\n          continue;\n        }\n        tuples.push({ injectable, instance, keyArray });\n      }\n    }\n\n    // Phase 2 \u2014 Fire callbacks. Caches stay populated so peer-coordination\n    // inside a callback works (`di.inject(peer)` returns the cached instance).\n    for (const { injectable, instance, keyArray } of tuples) {\n      firePurgeCallbacks(injectable, instance, keyArray);\n    }\n\n    // Phase 3 \u2014 Evict. Sweeps both the original snapshot entries and anything\n    // re-populated by phase 2 callbacks. Callbacks do NOT re-fire here.\n    evict(instancesByInjectableMap, injectablesInScope, keyParts);\n  };\n\nexport const purgeInstancesFor = ({\n  getRelatedInjectables,\n  instancesByInjectableMap,\n  firePurgeCallbacks,\n  anyPurgeCallbacksRegistered,\n}) => {\n  const purgeStoredInstances = purgeStoredInstancesFor({\n    instancesByInjectableMap,\n    firePurgeCallbacks,\n    anyPurgeCallbacksRegistered,\n  });\n\n  return (alias, ...keyParts) =>\n    purgeStoredInstances(\n      alias === undefined\n        ? [...instancesByInjectableMap.keys()]\n        : getRelatedInjectables(alias),\n      keyParts,\n    );\n};\n", "import {\n  deregistrationCallbackToken,\n  deregistrationDecoratorToken,\n  injectionDecoratorToken,\n  preInjectCallbackToken,\n} from './tokens';\nimport toFlatInjectables from './toFlatInjectables';\nimport isInjectionToken from '../getInjectionToken/isInjectionToken';\nimport { getRelatedTokens, isRelatedToToken } from './getRelatedTokens';\nimport { invalidateRelatedInjectablesCache } from './getRelatedInjectablesFor';\nimport flow from './fastFlow';\n\nexport const deregisterFor =\n  ({\n    injectMany,\n    getApplicableDecorators,\n    injectableSet,\n    injectableAndRegistrationContext,\n    injectablesByInjectionToken,\n    overridingInjectables,\n    purgeInstances,\n    injectableIdSet,\n    namespacedIdByInjectableMap,\n    childrenByParentMap,\n    // Todo: get rid of function usage.\n    getDi,\n    decoratorCache,\n    syncInjectWiring,\n  }) =>\n  ({ injectables, context, source }) => {\n    // Collect callbacks first (while all injectables are still registered)\n    const callbacks = injectMany({\n      alias: deregistrationCallbackToken,\n      instantiationParameters: [],\n      injectingInjectable: source,\n    });\n\n    const flatInjectables = toFlatInjectables(injectables);\n\n    // Fire callbacks for all injectables being deregistered (original batch semantics)\n    flatInjectables.forEach(injectable => {\n      callbacks.forEach(callback => {\n        callback(injectable);\n      });\n    });\n\n    const di = getDi();\n\n    const deregisterSingle = deregisterSingleFor({\n      injectableSet,\n      injectableAndRegistrationContext,\n      injectablesByInjectionToken,\n      overridingInjectables,\n      purgeInstances,\n      injectableIdSet,\n      namespacedIdByInjectableMap,\n      childrenByParentMap,\n      di,\n    });\n\n    let injectWiringChanged = false;\n\n    flatInjectables.forEach(injectable => {\n      if (\n        isRelatedToToken(injectable.injectionToken, injectionDecoratorToken)\n      ) {\n        decoratorCache.injection = null;\n        injectWiringChanged = true;\n      }\n\n      if (isRelatedToToken(injectable.injectionToken, preInjectCallbackToken)) {\n        decoratorCache.preInject = null;\n        injectWiringChanged = true;\n      }\n\n      const decorators = getApplicableDecorators({\n        decoratorToken: deregistrationDecoratorToken,\n        target: injectable,\n        injectingInjectable: source,\n      });\n\n      if (decorators.length === 0) {\n        deregisterSingle(injectable);\n        return;\n      }\n\n      const decoratedDeregister = flow(...decorators)(deregisterSingle);\n\n      decoratedDeregister(injectable);\n    });\n\n    // Recomputed from the registration index after the removals, so a\n    // deregistration decorator that prevented the removal is handled too.\n    if (injectWiringChanged) {\n      syncInjectWiring();\n    }\n  };\n\nexport const deregisterSingleFor =\n  ({\n    injectableSet,\n    injectableAndRegistrationContext,\n    injectablesByInjectionToken,\n    overridingInjectables,\n    purgeInstances,\n    injectableIdSet,\n    namespacedIdByInjectableMap,\n    childrenByParentMap,\n    di,\n  }) =>\n  injectable => {\n    if (isInjectionToken(injectable)) {\n      throw new Error(\n        `Tried to deregister using injection token \"${injectable.id}\", but deregistration using token is illegal.`,\n      );\n    }\n\n    if (!injectableSet.has(injectable)) {\n      throw new Error(\n        `Tried to deregister non-registered injectable \"${injectable.id}\".`,\n      );\n    }\n\n    // Cascade deregister children using the reverse index (O(1) lookup).\n    const children = childrenByParentMap.get(injectable);\n\n    if (children) {\n      children.forEach(child => {\n        injectableAndRegistrationContext.delete(child);\n\n        if (injectableSet.has(child)) {\n          di.deregister({\n            injectables: [child],\n          });\n        }\n      });\n\n      childrenByParentMap.delete(injectable);\n    }\n\n    purgeInstances(injectable);\n    injectableAndRegistrationContext.delete(injectable);\n    const namespacedId = namespacedIdByInjectableMap.get(injectable);\n    injectableIdSet.delete(namespacedId);\n    injectableSet.delete(injectable);\n    namespacedIdByInjectableMap.delete(injectable);\n\n    const tokens = getRelatedTokens(injectable.injectionToken);\n\n    tokens.forEach(token => {\n      const tokenSet = injectablesByInjectionToken.get(token);\n      tokenSet.delete(injectable);\n      invalidateRelatedInjectablesCache(tokenSet);\n    });\n\n    overridingInjectables.delete(injectable);\n  };\n", "export const overrideFor =\n  ({ getRelatedInjectables, earlyOverride }) =>\n  (alias, instantiateStub) => {\n    const relatedInjectables = getRelatedInjectables(alias);\n\n    if (relatedInjectables.length === 0) {\n      if (alias.aliasType === 'injection-token') {\n        throw new Error(\n          `Tried to override single implementation of injection token \"${alias.id}\", but found no registered implementations.`,\n        );\n      }\n\n      throw new Error(\n        `Tried to override \"${alias.id}\" which is not registered.`,\n      );\n    }\n\n    earlyOverride(alias, instantiateStub);\n  };\n\nexport const unoverrideFor =\n  ({ overridingInjectables, getRelatedInjectables, getNamespacedId }) =>\n  alias => {\n    const [injectable] = getRelatedInjectables(alias);\n\n    if (!injectable) {\n      throw new Error(\n        `Tried to unoverride \"${alias.id}\", but it was not registered.`,\n      );\n    }\n\n    if (!overridingInjectables.has(injectable)) {\n      throw new Error(\n        `Tried to unoverride \"${getNamespacedId(\n          injectable,\n        )}\", but it was not overridden.`,\n      );\n    }\n\n    overridingInjectables.delete(injectable);\n  };\n", "export const checkForNoMatchesFor =\n  ({ getNamespacedId }) =>\n  (relatedInjectables, alias, injectingInjectable) => {\n    if (relatedInjectables.length === 0) {\n      throw new Error(\n        `Tried to inject non-registered injectable \"${\n          alias.id\n        }\" from \"${getNamespacedId(injectingInjectable)}\".`,\n      );\n    }\n  };\n", "export const checkForTooManyMatchesFor =\n  ({ getNamespacedId }) =>\n  (relatedInjectables, alias, injectingInjectable) => {\n    if (relatedInjectables.length > 1) {\n      throw new Error(\n        `Tried to inject single injectable for injection token \"${\n          alias.id\n        }\" from \"${getNamespacedId(\n          injectingInjectable,\n        )}\" but found multiple injectables: \"${relatedInjectables\n          .map(getNamespacedId)\n          .join('\", \"')}\"`,\n      );\n    }\n  };\n", "export const checkForSideEffectsFor =\n  ({ getSideEffectsArePrevented, getNamespacedId }) =>\n  (injectable, injectingInjectable) => {\n    if (getSideEffectsArePrevented(injectable)) {\n      throw new Error(\n        `Tried to inject \"${getNamespacedId(\n          injectable,\n        )}\" from \"${getNamespacedId(\n          injectingInjectable,\n        )}\" when side-effects are prevented.`,\n      );\n    }\n  };\n", "export const checkForAbstractTokenFor =\n  ({ getNamespacedId }) =>\n  (alias, injectingInjectable) => {\n    if (alias.abstract) {\n      throw new Error(\n        `Tried to inject injection token \"${alias.id}\" from \"${getNamespacedId(\n          injectingInjectable,\n        )}\", but it is abstract. Use \".for(specifier)\" for a concrete token.`,\n      );\n    }\n  };\n", "export const checkForNonMaybeCardinalityFor =\n  ({ getNamespacedId }) =>\n  (alias, injectingInjectable) => {\n    if (alias.cardinality !== 'zero-or-one') {\n      throw new Error(\n        `Tried to injectMaybe \"${alias.id}\" from \"${getNamespacedId(\n          injectingInjectable,\n        )}\", but its cardinality is \"${\n          alias.cardinality\n        }\" instead of \"zero-or-one\".`,\n      );\n    }\n  };\n", "import isInjectable from '../getInjectable/isInjectable';\nimport { injectableSymbol2 } from '../getInjectable2/getInjectable2';\n\n// Declared sets are derived once per injectable: a `consumptions` array is\n// fixed at creation, and injectable identity outlives any single container.\nconst declaredSetsByInjectable = new WeakMap();\n\nconst getDeclaredSet = injectable => {\n  let declared = declaredSetsByInjectable.get(injectable);\n\n  if (!declared) {\n    declared = new Set(injectable.consumptions ?? []);\n    declaredSetsByInjectable.set(injectable, declared);\n  }\n\n  return declared;\n};\n\nexport const checkForUndeclaredConsumptionFor =\n  ({ getNamespacedId }) =>\n  ({ alias, injectingInjectable }) => {\n    // Only injectable2 declares consumptions. Everything else is exempt by\n    // this one check: the container root, v1 injectables, and the token that\n    // stands in as the injecting party for injectMany's element injects.\n    if (injectingInjectable.aliasType !== injectableSymbol2) {\n      return;\n    }\n\n    // Injecting an injectable by reference already implies a dependency on\n    // whatever package it lives in, so only tokens are declared.\n    if (isInjectable(alias)) {\n      return;\n    }\n\n    const declared = getDeclaredSet(injectingInjectable);\n\n    // Declaring a general token covers every `.for()` derivative of it, which\n    // is what makes runtime specifiers declarable at all. The walk is upwards\n    // only: declaring a specific token does not cover its general token.\n    let candidate = alias;\n\n    while (candidate !== undefined) {\n      if (declared.has(candidate)) {\n        return;\n      }\n\n      candidate = candidate.specificTokenOf;\n    }\n\n    throw new Error(\n      `Tried to inject \"${alias.id}\" from \"${getNamespacedId(\n        injectingInjectable,\n      )}\", but it is not a declared consumption.`,\n    );\n  };\n", "import { injectableSymbol2 } from '../getInjectable2/getInjectable2';\n\nconst isToken2 = alias => alias.aliasType === 'injection-token2';\n\n// Read-only: reads the registration state directly and holds nothing of its\n// own, so registering after validating works and validating again reflects it.\nexport const validateFor =\n  ({\n    containerId,\n    injectableSet,\n    injectablesByInjectionToken,\n    namespacedIdByInjectableMap,\n    overridingInjectables,\n  }) =>\n  () => {\n    const verifiedIds = [];\n    const unverifiedIds = [];\n    const unverifiableConsumptions = [];\n    const violations = [];\n\n    for (const injectable of injectableSet) {\n      const namespacedId = namespacedIdByInjectableMap.get(injectable);\n\n      // Only injectable2 declares consumptions; v1 injectables are beyond\n      // what this can check.\n      if (injectable.aliasType !== injectableSymbol2) {\n        unverifiedIds.push(namespacedId);\n        continue;\n      }\n\n      verifiedIds.push(namespacedId);\n\n      // An overridden injectable's own instantiate never runs, so its\n      // declarations say nothing about what this container needs.\n      if (overridingInjectables.has(injectable)) {\n        continue;\n      }\n\n      for (const consumption of injectable.consumptions ?? []) {\n        if (!isToken2(consumption)) {\n          // A v1 token carries no cardinality, so there is no arity to check.\n          unverifiableConsumptions.push({\n            injectableId: namespacedId,\n            consumptionId: consumption.id,\n          });\n\n          continue;\n        }\n\n        const { cardinality } = consumption;\n\n        if (cardinality !== 'one' && cardinality !== 'one-or-many') {\n          continue;\n        }\n\n        // The index holds every registration made against the token or any of\n        // its `.for()` derivatives, which is how a general-token declaration\n        // is satisfied by an implementation of one of its specific tokens.\n        const registered = injectablesByInjectionToken.get(consumption);\n\n        // Only the lower bound is checked here: the upper bound cannot be\n        // exceeded, since registering rejects the second implementation.\n        if (registered === undefined || registered.size === 0) {\n          violations.push(\n            `Injectable \"${namespacedId}\" consumes injection token \"${consumption.id}\" with cardinality \"${cardinality}\", but it has no registrations.`,\n          );\n        }\n      }\n    }\n\n    if (violations.length > 0) {\n      throw new Error(\n        `Tried to validate container \"${containerId}\", but found violations:\\n${violations\n          .map(violation => ` - ${violation}`)\n          .join('\\n')}`,\n      );\n    }\n\n    const sorted = ids => [...ids].sort();\n\n    return {\n      verifiedInjectables: {\n        count: verifiedIds.length,\n        ids: sorted(verifiedIds),\n      },\n\n      unverifiedInjectables: {\n        count: unverifiedIds.length,\n        ids: sorted(unverifiedIds),\n      },\n\n      unverifiableConsumptions,\n    };\n  };\n", "import isInjectionToken from '../getInjectionToken/isInjectionToken';\nimport { injectableSymbol2 } from '../getInjectable2/getInjectable2';\nimport { injectionTokenSymbol2 } from '../getInjectionToken2/getInjectionToken2';\n\nconst targetIsV2 = injectable =>\n  injectable.aliasType === injectableSymbol2 ||\n  injectable.aliasType === injectionTokenSymbol2;\n\n// v1-shape stub: (di, ...params) => instance. Wraps for v2 targets.\nconst asV1Shape = (stub, isV2Target) =>\n  isV2Target\n    ? di =>\n        (...params) =>\n          stub(di, ...params)\n    : stub;\n\n// v2-shape stub: (di) => (...params) => instance. Unwraps for v1 targets.\nconst asV2Shape = (stub, isV2Target) =>\n  isV2Target ? stub : (di, ...params) => stub(di)(...params);\n\nconst earlyOverrideImplFor =\n  normalize =>\n  ({\n    getRelatedInjectables,\n    alreadyInjected,\n    overridingInjectables,\n    getNamespacedId,\n  }) =>\n  (alias, instantiateStub) => {\n    const relatedInjectables = getRelatedInjectables(alias);\n\n    if (relatedInjectables.length > 1) {\n      throw new Error(\n        `Tried to override single implementation of injection token \"${\n          alias.id\n        }\", but found multiple registered implementations: \"${relatedInjectables\n          .map(getNamespacedId)\n          .join('\", \"')}\".`,\n      );\n    }\n\n    if (relatedInjectables.length === 0 && isInjectionToken(alias)) {\n      throw new Error(\n        `Tried to early-override an injection token \"${alias.id}\", but that is currently not supported.`,\n      );\n    }\n\n    const originalInjectable = relatedInjectables[0] || alias;\n\n    if (alreadyInjected.has(alias) || alreadyInjected.has(originalInjectable)) {\n      throw new Error(\n        `Tried to override injectable \"${getNamespacedId(\n          originalInjectable,\n        )}\", but it was already injected.`,\n      );\n    }\n\n    overridingInjectables.set(originalInjectable, {\n      ...originalInjectable,\n      overriddenInjectable: originalInjectable,\n      causesSideEffects: false,\n      instantiate: normalize(instantiateStub, targetIsV2(originalInjectable)),\n    });\n  };\n\nexport const earlyOverrideFor = earlyOverrideImplFor(asV1Shape);\nexport const earlyOverride2For = earlyOverrideImplFor(asV2Shape);\n", "import { preInjectCallbackToken } from './tokens';\n\n// Non-wrapping entry hook: fires every pre-inject callback applicable to the\n// alias, then calls through. Fires before any resolution or failure check,\n// so a callback can register implementations that the same operation then\n// observes. `kind` is baked in at wrap time: 'inject' for the inject\n// variants, 'injectMany' for the injectMany variants (withMeta variants\n// report their base kind). The third argument is the injecting party: the\n// injectable whose instantiate made the call, or the container root for\n// injects made directly on `di`.\nexport const withPreInjectCallbacksFor =\n  ({ decoratorCache, getApplicableDecorators }) =>\n  kind =>\n  toBeCalled =>\n  args => {\n    // When decoratorCache.preInject is null, a callback was registered or\n    // deregistered \u2014 invalidate all per-alias cached callback lists.\n    if (decoratorCache.preInject === null) {\n      decoratorCache.preInject = true;\n      decoratorCache.preInjectByAlias = new Map();\n    }\n\n    let callbacks = decoratorCache.preInjectByAlias.get(args.alias);\n\n    if (callbacks === undefined) {\n      const applicable = getApplicableDecorators({\n        decoratorToken: preInjectCallbackToken,\n        target: args.alias,\n        injectingInjectable: args.injectingInjectable,\n      });\n\n      callbacks = applicable.length > 0 ? applicable : null;\n\n      decoratorCache.preInjectByAlias.set(args.alias, callbacks);\n    }\n\n    if (callbacks !== null) {\n      for (const callback of callbacks) {\n        callback(args.alias, kind, args.injectingInjectable);\n      }\n    }\n\n    return toBeCalled(args);\n  };\n", "import { instancePurgeCallbackToken } from './tokens';\n\nexport const firePurgeCallbacksFor =\n  ({ getApplicableDecorators }) =>\n  (injectable, instance, keyArray) => {\n    const payload = { instance };\n\n    const callbacks = getApplicableDecorators({\n      decoratorToken: instancePurgeCallbackToken,\n      target: injectable,\n      injectingInjectable: injectable,\n    });\n\n    for (const cb of callbacks) {\n      cb(payload)(...keyArray);\n    }\n  };\n", "import { getRelatedTokens } from './getRelatedTokens';\n\n// Returns every decorator/callback instance that applies to `target` for the\n// given `decoratorToken`. Three lookup dimensions are unified:\n//\n//   1. Direct:   decoratorToken.for(target).\n//   2. Chain:    walk `specificTokenOf` ancestors of the contract token \u2014\n//                `target.injectionToken` for injectable targets,\n//                `target.specificTokenOf` for token targets \u2014 and look up\n//                `decoratorToken.for(ancestor)` for each. This is symmetric\n//                with the registration-time chain indexing in\n//                `getRelatedTokens`: a contributor registered under\n//                `someToken.for(specifier)` is already retrievable via\n//                `injectMany(someToken)`, and a decorator targeting the\n//                parent contract should fire for the child specialization.\n//   3. Tags:     for every tag of the target and of every token in its\n//                chain, look up `decoratorToken.for(tag)`. Tags are deduped\n//                across these sources: `.for()` children inherit the general\n//                token's tags, so the same tag typically occurs on every\n//                chain level. This makes a tag on a token fire everywhere\n//                `.for(token)` would.\n//\n// Injectables without an `injectionToken` skip the chain dimension.\n//\n// Fast path: if no injectable is registered under the abstract `decoratorToken`\n// itself, none of the three lookup dimensions can ever match. `register.js`\n// indexes every specific decorator by walking `getRelatedTokens(injectionToken)`,\n// which terminates at the abstract token \u2014 so the abstract set is non-empty\n// iff at least one decorator of this type is registered anywhere.\nconst EMPTY = Object.freeze([]);\n\nexport const getApplicableDecoratorsFor =\n  ({ injectMany, injectablesByInjectionToken }) =>\n  ({ decoratorToken, target, injectingInjectable }) => {\n    const registered = injectablesByInjectionToken.get(decoratorToken);\n\n    if (!registered || registered.size === 0) {\n      return EMPTY;\n    }\n\n    const out = [];\n\n    // Most dispatch keys have no registrations \u2014 checking the registration\n    // index directly skips the injectMany machinery for them. `.for()` itself\n    // is cheap on repeat calls (memoized by specifier).\n    const dispatch = alias => {\n      const registeredForAlias = injectablesByInjectionToken.get(alias);\n\n      if (registeredForAlias && registeredForAlias.size > 0) {\n        out.push(\n          ...injectMany({\n            alias,\n            instantiationParameters: [],\n            injectingInjectable,\n          }),\n        );\n      }\n    };\n\n    dispatch(decoratorToken.for(target));\n\n    const chain = getRelatedTokens(\n      target.injectionToken ?? target.specificTokenOf,\n    );\n\n    for (const t of chain) {\n      dispatch(decoratorToken.for(t));\n    }\n\n    const targetTags = target.tags;\n\n    if (targetTags) {\n      for (const tag of targetTags) {\n        dispatch(decoratorToken.for(tag));\n      }\n    }\n\n    // Dedup without allocations: `.for()` children share the general token's\n    // tags array, so a chain carries at most one distinct tags array \u2014 skip\n    // repeats by reference, and skip tags already dispatched via target.tags\n    // with indexOf (the arrays are tiny).\n    let processedChainTags = targetTags;\n\n    for (const t of chain) {\n      const chainTags = t.tags;\n\n      if (!chainTags || chainTags === processedChainTags) {\n        continue;\n      }\n\n      processedChainTags = chainTags;\n\n      for (const tag of chainTags) {\n        if (targetTags && targetTags.indexOf(tag) !== -1) {\n          continue;\n        }\n\n        dispatch(decoratorToken.for(tag));\n      }\n    }\n\n    return out;\n  };\n", "import { privateInjectFor } from './privateInjectFor';\nimport { withInjectionDecoratorsFor } from './withInjectionDecoratorsFor';\nimport { privateInjectManyFor as nonDecoratedPrivateInjectManyFor } from './privateInjectManyFor';\nimport { registerFor, registerSingleFor } from './register';\nimport { purgeInstancesFor, purgeStoredInstancesFor } from './purgeInstances';\nimport { deregisterFor } from './deregister';\nimport { overrideFor, unoverrideFor } from './override';\nimport { getNamespacedIdFor } from './getNamespacedIdFor';\nimport { checkForNoMatchesFor } from './checkForNoMatchesFor';\nimport { checkForTooManyMatchesFor } from './checkForTooManyMatches';\nimport { checkForSideEffectsFor } from './checkForSideEffectsFor';\nimport { checkForAbstractTokenFor } from './checkForAbstractTokenFor';\nimport { checkForNonMaybeCardinalityFor } from './checkForNonMaybeCardinalityFor';\nimport { checkForUndeclaredConsumptionFor } from './checkForUndeclaredConsumptionFor';\nimport { validateFor } from './validate';\nimport { getRelatedInjectablesFor } from './getRelatedInjectablesFor';\nimport { earlyOverrideFor, earlyOverride2For } from './early-override';\nimport {\n  injectionDecoratorToken,\n  instancePurgeCallbackToken,\n  preInjectCallbackToken,\n} from './tokens';\nimport { withPreInjectCallbacksFor } from './withPreInjectCallbacksFor';\nimport { isRelatedToToken } from './getRelatedTokens';\nimport { firePurgeCallbacksFor } from './firePurgeCallbacksFor';\nimport { getApplicableDecoratorsFor } from './getApplicableDecoratorsFor';\nimport { isCompositeStorage } from './privateInjectFor';\n\nexport default containerId => {\n  const injectableSet = new Set();\n\n  const decoratorCache = {\n    injection: null,\n    injectionByAlias: new Map(),\n    preInject: null,\n    preInjectByAlias: new Map(),\n  };\n  const overridingInjectables = new Map();\n  let sideEffectsArePrevented = true;\n  const alreadyInjected = new Set();\n  const injectablesWithPermittedSideEffects = new Set();\n  const injectableIdSet = new Set();\n\n  const injectableAndRegistrationContext = new Map();\n  const instancesByInjectableMap = new Map();\n  const injectablesByInjectionToken = new Map();\n  const namespacedIdByInjectableMap = new Map();\n  const childrenByParentMap = new Map();\n\n  const getNamespacedId = getNamespacedIdFor(injectableAndRegistrationContext);\n\n  const getRelatedInjectables = getRelatedInjectablesFor({\n    injectablesByInjectionToken,\n    injectableSet,\n  });\n\n  const containerRootContextItem = {\n    injectable: { id: containerId, aliasType: 'container' },\n  };\n\n  const rootInjectable = containerRootContextItem.injectable;\n\n  const checkForAbstractToken = checkForAbstractTokenFor({ getNamespacedId });\n\n  const nonDecoratedPrivateInjectManyForUnknownMeta =\n    nonDecoratedPrivateInjectManyFor({\n      getRelatedInjectables,\n      // Elements go through the element slot, not `privateDi.inject`: entry\n      // wrappers (once-per-operation hooks) must not re-fire per element,\n      // while injection decorators still apply per element.\n      getInject: () => elementInject,\n      namespacedIdByInjectableMap,\n    });\n\n  const nonDecoratedPrivateInjectMany =\n    nonDecoratedPrivateInjectManyForUnknownMeta({\n      withMeta: false,\n    });\n\n  const nonDecoratedPrivateInjectManyWithMeta =\n    nonDecoratedPrivateInjectManyForUnknownMeta({\n      withMeta: true,\n    });\n\n  const getApplicableDecorators = getApplicableDecoratorsFor({\n    injectMany: nonDecoratedPrivateInjectMany,\n    injectablesByInjectionToken,\n  });\n\n  const getSideEffectsArePrevented = injectable =>\n    sideEffectsArePrevented &&\n    injectable.causesSideEffects &&\n    !injectablesWithPermittedSideEffects.has(injectable);\n\n  const checkForSideEffects = checkForSideEffectsFor({\n    getSideEffectsArePrevented,\n    getNamespacedId,\n  });\n\n  const checkForNoMatches = checkForNoMatchesFor({\n    getNamespacedId,\n  });\n\n  const checkForTooManyMatches = checkForTooManyMatchesFor({\n    getNamespacedId,\n  });\n\n  const checkForNonMaybeCardinality = checkForNonMaybeCardinalityFor({\n    getNamespacedId,\n  });\n\n  const checkForUndeclaredConsumption = checkForUndeclaredConsumptionFor({\n    getNamespacedId,\n  });\n\n  // Enforcement wraps the slots rather than living inside the operation\n  // functions, so that the machinery \u2014 decorator and callback dispatch, purge\n  // callbacks \u2014 stays exempt: it holds the raw operations captured at\n  // construction and never reads these slots.\n  const withConsumptionEnforcement = toBeCalled => args => {\n    checkForUndeclaredConsumption(args);\n\n    return toBeCalled(args);\n  };\n\n  const nonDecoratedPrivateInjectUnknownMeta = privateInjectFor({\n    getRelatedInjectables,\n    injectableSet,\n    alreadyInjected,\n    overridingInjectables,\n    instancesByInjectableMap,\n    getDi: () => privateDi,\n    checkForNoMatches,\n    checkForTooManyMatches,\n    checkForSideEffects,\n    checkForAbstractToken,\n    checkForNonMaybeCardinality,\n    namespacedIdByInjectableMap,\n    getNamespacedId,\n    getApplicableDecorators,\n  });\n\n  const nonDecoratedPrivateInject = nonDecoratedPrivateInjectUnknownMeta({\n    withMeta: false,\n  });\n\n  const nonDecoratedPrivateInjectWithMeta =\n    nonDecoratedPrivateInjectUnknownMeta({\n      withMeta: true,\n    });\n\n  const withInjectionDecorators = withInjectionDecoratorsFor({\n    decoratorCache,\n    getApplicableDecorators,\n  });\n\n  // Injection decorators apply only on the per-injectable inject path.\n  // injectMany resolves related injectables and calls the (decorated) inject\n  // on each, so decorators still fire per element \u2014 but the token-level\n  // injectMany is never wrapped.\n  const decoratedPrivateInject = withInjectionDecorators(\n    nonDecoratedPrivateInject,\n  );\n\n  const decoratedPrivateInjectWithMeta = withInjectionDecorators(\n    nonDecoratedPrivateInjectWithMeta,\n  );\n\n  const withPreInjectCallbacks = withPreInjectCallbacksFor({\n    decoratorCache,\n    getApplicableDecorators,\n  });\n\n  const withPreInjectCallbacksForInject = withPreInjectCallbacks('inject');\n\n  const withPreInjectCallbacksForInjectMany =\n    withPreInjectCallbacks('injectMany');\n\n  const preInjectNonDecoratedInject = withPreInjectCallbacksForInject(\n    nonDecoratedPrivateInject,\n  );\n\n  const preInjectDecoratedInject = withPreInjectCallbacksForInject(\n    decoratedPrivateInject,\n  );\n\n  const preInjectNonDecoratedInjectWithMeta = withPreInjectCallbacksForInject(\n    nonDecoratedPrivateInjectWithMeta,\n  );\n\n  const preInjectDecoratedInjectWithMeta = withPreInjectCallbacksForInject(\n    decoratedPrivateInjectWithMeta,\n  );\n\n  const preInjectInjectMany = withPreInjectCallbacksForInjectMany(\n    nonDecoratedPrivateInjectMany,\n  );\n\n  const preInjectInjectManyWithMeta = withPreInjectCallbacksForInjectMany(\n    nonDecoratedPrivateInjectManyWithMeta,\n  );\n\n  // The inject used for injectMany elements: decorated per element when\n  // injection decorators exist, but never wrapped by entry-level hooks\n  // (pre-inject callbacks fire once per operation, not per element).\n  let elementInject = nonDecoratedPrivateInject;\n\n  // Wires the decorated and pre-inject-hooked variants in only while at\n  // least one matching contributor is registered, so the common bare case\n  // pays no wrapper frame at all. Every reader of the privateDi slots (and\n  // `elementInject`, via the getInject thunk) reads them at call time.\n  const syncInjectWiring = () => {\n    const registeredDecorators = injectablesByInjectionToken.get(\n      injectionDecoratorToken,\n    );\n\n    const decoratorsActive =\n      registeredDecorators !== undefined && registeredDecorators.size > 0;\n\n    const registeredPreInjectCallbacks = injectablesByInjectionToken.get(\n      preInjectCallbackToken,\n    );\n\n    const preInjectActive =\n      registeredPreInjectCallbacks !== undefined &&\n      registeredPreInjectCallbacks.size > 0;\n\n    elementInject = decoratorsActive\n      ? decoratedPrivateInject\n      : nonDecoratedPrivateInject;\n\n    privateDi.inject = preInjectActive\n      ? decoratorsActive\n        ? preInjectDecoratedInject\n        : preInjectNonDecoratedInject\n      : elementInject;\n\n    privateDi.injectWithMeta = preInjectActive\n      ? decoratorsActive\n        ? preInjectDecoratedInjectWithMeta\n        : preInjectNonDecoratedInjectWithMeta\n      : decoratorsActive\n      ? decoratedPrivateInjectWithMeta\n      : nonDecoratedPrivateInjectWithMeta;\n\n    privateDi.injectMany = preInjectActive\n      ? preInjectInjectMany\n      : nonDecoratedPrivateInjectMany;\n\n    privateDi.injectManyWithMeta = preInjectActive\n      ? preInjectInjectManyWithMeta\n      : nonDecoratedPrivateInjectManyWithMeta;\n\n    // `elementInject` is deliberately left unwrapped: enforcement is per\n    // inject operation, and an injectMany's elements were already covered by\n    // the check on the operation itself.\n    privateDi.inject = withConsumptionEnforcement(privateDi.inject);\n    privateDi.injectWithMeta = withConsumptionEnforcement(\n      privateDi.injectWithMeta,\n    );\n    privateDi.injectMany = withConsumptionEnforcement(privateDi.injectMany);\n    privateDi.injectManyWithMeta = withConsumptionEnforcement(\n      privateDi.injectManyWithMeta,\n    );\n  };\n\n  const firePurgeCallbacks = firePurgeCallbacksFor({\n    getApplicableDecorators,\n  });\n\n  const rawRegisterSingle = registerSingleFor({\n    injectableSet,\n    namespacedIdByInjectableMap,\n    instancesByInjectableMap,\n    injectablesByInjectionToken,\n    injectableIdSet,\n    injectableAndRegistrationContext,\n    childrenByParentMap,\n    firePurgeCallbacks,\n  });\n\n  const registerSingle = (injectable, context) => {\n    rawRegisterSingle(injectable, context);\n\n    let wiringChanged = false;\n\n    if (isRelatedToToken(injectable.injectionToken, injectionDecoratorToken)) {\n      decoratorCache.injection = null;\n      wiringChanged = true;\n    }\n\n    if (isRelatedToToken(injectable.injectionToken, preInjectCallbackToken)) {\n      decoratorCache.preInject = null;\n      wiringChanged = true;\n    }\n\n    if (wiringChanged) {\n      syncInjectWiring();\n    }\n  };\n\n  // Callbacks registered against a specific target also land under the\n  // abstract token, so an empty set here means no purge callback can apply.\n  const anyPurgeCallbacksRegistered = () => {\n    const registered = injectablesByInjectionToken.get(\n      instancePurgeCallbackToken,\n    );\n\n    return registered !== undefined && registered.size > 0;\n  };\n\n  const purgeInstances = purgeInstancesFor({\n    getRelatedInjectables,\n    instancesByInjectableMap,\n    firePurgeCallbacks,\n    anyPurgeCallbacksRegistered,\n  });\n\n  const purgeStoredInstances = purgeStoredInstancesFor({\n    instancesByInjectableMap,\n    firePurgeCallbacks,\n    anyPurgeCallbacksRegistered,\n  });\n\n  const deregister = deregisterFor({\n    injectMany: nonDecoratedPrivateInjectMany,\n    getApplicableDecorators,\n    injectableSet,\n    injectableAndRegistrationContext,\n    injectablesByInjectionToken,\n    overridingInjectables,\n    purgeInstances,\n    injectableIdSet,\n    namespacedIdByInjectableMap,\n    childrenByParentMap,\n    // Todo: get rid of function usage.\n    getDi: () => privateDi,\n    decoratorCache,\n    syncInjectWiring,\n  });\n\n  const privateRegister = registerFor({\n    registerSingle,\n    injectMany: nonDecoratedPrivateInjectMany,\n    getApplicableDecorators,\n  });\n\n  const earlyOverride = earlyOverrideFor({\n    getRelatedInjectables,\n    alreadyInjected,\n    overridingInjectables,\n    getNamespacedId,\n  });\n\n  const earlyOverride2 = earlyOverride2For({\n    getRelatedInjectables,\n    alreadyInjected,\n    overridingInjectables,\n    getNamespacedId,\n  });\n\n  const override = overrideFor({\n    getRelatedInjectables,\n    earlyOverride,\n  });\n\n  const override2 = overrideFor({\n    getRelatedInjectables,\n    earlyOverride: earlyOverride2,\n  });\n\n  const unoverride = unoverrideFor({\n    overridingInjectables,\n    getRelatedInjectables,\n    getNamespacedId,\n  });\n\n  const purgeAllButOverrides = () => {\n    injectableSet.clear();\n    alreadyInjected.clear();\n    injectableIdSet.clear();\n    injectableAndRegistrationContext.clear();\n    instancesByInjectableMap.clear();\n    injectablesByInjectionToken.clear();\n    namespacedIdByInjectableMap.clear();\n    childrenByParentMap.clear();\n    decoratorCache.injection = null;\n    decoratorCache.preInject = null;\n    syncInjectWiring();\n  };\n\n  // The immediate parent is the last registration context item; a missing\n  // entry or a container-level parent normalizes to rootInjectable so that\n  // scope comparisons work uniformly for root and nested scopes.\n  const getImmediateScopeOf = injectable => {\n    const context = injectableAndRegistrationContext.get(injectable);\n    const immediateParent = context?.[context.length - 1]?.injectable;\n\n    return !immediateParent || immediateParent.aliasType === 'container'\n      ? rootInjectable\n      : immediateParent;\n  };\n\n  const privateDi = {\n    // Swapped by syncInjectWiring: the decorated variants are wired\n    // in only while at least one injection decorator is registered, so the\n    // common no-decorator case pays no wrapper frame at all.\n    inject: nonDecoratedPrivateInject,\n    injectWithMeta: nonDecoratedPrivateInjectWithMeta,\n    injectMany: nonDecoratedPrivateInjectMany,\n    injectManyWithMeta: nonDecoratedPrivateInjectManyWithMeta,\n\n    injectFactory:\n      alias =>\n      (...params) =>\n        publicInject(alias, ...params),\n\n    register: privateRegister,\n    deregister,\n    override,\n    override2,\n    earlyOverride,\n    earlyOverride2,\n    unoverride,\n\n    reset: () => {\n      overridingInjectables.clear();\n    },\n\n    permitSideEffects: alias => {\n      if (alias === undefined) {\n        sideEffectsArePrevented = false;\n        return;\n      }\n\n      getRelatedInjectables(alias).forEach(injectable =>\n        injectablesWithPermittedSideEffects.add(injectable),\n      );\n    },\n\n    purge: purgeInstances,\n\n    scopedPurge: (scopeInjectable, alias, ...keyParts) => {\n      // Without an alias, the scope's own instances and those of whatever it\n      // registered directly.\n      if (alias === undefined) {\n        const children = childrenByParentMap.get(scopeInjectable);\n\n        purgeStoredInstances(\n          children === undefined\n            ? [scopeInjectable]\n            : [scopeInjectable, ...children],\n          keyParts,\n        );\n\n        return;\n      }\n\n      const injectables = getRelatedInjectables(alias);\n      const allowedChildren = childrenByParentMap.get(scopeInjectable);\n\n      for (let i = 0; i < injectables.length; i++) {\n        const injectable = injectables[i];\n\n        if (\n          injectable !== scopeInjectable &&\n          !allowedChildren?.has(injectable)\n        ) {\n          throw new Error(\n            `Tried to purge \"${namespacedIdByInjectableMap.get(\n              injectable,\n            )}\" from \"${namespacedIdByInjectableMap.get(\n              scopeInjectable,\n            )}\", but it is not within its registration context tree.`,\n          );\n        }\n      }\n\n      purgeStoredInstances(injectables, keyParts);\n    },\n\n    purgeAllButOverrides,\n    hasRegistrations: alias => !!getRelatedInjectables(alias).length,\n    getNumberOfRegistrations: alias => getRelatedInjectables(alias).length,\n\n    registeredInScopeOf: (scopeInjectable, alias) =>\n      getRelatedInjectables(alias).some(\n        injectable => getImmediateScopeOf(injectable) === scopeInjectable,\n      ),\n\n    registeredInSubtreeOf: (scopeInjectable, alias) =>\n      getRelatedInjectables(alias).some(injectable => {\n        let scope = getImmediateScopeOf(injectable);\n\n        while (scope !== scopeInjectable && scope !== rootInjectable) {\n          scope = getImmediateScopeOf(scope);\n        }\n\n        return scope === scopeInjectable;\n      }),\n\n    getNumberOfInstances: () => {\n      const result = {};\n      for (const [injectable, stored] of instancesByInjectableMap) {\n        const namespacedId = namespacedIdByInjectableMap.get(injectable);\n        if (!namespacedId) continue;\n\n        let count = 0;\n        if (isCompositeStorage(stored)) {\n          for (const _ of stored.values()) count++;\n        } else {\n          count = 1;\n        }\n        if (count > 0) result[namespacedId] = count;\n      }\n      return result;\n    },\n  };\n\n  // The slots start out holding the bare operations; wire them once up-front\n  // so enforcement applies even in a container where nothing is registered.\n  syncInjectWiring();\n\n  const publicInject = (alias, ...args) =>\n    privateDi.inject({\n      alias,\n      instantiationParameters: args,\n      injectingInjectable: rootInjectable,\n    });\n\n  const publicInjectMany = (alias, ...args) =>\n    privateDi.injectMany({\n      alias,\n      instantiationParameters: args,\n      injectingInjectable: rootInjectable,\n    });\n\n  const publicInjectWithMeta = (alias, ...args) =>\n    privateDi.injectWithMeta({\n      alias,\n      instantiationParameters: args,\n      injectingInjectable: rootInjectable,\n    });\n\n  const publicInjectManyWithMeta = (alias, ...args) =>\n    privateDi.injectManyWithMeta({\n      alias,\n      instantiationParameters: args,\n      injectingInjectable: rootInjectable,\n    });\n\n  const publicDi = {\n    ...privateDi,\n\n    inject: publicInject,\n    injectWithMeta: publicInjectWithMeta,\n    injectMany: publicInjectMany,\n    injectManyWithMeta: publicInjectManyWithMeta,\n\n    inject2:\n      alias =>\n      (...params) =>\n        publicInject(alias, ...params),\n\n    injectMany2:\n      alias =>\n      (...params) =>\n        publicInjectMany(alias, ...params),\n\n    // Resolves per call like injectMany, but unwraps to the single instance or\n    // undefined \u2014 the 'zero-or-one' upper bound guarantees at most one.\n    injectMaybe2: alias => {\n      checkForNonMaybeCardinality(alias, rootInjectable);\n\n      return (...params) => publicInjectMany(alias, ...params)[0];\n    },\n\n    injectWithMeta2:\n      alias =>\n      (...params) =>\n        publicInjectWithMeta(alias, ...params),\n\n    injectManyWithMeta2:\n      alias =>\n      (...params) =>\n        publicInjectManyWithMeta(alias, ...params),\n\n    // injectMaybe2 over the with-meta plane: unwraps to the single\n    // meta-wrapped instance or undefined.\n    injectMaybeWithMeta2: alias => {\n      checkForNonMaybeCardinality(alias, rootInjectable);\n\n      return (...params) => publicInjectManyWithMeta(alias, ...params)[0];\n    },\n\n    register: (...injectables) => {\n      privateDi.register({\n        injectables,\n        context: [containerRootContextItem],\n        source: rootInjectable,\n      });\n    },\n\n    deregister: (...injectables) => {\n      privateDi.deregister({\n        injectables,\n        context: [containerRootContextItem],\n        source: rootInjectable,\n      });\n    },\n\n    registeredInLocalScope: alias =>\n      privateDi.registeredInScopeOf(rootInjectable, alias),\n\n    validate: validateFor({\n      containerId,\n      injectableSet,\n      injectablesByInjectionToken,\n      namespacedIdByInjectableMap,\n      overridingInjectables,\n    }),\n\n    registeredInLocalScopeSubtree: alias =>\n      privateDi.registeredInSubtreeOf(rootInjectable, alias),\n  };\n\n  return publicDi;\n};\n", "import { identity, constant } from 'lodash/fp';\n\nexport const getTypedSpecifier = constant(identity);\n"],
  "mappings": "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",
  "names": ["instantiate", "childMap", "deleted", "minimalDi", "newInstance", "callbacks", "EMPTY"]
}
