@tstdl/base 0.86.0-beta9 → 0.86.1

package/utils/cancellation-token.js

@@ -18,23 +18,26 @@ var __copyProps = (to, from2, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var cancellation_token_exports = {};
 __export(cancellation_token_exports, {
-  CancellationToken: () => CancellationToken
+  CancellationToken: () => CancellationToken,
+  ReadonlyCancellationToken: () => ReadonlyCancellationToken
 });
 module.exports = __toCommonJS(cancellation_token_exports);
-var import_noop = require("../rxjs/noop.js");
 var import_rxjs = require("rxjs");
+var import_noop = require("../rxjs/noop.js");
 var import_noop2 = require("./noop.js");
 var import_type_guards = require("./type-guards.js");
-class CancellationToken {
-  stateSubject;
-  state$;
-  set$;
-  unset$;
+class ReadonlyCancellationToken {
+}
+class CancellationToken extends ReadonlyCancellationToken {
+  #stateSubject = new import_rxjs.BehaviorSubject(false);
+  state$ = this.#stateSubject.pipe((0, import_rxjs.distinctUntilChanged)());
+  set$ = this.state$.pipe((0, import_rxjs.filter)((state) => state), (0, import_rxjs.map)(() => void 0));
+  unset$ = this.state$.pipe((0, import_rxjs.filter)((state) => !state), (0, import_rxjs.map)(() => void 0));
   get isSet() {
-    return this.stateSubject.value;
+    return this.#stateSubject.value;
   }
   get isUnset() {
-    return !this.stateSubject.value;
+    return !this.#stateSubject.value;
   }
   get $set() {
     return (0, import_rxjs.firstValueFrom)(this.set$);
@@ -52,10 +55,8 @@ class CancellationToken {
    * @default false
    */
   constructor(initialState = false) {
-    this.stateSubject = new import_rxjs.BehaviorSubject(initialState);
-    this.state$ = this.stateSubject.pipe((0, import_rxjs.distinctUntilChanged)());
-    this.set$ = this.state$.pipe((0, import_rxjs.filter)((state) => state), (0, import_rxjs.map)(() => void 0));
-    this.unset$ = this.state$.pipe((0, import_rxjs.filter)((state) => !state), (0, import_rxjs.map)(() => void 0));
+    super();
+    this.#stateSubject.next(initialState);
   }
   static from(source, config) {
     const source$ = source instanceof AbortSignal ? (0, import_rxjs.fromEvent)(source, "abort", () => true) : (0, import_rxjs.isObservable)(source) ? source.pipe((0, import_rxjs.map)((state) => (0, import_type_guards.isBoolean)(state) ? state : true)) : (0, import_rxjs.from)(source).pipe((0, import_rxjs.map)(() => true));
@@ -71,7 +72,7 @@ class CancellationToken {
       error: error ? (errorValue) => target.error(errorValue) : import_noop2.noop,
       complete: complete ? () => target.complete() : import_noop2.noop
     });
-    target.stateSubject.subscribe({
+    target.#stateSubject.subscribe({
       error: () => subscription.unsubscribe(),
       complete: () => subscription.unsubscribe()
     });
@@ -103,25 +104,25 @@ class CancellationToken {
    * Set this token.
    */
   set() {
-    this.stateSubject.next(true);
+    this.#stateSubject.next(true);
   }
   /**
    * Unset this token.
    */
   unset() {
-    this.stateSubject.next(false);
+    this.#stateSubject.next(false);
   }
   /**
    * Set the state.
    */
   setState(state) {
-    this.stateSubject.next(state);
+    this.#stateSubject.next(state);
   }
   /**
    * Errors the token.
    */
   error(error) {
-    this.stateSubject.error(error);
+    this.#stateSubject.error(error);
   }
   /**
    * Clean up subscriptions.
@@ -129,7 +130,7 @@ class CancellationToken {
    * Keep in mind that *active* awaits (promise) on this token will throw.
    */
   complete() {
-    this.stateSubject.complete();
+    this.#stateSubject.complete();
   }
   async then(onfulfilled) {
     await this.$set;

package/_container/container.d.ts

@@ -1,99 +0,0 @@
-import type { Record, TypedOmit } from '../types.js';
-import type { Observable } from 'rxjs';
-import type { Injectable, InjectableArgument } from './interfaces.js';
-import type { Provider } from './provider.js';
-import type { InjectionToken } from './token.js';
-import type { ArgumentProvider, Mapper } from './types.js';
-export declare const injectMetadataSymbol: unique symbol;
-/**
- * transient: a new instance will be created with each resolve
- * singleton: each resolve will return the same instance
- * resolution: the same instance will be resolved for each resolution of this dependency during a single resolution chain
- */
-export type Lifecycle = 'transient' | 'singleton' | 'resolution';
-export type RegistrationOptions<T, A = unknown> = {
-    lifecycle?: Lifecycle;
-    /** default resolve argument used when neither token nor explicit resolve argument is provided */
-    defaultArgument?: InjectableArgument<T, A>;
-    /** default resolve argument used when neither token nor explicit resolve argument is provided */
-    defaultArgumentProvider?: ArgumentProvider<InjectableArgument<T, A>>;
-    /**
-     * value to distinguish scoped and singleton instances based on argument
-     * by default it uses strict equality (===) on the original argument,
-     * so modifications to argument objects and literal objects in the call
-     * may not yield the expected result
-     *
-     * hint: {@link JSON.stringify} is a simple solution for many use cases,
-     * but will fail if properties have different order
-     */
-    argumentIdentityProvider?: Mapper<InjectableArgument<T, A> | undefined>;
-    /** function which gets called after a resolve */
-    initializer?: (instance: T) => any;
-    /** custom metadata */
-    metadata?: Record;
-};
-export type Registration<T = any, A = any> = {
-    token: InjectionToken<T, A>;
-    provider: Provider<T, A>;
-    options: RegistrationOptions<T, A>;
-    instances: Map<any, T>;
-};
-export declare class Container {
-    private readonly registrationMap;
-    private readonly registrationSubject;
-    /** emits on new registration */
-    readonly registration$: Observable<Registration>;
-    /** all registrations */
-    get registrations(): Iterable<Registration>;
-    constructor();
-    /**
-     * register a provider for a token
-     * @param token token to register
-     * @param provider provider used to resolve the token
-     * @param options registration options
-     */
-    register<T, A = any>(token: InjectionToken<T, A>, provider: Provider<T, A>, options?: RegistrationOptions<T, A>): void;
-    /**
-     * 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<T, A = any>(token: InjectionToken<T, A>, provider: Provider<T, A>, options?: TypedOmit<RegistrationOptions<T, A>, 'lifecycle'>): void;
-    /**
-     * check if token has a registered provider
-     * @param token token check
-     */
-    hasRegistration(token: InjectionToken): boolean;
-    /**
-     * get registration
-     * @param token token to get registration for
-     */
-    getRegistration<T, A>(token: InjectionToken<T, A>): Registration<T, A>;
-    /**
-     * try to get registration
-     * @param token token to get registration for
-     */
-    tryGetRegistration<T, A>(token: InjectionToken<T, A>): Registration<T, A> | undefined;
-    /**
-     * resolve a token
-     * @param token token to resolve
-     * @param argument argument used for resolving (overrides token and default arguments)
-     * @returns
-     */
-    resolve<T, A = T extends Injectable<infer AInject> ? AInject : any>(token: InjectionToken<T, A>, argument?: T extends Injectable<infer AInject> ? AInject : A, instances?: [InjectionToken, any][]): T;
-    /**
-     * resolve a token
-     * @param token token to resolve
-     * @param argument argument used for resolving (overrides token and default arguments)
-     * @returns
-     */
-    resolveAsync<T, A = T extends Injectable<infer AInject> ? AInject : any>(token: InjectionToken<T, A>, argument?: T extends Injectable<infer AInject> ? AInject : A, instances?: [InjectionToken, any][]): Promise<T>;
-    private _resolve;
-    private _resolveAsync;
-    private resolveInjection;
-    private resolveInjectionAsync;
-    private getResolveContext;
-    private addInstancesToResolveContext;
-}
-export declare const container: Container;

package/_container/container.js

@@ -1,443 +0,0 @@
-"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;
-    }
-    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);
-    }
-  }
-}
-const container = new Container();