@tstdl/base 0.83.0-beta2 → 0.83.0-beta3

package/container/container.js

@@ -1,429 +1,443 @@
-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;
+"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.`);
+      }
     }
-    // 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);
-        }
+    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;
+    }
+    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 objectEntries(resolution.instance)) {
-            if (!context.forwardRefs.has(value)) {
-                continue;
-            }
-            resolution.instance[key] = ForwardRef.deref(value);
-        }
+  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);
     }
+  }
 }
-export const container = new Container();
-//# sourceMappingURL=container.js.map
+const container = new Container();