@tstdl/base 0.85.13 → 0.86.0-beta1

package/container/container.js

@@ -1,443 +1,428 @@
-"use strict";
-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);
-var container_exports = {};
-__export(container_exports, {
-  Container: () => Container,
-  container: () => container,
-  injectMetadataSymbol: () => injectMetadataSymbol
-});
-module.exports = __toCommonJS(container_exports);
-var import_circular_buffer = require("../data-structures/circular-buffer.js");
-var import_multi_key_map = require("../data-structures/multi-key-map.js");
-var import_reflection = require("../reflection/index.js");
-var import_map = require("../utils/async-iterable-helpers/map.js");
-var import_to_array = require("../utils/async-iterable-helpers/to-array.js");
-var import_forward_ref = require("../utils/object/forward-ref.js");
-var import_object = require("../utils/object/object.js");
-var import_type_guards = require("../utils/type-guards.js");
-var import_rxjs = require("rxjs");
-var import_interfaces = require("./interfaces.js");
-var import_provider = require("./provider.js");
-var import_resolve_chain = require("./resolve-chain.js");
-var import_resolve_error = require("./resolve.error.js");
-var import_token = require("./token.js");
-var import_utils = require("./utils.js");
-const injectMetadataSymbol = Symbol("Inject metadata");
-class Container {
-  registrationMap;
-  registrationSubject;
-  /** emits on new registration */
-  registration$;
-  /** all registrations */
-  get registrations() {
-    return this.registrationMap.values();
-  }
-  constructor() {
-    this.registrationMap = /* @__PURE__ */ new Map();
-    this.registrationSubject = new import_rxjs.Subject();
-    this.registration$ = this.registrationSubject.asObservable();
-  }
-  /**
-   * register a provider for a token
-   * @param token token to register
-   * @param provider provider used to resolve the token
-   * @param options registration options
-   */
-  register(token, provider, options = {}) {
-    if ((0, import_provider.isClassProvider)(provider) && !(0, import_utils.isStubClass)(provider.useClass)) {
-      const injectable = import_reflection.reflectionRegistry.getMetadata(provider.useClass)?.data.has(injectMetadataSymbol) ?? false;
-      if (!injectable) {
-        throw new Error(`${provider.useClass.name} is not injectable.`);
-      }
-    }
-    const registration = {
-      token,
-      provider,
-      options,
-      instances: /* @__PURE__ */ new Map()
-    };
-    this.registrationMap.set(token, registration);
-    this.registrationSubject.next(registration);
-  }
-  /**
-   * register a provider for a token as a singleton. Alias for {@link register} with `singleton` lifecycle
-   * @param token token to register
-   * @param provider provider used to resolve the token
-   * @param options registration options
-   */
-  registerSingleton(token, provider, options) {
-    this.register(token, provider, { ...options, lifecycle: "singleton" });
-  }
-  /**
-   * check if token has a registered provider
-   * @param token token check
-   */
-  hasRegistration(token) {
-    return this.registrationMap.has(token);
-  }
-  /**
-   * get registration
-   * @param token token to get registration for
-   */
-  getRegistration(token) {
-    const registration = this.registrationMap.get(token);
-    if ((0, import_type_guards.isUndefined)(registration)) {
-      const tokenName = (0, import_token.getTokenName)(token);
-      throw new Error(`No provider for ${tokenName} registered.`);
-    }
-    return registration;
-  }
-  /**
-   * try to get registration
-   * @param token token to get registration for
-   */
-  tryGetRegistration(token) {
-    return this.registrationMap.get(token);
-  }
-  /**
-   * resolve a token
-   * @param token token to resolve
-   * @param argument argument used for resolving (overrides token and default arguments)
-   * @returns
-   */
-  resolve(token, argument, instances) {
-    const context = {
-      isAsync: false,
-      resolves: 0,
-      forwardRefQueue: new import_circular_buffer.CircularBuffer(),
-      resolutions: [],
-      forwardRefs: /* @__PURE__ */ new Set(),
-      providedInstances: new Map(instances),
-      instances: new import_multi_key_map.MultiKeyMap(),
-      resolving: new import_multi_key_map.MultiKeyMap()
-    };
-    return this._resolve(token, false, argument, context, import_resolve_chain.ResolveChain.startWith(token), true);
-  }
-  /**
-   * resolve a token
-   * @param token token to resolve
-   * @param argument argument used for resolving (overrides token and default arguments)
-   * @returns
-   */
-  async resolveAsync(token, argument, instances) {
-    const context = {
-      isAsync: true,
-      resolves: 0,
-      forwardRefQueue: new import_circular_buffer.CircularBuffer(),
-      resolutions: [],
-      forwardRefs: /* @__PURE__ */ new Set(),
-      providedInstances: new Map(instances),
-      instances: new import_multi_key_map.MultiKeyMap(),
-      resolving: new import_multi_key_map.MultiKeyMap()
-    };
-    return this._resolveAsync(token, false, argument, context, import_resolve_chain.ResolveChain.startWith(token), true);
-  }
-  // eslint-disable-next-line max-statements, max-lines-per-function, complexity
-  _resolve(token, optional, _argument, context, chain, isFirst) {
-    if (chain.length > 750 || ++context.resolves > 750) {
-      throw new import_resolve_error.ResolveError("Resolve stack overflow. This can happen on circular dependencies with transient lifecycles and self reference. Use scoped or singleton lifecycle instead or @forwardRef().", chain);
-    }
-    if ((0, import_type_guards.isUndefined)(token)) {
-      throw new import_resolve_error.ResolveError("Token is undefined - this might be because of circular dependencies, use alias or forwardRef in this case.", chain);
-    }
-    if (context.providedInstances.has(token)) {
-      return context.providedInstances.get(token);
-    }
-    const registration = this.tryGetRegistration(token);
-    if ((0, import_type_guards.isUndefined)(registration)) {
-      if (optional == true) {
-        return void 0;
-      }
-      throw new import_resolve_error.ResolveError(`No provider for ${(0, import_token.getTokenName)(token)} registered.`, chain);
-    }
-    const resolveArgument = _argument ?? registration.options.defaultArgument ?? registration.options.defaultArgumentProvider?.(this.getResolveContext(context, chain));
-    if ((0, import_type_guards.isPromise)(resolveArgument)) {
-      throw new import_resolve_error.ResolveError(`Cannot evaluate async argument provider for token ${(0, import_token.getTokenName)(token)} in synchronous resolve, use resolveAsync instead.`, chain);
-    }
-    const argumentIdentity = (0, import_type_guards.isDefined)(registration.options.argumentIdentityProvider) && (registration.options.lifecycle == "resolution" || registration.options.lifecycle == "singleton") ? registration.options.argumentIdentityProvider(resolveArgument) : resolveArgument;
-    if ((0, import_type_guards.isPromise)(argumentIdentity)) {
-      throw new import_resolve_error.ResolveError(`Cannot evaluate async argument identity provider for token ${(0, import_token.getTokenName)(token)} in synchronous resolve, use resolveAsync instead.`, chain);
-    }
-    if (registration.options.lifecycle == "resolution" && context.instances.has([token, argumentIdentity])) {
-      return context.instances.get([token, argumentIdentity]);
-    }
-    if (registration.options.lifecycle == "singleton" && registration.instances.has(argumentIdentity)) {
-      return registration.instances.get(argumentIdentity);
-    }
-    if (context.resolving.has([token, argumentIdentity])) {
-      throw new import_resolve_error.ResolveError("Circular dependency to itself detected. Please check your registrations and providers. @forwardRef might be a solution.", chain);
-    }
-    context.resolving.set([token, argumentIdentity], true);
-    let instance;
-    if ((0, import_provider.isClassProvider)(registration.provider)) {
-      const typeMetadata = import_reflection.reflectionRegistry.getMetadata(registration.provider.useClass);
-      if ((0, import_type_guards.isUndefined)(typeMetadata) || !typeMetadata.data.has(injectMetadataSymbol)) {
-        throw new import_resolve_error.ResolveError(`${registration.provider.useClass.name} is not injectable.`, chain);
-      }
-      if ((0, import_utils.isStubClass)(typeMetadata.constructor)) {
-        throw new import_resolve_error.ResolveError(`No provider for ${(0, import_token.getTokenName)(token)} registered.`, chain);
-      }
-      const parameters = (typeMetadata.parameters ?? []).map((metadata) => this.resolveInjection(token, context, typeMetadata, metadata, resolveArgument, chain));
-      instance = new typeMetadata.constructor(...parameters);
-      for (const [property, metadata] of typeMetadata.properties) {
-        if (!metadata.data.has(injectMetadataSymbol)) {
-          continue;
-        }
-        instance[property] = this.resolveInjection(token, context, typeMetadata, metadata, resolveArgument, chain);
-      }
-    }
-    if ((0, import_provider.isValueProvider)(registration.provider)) {
-      instance = registration.provider.useValue;
-    }
-    if ((0, import_provider.isTokenProvider)(registration.provider)) {
-      const arg = resolveArgument ?? registration.provider.argument ?? registration.provider.argumentProvider?.();
-      const innerToken = registration.provider.useToken ?? registration.provider.useTokenProvider();
-      if ((0, import_type_guards.isPromise)(arg)) {
-        throw new import_resolve_error.ResolveError(`Cannot evaluate async argument provider for token ${(0, import_token.getTokenName)(token)} in synchronous resolve, use resolveAsync instead.`, chain);
-      }
-      if ((0, import_type_guards.isPromise)(innerToken)) {
-        throw new import_resolve_error.ResolveError(`Cannot evaluate async token provider for token ${(0, import_token.getTokenName)(token)} in synchronous resolve, use resolveAsync instead.`, chain);
-      }
-      instance = this._resolve(innerToken, false, arg, context, chain.addToken(innerToken), false);
-    }
-    if ((0, import_provider.isFactoryProvider)(registration.provider)) {
-      try {
-        const result = registration.provider.useFactory(resolveArgument, this.getResolveContext(context, chain));
-        if ((0, import_type_guards.isPromise)(result)) {
-          throw new import_resolve_error.ResolveError(`Cannot evaluate async factory provider for token ${(0, import_token.getTokenName)(token)} in synchronous resolve, use resolveAsync instead.`, chain);
-        }
-        instance = result;
-      } catch (error) {
-        throw new import_resolve_error.ResolveError("Error in factory.", chain, error);
-      }
-    }
-    if (registration.options.lifecycle == "resolution") {
-      context.instances.set([token, argumentIdentity], instance);
-    }
-    if (registration.options.lifecycle == "singleton") {
-      registration.instances.set(argumentIdentity, instance);
-    }
-    context.resolutions.push({ instance, registration });
-    context.resolving.delete([token, argumentIdentity]);
-    if (isFirst) {
-      for (const fn of context.forwardRefQueue.consume()) {
-        fn();
-      }
-      derefForwardRefs(context);
-      for (let i = context.resolutions.length - 1; i >= 0; i--) {
-        const resolution = context.resolutions[i];
-        if ((0, import_type_guards.isFunction)(resolution.instance?.[import_interfaces.afterResolve])) {
-          const returnValue = resolution.instance[import_interfaces.afterResolve]();
-          if ((0, import_type_guards.isPromise)(returnValue)) {
-            throw new import_resolve_error.ResolveError(`Cannot execute async [afterResolve] for token ${(0, import_token.getTokenName)(token)} in synchronous resolve, use resolveAsync instead.`, chain);
-          }
-        }
-        if ((0, import_type_guards.isDefined)(resolution.registration.options.initializer)) {
-          const returnValue = resolution.registration.options.initializer(resolution.instance);
-          if ((0, import_type_guards.isPromise)(returnValue)) {
-            throw new import_resolve_error.ResolveError(`Cannot execute async initializer for token ${(0, import_token.getTokenName)(token)} in synchronous resolve, use resolveAsync instead.`, chain);
-          }
-        }
-      }
-    }
-    return instance;
-  }
-  // eslint-disable-next-line max-statements, max-lines-per-function, complexity
-  async _resolveAsync(token, optional, _argument, context, chain, isFirst) {
-    if (chain.length > 750 || ++context.resolves > 750) {
-      throw new import_resolve_error.ResolveError("Resolve stack overflow. This can happen on circular dependencies with transient lifecycles and self reference. Use scoped or singleton lifecycle instead or @forwardRef().", chain);
-    }
-    if ((0, import_type_guards.isUndefined)(token)) {
-      throw new import_resolve_error.ResolveError("Token is undefined - this might be because of circular dependencies, use alias or forwardRef in this case.", chain);
-    }
-    if (context.providedInstances.has(token)) {
-      return context.providedInstances.get(token);
-    }
-    const registration = this.tryGetRegistration(token);
-    if ((0, import_type_guards.isUndefined)(registration)) {
-      if (optional == true) {
-        return void 0;
-      }
-      throw new import_resolve_error.ResolveError(`No provider for ${(0, import_token.getTokenName)(token)} registered.`, chain);
-    }
-    const resolveArgument = _argument ?? registration.options.defaultArgument ?? await registration.options.defaultArgumentProvider?.(this.getResolveContext(context, chain));
-    const argumentIdentity = (0, import_type_guards.isDefined)(registration.options.argumentIdentityProvider) && (registration.options.lifecycle == "resolution" || registration.options.lifecycle == "singleton") ? await registration.options.argumentIdentityProvider(resolveArgument) : resolveArgument;
-    if (registration.options.lifecycle == "resolution" && context.instances.has([token, argumentIdentity])) {
-      return context.instances.get([token, argumentIdentity]);
-    }
-    if (registration.options.lifecycle == "singleton" && registration.instances.has(argumentIdentity)) {
-      return registration.instances.get(argumentIdentity);
-    }
-    if (context.resolving.has([token, argumentIdentity])) {
-      throw new import_resolve_error.ResolveError("Circular dependency to itself detected. Please check your registrations and providers. @forwardRef might be a solution.", chain);
-    }
-    context.resolving.set([token, argumentIdentity], true);
-    let instance;
-    if ((0, import_provider.isClassProvider)(registration.provider)) {
-      const typeMetadata = import_reflection.reflectionRegistry.getMetadata(registration.provider.useClass);
-      if ((0, import_type_guards.isUndefined)(typeMetadata) || !typeMetadata.data.has(injectMetadataSymbol)) {
-        throw new import_resolve_error.ResolveError(`${registration.provider.useClass.name} is not injectable.`, chain);
-      }
-      if ((0, import_utils.isStubClass)(typeMetadata.constructor)) {
-        throw new import_resolve_error.ResolveError(`No provider for ${(0, import_token.getTokenName)(token)} registered.`, chain);
-      }
-      const boxedParameters = await (0, import_to_array.toArrayAsync)((0, import_map.mapAsync)(typeMetadata.parameters ?? [], async (metadata) => this.resolveInjectionAsync(context, typeMetadata, metadata, resolveArgument, chain)));
-      const parameters = boxedParameters.map((box) => box.resolved);
-      instance = new typeMetadata.constructor(...parameters);
-      for (const [property, metadata] of typeMetadata.properties) {
-        if (!metadata.data.has(injectMetadataSymbol)) {
-          continue;
-        }
-        instance[property] = (await this.resolveInjectionAsync(context, typeMetadata, metadata, resolveArgument, chain)).resolved;
-      }
-    }
-    if ((0, import_provider.isValueProvider)(registration.provider)) {
-      instance = registration.provider.useValue;
-    }
-    if ((0, import_provider.isTokenProvider)(registration.provider)) {
-      const arg = resolveArgument ?? registration.provider.argument ?? await registration.provider.argumentProvider?.();
-      const innerToken = registration.provider.useToken ?? await registration.provider.useTokenProvider();
-      instance = await this._resolveAsync(innerToken, false, arg, context, chain.addToken(innerToken), false);
-    }
-    if ((0, import_provider.isFactoryProvider)(registration.provider)) {
-      try {
-        instance = await registration.provider.useFactory(resolveArgument, this.getResolveContext(context, chain));
-      } catch (error) {
-        throw new import_resolve_error.ResolveError("Error in factory.", chain, error);
-      }
-    }
-    if (registration.options.lifecycle == "resolution") {
-      context.instances.set([token, argumentIdentity], instance);
-    }
-    if (registration.options.lifecycle == "singleton") {
-      registration.instances.set(argumentIdentity, instance);
-    }
-    context.resolutions.push({ instance, registration });
-    context.resolving.delete([token, argumentIdentity]);
-    if (isFirst) {
-      for (const fn of context.forwardRefQueue.consume()) {
-        await fn();
-      }
-      derefForwardRefs(context);
-      for (let i = context.resolutions.length - 1; i >= 0; i--) {
-        const resolution = context.resolutions[i];
-        if ((0, import_type_guards.isFunction)(resolution.instance?.[import_interfaces.afterResolve])) {
-          await resolution.instance[import_interfaces.afterResolve]();
-        }
-        if ((0, import_type_guards.isDefined)(resolution.registration.options.initializer)) {
-          await resolution.registration.options.initializer(resolution.instance);
-        }
-      }
-    }
-    return instance;
-  }
-  resolveInjection(token, context, typeMetadata, metadata, resolveArgument, chain) {
-    const getChain = metadata.metadataType == "constructor-parameter" ? (injectToken2) => chain.addParameter(typeMetadata.constructor, metadata.index, injectToken2).addToken(injectToken2) : (injectToken2) => chain.addProperty(typeMetadata.constructor, metadata.key, injectToken2).addToken(injectToken2);
-    const injectMetadata = metadata.data.tryGet(injectMetadataSymbol) ?? {};
-    const injectToken = injectMetadata.injectToken ?? metadata.type;
-    if ((0, import_type_guards.isDefined)(injectMetadata.injectArgumentMapper) && (!this.hasRegistration(injectToken) || (0, import_type_guards.isDefined)(resolveArgument) || (0, import_type_guards.isUndefined)(injectToken))) {
-      const mapped = injectMetadata.injectArgumentMapper(resolveArgument);
-      if ((0, import_type_guards.isPromise)(mapped)) {
-        throw new import_resolve_error.ResolveError(`Cannot evaluate async argument mapper for token ${(0, import_token.getTokenName)(token)} in synchronous resolve, use resolveAsync instead.`, getChain(injectToken));
-      }
-      return mapped;
-    }
-    const parameterResolveArgument = injectMetadata.forwardArgumentMapper?.(resolveArgument) ?? injectMetadata.resolveArgumentProvider?.(this.getResolveContext(context, getChain(injectToken)));
-    if ((0, import_type_guards.isPromise)(parameterResolveArgument)) {
-      throw new import_resolve_error.ResolveError(`Cannot evaluate async argument provider for token ${(0, import_token.getTokenName)(token)} in synchronous resolve, use resolveAsync instead.`, getChain(injectToken));
-    }
-    if ((0, import_type_guards.isDefined)(injectMetadata.forwardRefToken)) {
-      const forwardRef = import_forward_ref.ForwardRef.create();
-      const forwardRefToken = injectMetadata.forwardRefToken;
-      context.forwardRefQueue.add(() => {
-        const forwardToken = (0, import_type_guards.isFunction)(forwardRefToken) ? forwardRefToken() : forwardRefToken;
-        if ((0, import_type_guards.isDefined)(injectMetadata.mapper)) {
-          throw new import_resolve_error.ResolveError("Cannot use inject mapper with forwardRef.", getChain(forwardToken));
-        }
-        const resolved2 = this._resolve(forwardToken, injectMetadata.optional, parameterResolveArgument, context, getChain(forwardToken), false);
-        import_forward_ref.ForwardRef.setRef(forwardRef, resolved2);
-      });
-      context.forwardRefs.add(forwardRef);
-      return forwardRef;
-    }
-    const resolved = this._resolve(injectToken, injectMetadata.optional, parameterResolveArgument, context, getChain(injectToken), false);
-    return (0, import_type_guards.isDefined)(injectMetadata.mapper) ? injectMetadata.mapper(resolved) : resolved;
-  }
-  async resolveInjectionAsync(context, typeMetadata, metadata, resolveArgument, chain) {
-    const getChain = metadata.metadataType == "constructor-parameter" ? (injectToken2) => chain.addParameter(typeMetadata.constructor, metadata.index, injectToken2).addToken(injectToken2) : (injectToken2) => chain.addProperty(typeMetadata.constructor, metadata.key, injectToken2).addToken(injectToken2);
-    const injectMetadata = metadata.data.tryGet(injectMetadataSymbol) ?? {};
-    const injectToken = injectMetadata.injectToken ?? metadata.type;
-    if ((0, import_type_guards.isDefined)(injectMetadata.injectArgumentMapper) && (!this.hasRegistration(injectToken) || (0, import_type_guards.isDefined)(resolveArgument) || (0, import_type_guards.isUndefined)(injectToken))) {
-      return { resolved: injectMetadata.injectArgumentMapper(resolveArgument) };
-    }
-    const parameterResolveArgument = await (injectMetadata.forwardArgumentMapper?.(resolveArgument) ?? injectMetadata.resolveArgumentProvider?.(this.getResolveContext(context, getChain(injectToken))));
-    if ((0, import_type_guards.isDefined)(injectMetadata.forwardRefToken)) {
-      const forwardRef = import_forward_ref.ForwardRef.create();
-      const forwardRefToken = injectMetadata.forwardRefToken;
-      context.forwardRefQueue.add(async () => {
-        const forwardToken = (0, import_type_guards.isFunction)(forwardRefToken) ? forwardRefToken() : forwardRefToken;
-        if ((0, import_type_guards.isDefined)(injectMetadata.mapper)) {
-          throw new import_resolve_error.ResolveError("Cannot use inject mapper with forwardRef.", getChain(forwardToken));
-        }
-        const resolved2 = await this._resolveAsync(forwardToken, injectMetadata.optional, parameterResolveArgument, context, getChain(forwardToken), false);
-        import_forward_ref.ForwardRef.setRef(forwardRef, resolved2);
-      });
-      context.forwardRefs.add(forwardRef);
-      return { resolved: forwardRef };
-    }
-    const resolved = await this._resolveAsync(injectToken, injectMetadata.optional, parameterResolveArgument, context, getChain(injectToken), false);
-    return { resolved: (0, import_type_guards.isDefined)(injectMetadata.mapper) ? injectMetadata.mapper(resolved) : resolved };
-  }
-  getResolveContext(resolveContext, chain) {
-    const context = {
-      isAsync: resolveContext.isAsync,
-      resolve: (token, argument, instances) => {
-        this.addInstancesToResolveContext(instances, resolveContext);
-        return this._resolve(token, false, argument, resolveContext, chain.addToken(token), false);
-      },
-      resolveAsync: async (token, argument, instances) => {
-        this.addInstancesToResolveContext(instances, resolveContext);
-        return this._resolveAsync(token, false, argument, resolveContext, chain.addToken(token), false);
-      }
-    };
-    return context;
-  }
-  addInstancesToResolveContext(instances, resolveContext) {
-    if ((0, import_type_guards.isUndefined)(instances)) {
-      return;
+import { CircularBuffer } from '../data-structures/circular-buffer.js';
+import { MultiKeyMap } from '../data-structures/multi-key-map.js';
+import { reflectionRegistry } from '../reflection/index.js';
+import { mapAsync } from '../utils/async-iterable-helpers/map.js';
+import { toArrayAsync } from '../utils/async-iterable-helpers/to-array.js';
+import { ForwardRef } from '../utils/object/forward-ref.js';
+import { objectEntries } from '../utils/object/object.js';
+import { isDefined, isFunction, isPromise, isUndefined } from '../utils/type-guards.js';
+import { Subject } from 'rxjs';
+import { afterResolve } from './interfaces.js';
+import { isClassProvider, isFactoryProvider, isTokenProvider, isValueProvider } from './provider.js';
+import { ResolveChain } from './resolve-chain.js';
+import { ResolveError } from './resolve.error.js';
+import { getTokenName } from './token.js';
+import { isStubClass } from './utils.js';
+export const injectMetadataSymbol = Symbol('Inject metadata');
+export class Container {
+    registrationMap;
+    registrationSubject;
+    /** emits on new registration */
+    registration$;
+    /** all registrations */
+    get registrations() {
+        return this.registrationMap.values();
+    }
+    constructor() {
+        this.registrationMap = new Map();
+        this.registrationSubject = new Subject();
+        this.registration$ = this.registrationSubject.asObservable();
+    }
+    /**
+     * register a provider for a token
+     * @param token token to register
+     * @param provider provider used to resolve the token
+     * @param options registration options
+     */
+    register(token, provider, options = {}) {
+        if (isClassProvider(provider) && !isStubClass(provider.useClass)) {
+            const injectable = reflectionRegistry.getMetadata(provider.useClass)?.data.has(injectMetadataSymbol) ?? false;
+            if (!injectable) {
+                throw new Error(`${provider.useClass.name} is not injectable.`);
+            }
+        }
+        const registration = {
+            token,
+            provider,
+            options,
+            instances: new Map()
+        };
+        this.registrationMap.set(token, registration);
+        this.registrationSubject.next(registration);
+    }
+    /**
+     * register a provider for a token as a singleton. Alias for {@link register} with `singleton` lifecycle
+     * @param token token to register
+     * @param provider provider used to resolve the token
+     * @param options registration options
+     */
+    registerSingleton(token, provider, options) {
+        this.register(token, provider, { ...options, lifecycle: 'singleton' });
+    }
+    /**
+     * check if token has a registered provider
+     * @param token token check
+     */
+    hasRegistration(token) {
+        return this.registrationMap.has(token);
+    }
+    /**
+     * get registration
+     * @param token token to get registration for
+     */
+    getRegistration(token) {
+        const registration = this.registrationMap.get(token);
+        if (isUndefined(registration)) {
+            const tokenName = getTokenName(token);
+            throw new Error(`No provider for ${tokenName} registered.`);
+        }
+        return registration;
+    }
+    /**
+     * try to get registration
+     * @param token token to get registration for
+     */
+    tryGetRegistration(token) {
+        return this.registrationMap.get(token);
+    }
+    /**
+     * resolve a token
+     * @param token token to resolve
+     * @param argument argument used for resolving (overrides token and default arguments)
+     * @returns
+     */
+    resolve(token, argument, instances) {
+        const context = {
+            isAsync: false,
+            resolves: 0,
+            forwardRefQueue: new CircularBuffer(),
+            resolutions: [],
+            forwardRefs: new Set(),
+            providedInstances: new Map(instances),
+            instances: new MultiKeyMap(),
+            resolving: new MultiKeyMap()
+        };
+        return this._resolve(token, false, argument, context, ResolveChain.startWith(token), true);
+    }
+    /**
+     * resolve a token
+     * @param token token to resolve
+     * @param argument argument used for resolving (overrides token and default arguments)
+     * @returns
+     */
+    async resolveAsync(token, argument, instances) {
+        const context = {
+            isAsync: true,
+            resolves: 0,
+            forwardRefQueue: new CircularBuffer(),
+            resolutions: [],
+            forwardRefs: new Set(),
+            providedInstances: new Map(instances),
+            instances: new MultiKeyMap(),
+            resolving: new MultiKeyMap()
+        };
+        return this._resolveAsync(token, false, argument, context, ResolveChain.startWith(token), true);
+    }
+    // eslint-disable-next-line max-statements, max-lines-per-function, complexity
+    _resolve(token, optional, _argument, context, chain, isFirst) {
+        if ((chain.length > 750) || (++context.resolves > 750)) {
+            throw new ResolveError('Resolve stack overflow. This can happen on circular dependencies with transient lifecycles and self reference. Use scoped or singleton lifecycle instead or @forwardRef().', chain);
+        }
+        if (isUndefined(token)) {
+            throw new ResolveError('Token is undefined - this might be because of circular dependencies, use alias or forwardRef in this case.', chain);
+        }
+        if (context.providedInstances.has(token)) {
+            return context.providedInstances.get(token);
+        }
+        const registration = this.tryGetRegistration(token);
+        if (isUndefined(registration)) {
+            if (optional == true) {
+                return undefined;
+            }
+            throw new ResolveError(`No provider for ${getTokenName(token)} registered.`, chain);
+        }
+        const resolveArgument = _argument ?? registration.options.defaultArgument ?? registration.options.defaultArgumentProvider?.(this.getResolveContext(context, chain));
+        if (isPromise(resolveArgument)) {
+            throw new ResolveError(`Cannot evaluate async argument provider for token ${getTokenName(token)} in synchronous resolve, use resolveAsync instead.`, chain);
+        }
+        const argumentIdentity = (isDefined(registration.options.argumentIdentityProvider) && ((registration.options.lifecycle == 'resolution') || (registration.options.lifecycle == 'singleton')))
+            ? registration.options.argumentIdentityProvider(resolveArgument)
+            : resolveArgument;
+        if (isPromise(argumentIdentity)) {
+            throw new ResolveError(`Cannot evaluate async argument identity provider for token ${getTokenName(token)} in synchronous resolve, use resolveAsync instead.`, chain);
+        }
+        if ((registration.options.lifecycle == 'resolution') && context.instances.has([token, argumentIdentity])) {
+            return context.instances.get([token, argumentIdentity]);
+        }
+        if ((registration.options.lifecycle == 'singleton') && registration.instances.has(argumentIdentity)) {
+            return registration.instances.get(argumentIdentity);
+        }
+        if (context.resolving.has([token, argumentIdentity])) {
+            throw new ResolveError('Circular dependency to itself detected. Please check your registrations and providers. @forwardRef might be a solution.', chain);
+        }
+        context.resolving.set([token, argumentIdentity], true);
+        let instance;
+        if (isClassProvider(registration.provider)) {
+            const typeMetadata = reflectionRegistry.getMetadata(registration.provider.useClass);
+            if (isUndefined(typeMetadata) || !typeMetadata.data.has(injectMetadataSymbol)) {
+                throw new ResolveError(`${registration.provider.useClass.name} is not injectable.`, chain);
+            }
+            if (isStubClass(typeMetadata.constructor)) {
+                throw new ResolveError(`No provider for ${getTokenName(token)} registered.`, chain);
+            }
+            const parameters = (typeMetadata.parameters ?? []).map((metadata) => this.resolveInjection(token, context, typeMetadata, metadata, resolveArgument, chain));
+            instance = new typeMetadata.constructor(...parameters);
+            for (const [property, metadata] of typeMetadata.properties) {
+                if (!metadata.data.has(injectMetadataSymbol)) {
+                    continue;
+                }
+                instance[property] = this.resolveInjection(token, context, typeMetadata, metadata, resolveArgument, chain);
+            }
+        }
+        if (isValueProvider(registration.provider)) {
+            instance = registration.provider.useValue;
+        }
+        if (isTokenProvider(registration.provider)) {
+            const arg = resolveArgument ?? registration.provider.argument ?? registration.provider.argumentProvider?.();
+            const innerToken = registration.provider.useToken ?? registration.provider.useTokenProvider();
+            if (isPromise(arg)) {
+                throw new ResolveError(`Cannot evaluate async argument provider for token ${getTokenName(token)} in synchronous resolve, use resolveAsync instead.`, chain);
+            }
+            if (isPromise(innerToken)) {
+                throw new ResolveError(`Cannot evaluate async token provider for token ${getTokenName(token)} in synchronous resolve, use resolveAsync instead.`, chain);
+            }
+            instance = this._resolve(innerToken, false, arg, context, chain.addToken(innerToken), false);
+        }
+        if (isFactoryProvider(registration.provider)) {
+            try {
+                const result = registration.provider.useFactory(resolveArgument, this.getResolveContext(context, chain));
+                if (isPromise(result)) {
+                    throw new ResolveError(`Cannot evaluate async factory provider for token ${getTokenName(token)} in synchronous resolve, use resolveAsync instead.`, chain);
+                }
+                instance = result;
+            }
+            catch (error) {
+                throw new ResolveError('Error in factory.', chain, error);
+            }
+        }
+        if (registration.options.lifecycle == 'resolution') {
+            context.instances.set([token, argumentIdentity], instance);
+        }
+        if (registration.options.lifecycle == 'singleton') {
+            registration.instances.set(argumentIdentity, instance);
+        }
+        context.resolutions.push({ instance, registration });
+        context.resolving.delete([token, argumentIdentity]);
+        if (isFirst) {
+            for (const fn of context.forwardRefQueue.consume()) {
+                fn();
+            }
+            derefForwardRefs(context);
+            for (let i = context.resolutions.length - 1; i >= 0; i--) {
+                const resolution = context.resolutions[i];
+                if (isFunction(resolution.instance?.[afterResolve])) {
+                    const returnValue = resolution.instance[afterResolve]();
+                    if (isPromise(returnValue)) {
+                        throw new ResolveError(`Cannot execute async [afterResolve] for token ${getTokenName(token)} in synchronous resolve, use resolveAsync instead.`, chain);
+                    }
+                }
+                if (isDefined(resolution.registration.options.initializer)) {
+                    const returnValue = resolution.registration.options.initializer(resolution.instance);
+                    if (isPromise(returnValue)) {
+                        throw new ResolveError(`Cannot execute async initializer for token ${getTokenName(token)} in synchronous resolve, use resolveAsync instead.`, chain);
+                    }
+                }
+            }
+        }
+        return instance;
     }
-    for (const [instanceToken, instance] of instances) {
-      resolveContext.providedInstances.set(instanceToken, instance);
+    // eslint-disable-next-line max-statements, max-lines-per-function, complexity
+    async _resolveAsync(token, optional, _argument, context, chain, isFirst) {
+        if ((chain.length > 750) || (++context.resolves > 750)) {
+            throw new ResolveError('Resolve stack overflow. This can happen on circular dependencies with transient lifecycles and self reference. Use scoped or singleton lifecycle instead or @forwardRef().', chain);
+        }
+        if (isUndefined(token)) {
+            throw new ResolveError('Token is undefined - this might be because of circular dependencies, use alias or forwardRef in this case.', chain);
+        }
+        if (context.providedInstances.has(token)) {
+            return context.providedInstances.get(token);
+        }
+        const registration = this.tryGetRegistration(token);
+        if (isUndefined(registration)) {
+            if (optional == true) {
+                return undefined;
+            }
+            throw new ResolveError(`No provider for ${getTokenName(token)} registered.`, chain);
+        }
+        const resolveArgument = _argument ?? registration.options.defaultArgument ?? (await registration.options.defaultArgumentProvider?.(this.getResolveContext(context, chain)));
+        const argumentIdentity = (isDefined(registration.options.argumentIdentityProvider) && ((registration.options.lifecycle == 'resolution') || (registration.options.lifecycle == 'singleton')))
+            ? await registration.options.argumentIdentityProvider(resolveArgument)
+            : resolveArgument;
+        if ((registration.options.lifecycle == 'resolution') && context.instances.has([token, argumentIdentity])) {
+            return context.instances.get([token, argumentIdentity]);
+        }
+        if ((registration.options.lifecycle == 'singleton') && registration.instances.has(argumentIdentity)) {
+            return registration.instances.get(argumentIdentity);
+        }
+        if (context.resolving.has([token, argumentIdentity])) {
+            throw new ResolveError('Circular dependency to itself detected. Please check your registrations and providers. @forwardRef might be a solution.', chain);
+        }
+        context.resolving.set([token, argumentIdentity], true);
+        let instance;
+        if (isClassProvider(registration.provider)) {
+            const typeMetadata = reflectionRegistry.getMetadata(registration.provider.useClass);
+            if (isUndefined(typeMetadata) || !typeMetadata.data.has(injectMetadataSymbol)) {
+                throw new ResolveError(`${registration.provider.useClass.name} is not injectable.`, chain);
+            }
+            if (isStubClass(typeMetadata.constructor)) {
+                throw new ResolveError(`No provider for ${getTokenName(token)} registered.`, chain);
+            }
+            const boxedParameters = await toArrayAsync(mapAsync(typeMetadata.parameters ?? [], async (metadata) => this.resolveInjectionAsync(context, typeMetadata, metadata, resolveArgument, chain)));
+            const parameters = boxedParameters.map((box) => box.resolved);
+            instance = new typeMetadata.constructor(...parameters);
+            for (const [property, metadata] of typeMetadata.properties) {
+                if (!metadata.data.has(injectMetadataSymbol)) {
+                    continue;
+                }
+                instance[property] = (await this.resolveInjectionAsync(context, typeMetadata, metadata, resolveArgument, chain)).resolved;
+            }
+        }
+        if (isValueProvider(registration.provider)) {
+            instance = registration.provider.useValue;
+        }
+        if (isTokenProvider(registration.provider)) {
+            const arg = resolveArgument ?? registration.provider.argument ?? await registration.provider.argumentProvider?.();
+            const innerToken = registration.provider.useToken ?? await registration.provider.useTokenProvider();
+            instance = await this._resolveAsync(innerToken, false, arg, context, chain.addToken(innerToken), false);
+        }
+        if (isFactoryProvider(registration.provider)) {
+            try {
+                instance = await registration.provider.useFactory(resolveArgument, this.getResolveContext(context, chain));
+            }
+            catch (error) {
+                throw new ResolveError('Error in factory.', chain, error);
+            }
+        }
+        if (registration.options.lifecycle == 'resolution') {
+            context.instances.set([token, argumentIdentity], instance);
+        }
+        if (registration.options.lifecycle == 'singleton') {
+            registration.instances.set(argumentIdentity, instance);
+        }
+        context.resolutions.push({ instance, registration });
+        context.resolving.delete([token, argumentIdentity]);
+        if (isFirst) {
+            for (const fn of context.forwardRefQueue.consume()) {
+                await fn();
+            }
+            derefForwardRefs(context);
+            for (let i = context.resolutions.length - 1; i >= 0; i--) {
+                const resolution = context.resolutions[i];
+                if (isFunction(resolution.instance?.[afterResolve])) {
+                    await resolution.instance[afterResolve]();
+                }
+                if (isDefined(resolution.registration.options.initializer)) {
+                    await resolution.registration.options.initializer(resolution.instance);
+                }
+            }
+        }
+        return instance;
+    }
+    resolveInjection(token, context, typeMetadata, metadata, resolveArgument, chain) {
+        const getChain = (metadata.metadataType == 'constructor-parameter')
+            ? (injectToken) => chain.addParameter(typeMetadata.constructor, metadata.index, injectToken).addToken(injectToken)
+            : (injectToken) => chain.addProperty(typeMetadata.constructor, metadata.key, injectToken).addToken(injectToken);
+        const injectMetadata = metadata.data.tryGet(injectMetadataSymbol) ?? {};
+        const injectToken = (injectMetadata.injectToken ?? metadata.type);
+        if (isDefined(injectMetadata.injectArgumentMapper) && (!this.hasRegistration(injectToken) || isDefined(resolveArgument) || isUndefined(injectToken))) {
+            const mapped = injectMetadata.injectArgumentMapper(resolveArgument);
+            if (isPromise(mapped)) {
+                throw new ResolveError(`Cannot evaluate async argument mapper for token ${getTokenName(token)} in synchronous resolve, use resolveAsync instead.`, getChain(injectToken));
+            }
+            return mapped;
+        }
+        const parameterResolveArgument = injectMetadata.forwardArgumentMapper?.(resolveArgument) ?? injectMetadata.resolveArgumentProvider?.(this.getResolveContext(context, getChain(injectToken)));
+        if (isPromise(parameterResolveArgument)) {
+            throw new ResolveError(`Cannot evaluate async argument provider for token ${getTokenName(token)} in synchronous resolve, use resolveAsync instead.`, getChain(injectToken));
+        }
+        if (isDefined(injectMetadata.forwardRefToken)) {
+            const forwardRef = ForwardRef.create();
+            const forwardRefToken = injectMetadata.forwardRefToken;
+            context.forwardRefQueue.add(() => {
+                const forwardToken = isFunction(forwardRefToken) ? forwardRefToken() : forwardRefToken;
+                if (isDefined(injectMetadata.mapper)) {
+                    throw new ResolveError('Cannot use inject mapper with forwardRef.', getChain(forwardToken));
+                }
+                const resolved = this._resolve(forwardToken, injectMetadata.optional, parameterResolveArgument, context, getChain(forwardToken), false);
+                ForwardRef.setRef(forwardRef, resolved);
+            });
+            context.forwardRefs.add(forwardRef);
+            return forwardRef;
+        }
+        const resolved = this._resolve(injectToken, injectMetadata.optional, parameterResolveArgument, context, getChain(injectToken), false);
+        return isDefined(injectMetadata.mapper) ? injectMetadata.mapper(resolved) : resolved;
+    }
+    async resolveInjectionAsync(context, typeMetadata, metadata, resolveArgument, chain) {
+        const getChain = (metadata.metadataType == 'constructor-parameter')
+            ? (injectToken) => chain.addParameter(typeMetadata.constructor, metadata.index, injectToken).addToken(injectToken)
+            : (injectToken) => chain.addProperty(typeMetadata.constructor, metadata.key, injectToken).addToken(injectToken);
+        const injectMetadata = metadata.data.tryGet(injectMetadataSymbol) ?? {};
+        const injectToken = (injectMetadata.injectToken ?? metadata.type);
+        if (isDefined(injectMetadata.injectArgumentMapper) && (!this.hasRegistration(injectToken) || isDefined(resolveArgument) || isUndefined(injectToken))) {
+            return { resolved: injectMetadata.injectArgumentMapper(resolveArgument) };
+        }
+        const parameterResolveArgument = await (injectMetadata.forwardArgumentMapper?.(resolveArgument) ?? injectMetadata.resolveArgumentProvider?.(this.getResolveContext(context, getChain(injectToken))));
+        if (isDefined(injectMetadata.forwardRefToken)) {
+            const forwardRef = ForwardRef.create();
+            const forwardRefToken = injectMetadata.forwardRefToken;
+            context.forwardRefQueue.add(async () => {
+                const forwardToken = isFunction(forwardRefToken) ? forwardRefToken() : forwardRefToken;
+                if (isDefined(injectMetadata.mapper)) {
+                    throw new ResolveError('Cannot use inject mapper with forwardRef.', getChain(forwardToken));
+                }
+                const resolved = await this._resolveAsync(forwardToken, injectMetadata.optional, parameterResolveArgument, context, getChain(forwardToken), false);
+                ForwardRef.setRef(forwardRef, resolved);
+            });
+            context.forwardRefs.add(forwardRef);
+            return { resolved: forwardRef };
+        }
+        const resolved = await this._resolveAsync(injectToken, injectMetadata.optional, parameterResolveArgument, context, getChain(injectToken), false);
+        return { resolved: isDefined(injectMetadata.mapper) ? injectMetadata.mapper(resolved) : resolved };
+    }
+    getResolveContext(resolveContext, chain) {
+        const context = {
+            isAsync: resolveContext.isAsync,
+            resolve: (token, argument, instances) => {
+                this.addInstancesToResolveContext(instances, resolveContext);
+                return this._resolve(token, false, argument, resolveContext, chain.addToken(token), false);
+            },
+            resolveAsync: async (token, argument, instances) => {
+                this.addInstancesToResolveContext(instances, resolveContext);
+                return this._resolveAsync(token, false, argument, resolveContext, chain.addToken(token), false);
+            }
+        };
+        return context;
+    }
+    addInstancesToResolveContext(instances, resolveContext) {
+        if (isUndefined(instances)) {
+            return;
+        }
+        for (const [instanceToken, instance] of instances) {
+            resolveContext.providedInstances.set(instanceToken, instance);
+        }
     }
-  }
 }
 function derefForwardRefs(context) {
-  for (const resolution of context.resolutions) {
-    if (!(typeof resolution.instance == "object")) {
-      continue;
-    }
-    for (const [key, value] of (0, import_object.objectEntries)(resolution.instance)) {
-      if (!context.forwardRefs.has(value)) {
-        continue;
-      }
-      resolution.instance[key] = import_forward_ref.ForwardRef.deref(value);
+    for (const resolution of context.resolutions) {
+        if (!(typeof resolution.instance == 'object')) {
+            continue;
+        }
+        for (const [key, value] of objectEntries(resolution.instance)) {
+            if (!context.forwardRefs.has(value)) {
+                continue;
+            }
+            resolution.instance[key] = ForwardRef.deref(value);
+        }
     }
-  }
 }
-const container = new Container();
+export const container = new Container();