@tstdl/base 0.93.36 → 0.93.37

package/source/injector/injector.ts

@@ -1,919 +0,0 @@
-import { CancellationSignal, CancellationToken } from '#/cancellation/index.js';
-import { CircularBuffer } from '#/data-structures/circular-buffer.js';
-import { MultiKeyMap } from '#/data-structures/multi-key-map.js';
-import { isSyncOrAsyncDisposable } from '#/disposable/disposable.js';
-import { DeferredPromise } from '#/promise/deferred-promise.js';
-import { reflectionRegistry, type ConstructorParameterMetadata } from '#/reflection/registry.js';
-import type { AbstractConstructor, Constructor, OneOrMany, Record, TypedOmit, WritableOneOrMany } from '#/types/index.js';
-import { toArray } from '#/utils/array/array.js';
-import { FactoryMap } from '#/utils/factory-map.js';
-import { ForwardRef } from '#/utils/object/forward-ref.js';
-import { objectEntries } from '#/utils/object/object.js';
-import { assert, isArray, isBoolean, isDefined, isFunction, isNotNull, isNotObject, isNull, isPromise, isUndefined } from '#/utils/type-guards.js';
-import { setCurrentInjectionContext, type InjectOptions, type InjectionContext } from './inject.js';
-import { afterResolve, type Resolvable, type ResolveArgument } from './interfaces.js';
-import { isClassProvider, isFactoryProvider, isProviderWithInitializer, isTokenProvider, isValueProvider, type Provider } from './provider.js';
-import { RegistrationError } from './registration.error.js';
-import { runInResolutionContext, type AfterResolveHandler, type ResolutionContext } from './resolution.js';
-import { ResolveChain } from './resolve-chain.js';
-import { ResolveError } from './resolve.error.js';
-import { injectMetadataSymbol, injectableMetadataSymbol } from './symbols.js';
-import { getTokenName, type InjectionToken } from './token.js';
-import type { InjectMetadata } from './type-info.js';
-import type { AfterResolveContext, RegistrationOptions, ResolveContext, ResolveContextData, ResolveOptions } from './types.js';
-
-export type DisposeHandler = Disposable | AsyncDisposable | (() => PromiseLike<void> | void);
-
-type ResolutionTag = symbol;
-
-type RegistrationsMap = Map<InjectionToken, WritableOneOrMany<Registration>>;
-type GlobalRegistrationsMap = Map<InjectionToken, WritableOneOrMany<GlobalRegistration>>;
-
-type InternalResolveContext = {
-  resolves: number,
-
-  /** Currently resolving tokens (for circular dependency detection) */
-  resolving: FactoryMap<Injector, Set<InjectionToken>>,
-
-  /** Resolutions for resolution scoped dependencies  */
-  resolutionScopedResolutions: MultiKeyMap<[InjectionToken, unknown], Resolution<any, any>>,
-
-  /** All resolutions in this chain for postprocessing */
-  resolutions: Resolution<any, any>[],
-  resolutionContextData: FactoryMap<ResolutionTag, ResolveContextData<Record>>,
-
-  forwardRefQueue: CircularBuffer<() => void>,
-  forwardRefs: Set<ForwardRef>,
-
-  $done: DeferredPromise,
-};
-
-type Resolution<T, A> = {
-  tag: ResolutionTag,
-  registration: Registration<T>,
-  value: T,
-  argument: ResolveArgument<T, A>,
-  afterResolveRegistrations: AfterResolveHandler<A, Record>[],
-  afterResolveContext: AfterResolveContext<any>,
-  chain: ResolveChain,
-};
-
-export type ProvidersItem<T = any, A = any, D extends Record = Record> = Provider<T, A, D> & { provide: InjectionToken<T, A>, multi?: boolean };
-
-export type GlobalRegistration<T = any, A = any> = {
-  token: InjectionToken<T, A>,
-  provider: Provider<T, A>,
-  providers: ProvidersItem[],
-  options: RegistrationOptions<T, A>,
-};
-
-export type Registration<T = any, A = any> = GlobalRegistration<T, A> & {
-  /**
-   * A map associating argument identities to their resolved instances of type `T`.
-   */
-  resolutions: Map<any, T>,
-};
-
-export type GetRegistrationOptions = {
-  skipSelf?: boolean | number,
-  onlySelf?: boolean,
-};
-
-export type ResolveManyArrayItem<T, A> = [token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions<T, A>];
-export type ResolveManyItem<T, A> = InjectionToken<T, A> | ResolveManyArrayItem<T, A>;
-export type ResolveManyItemReturnType<T extends ResolveManyItem<any, any>> = T extends ResolveManyItem<infer U, any>
-  ? U | (T extends (ResolveManyArrayItem<any, any> & [any, any, { optional: true }]) ? undefined : never)
-  : never;
-export type ResolveManyReturnType<T extends ResolveManyItem<any, any>[]> = { [I in keyof T]: ResolveManyItemReturnType<T[I]> };
-
-export type AddDisposeHandler = (handler: Disposable | AsyncDisposable | (() => any)) => void;
-
-let _id = 1;
-
-export class Injector implements AsyncDisposable {
-  static readonly #globalRegistrations: GlobalRegistrationsMap = new Map();
-
-  readonly #parent: Injector | null;
-  readonly #children: Injector[] = [];
-  readonly #disposeToken = new CancellationToken();
-  readonly #disposableStack = new AsyncDisposableStack();
-  readonly #disposableStackRegistrations = new Set<object>();
-  readonly #registrations: RegistrationsMap = new Map();
-  readonly #injectorScopedResolutions = new MultiKeyMap<[InjectionToken, unknown], Resolution<any, any>>();
-  readonly #addDisposeHandler: AddDisposeHandler;
-
-  readonly id = _id++;
-  readonly name: string;
-
-  get parent(): Injector | null {
-    return this.#parent;
-  }
-
-  get disposed(): boolean {
-    return this.#disposableStack.disposed;
-  }
-
-  constructor(name: string, parent: Injector | null = null) {
-    this.name = name;
-    this.#parent = parent;
-
-    this.register(Injector, { useValue: this });
-    this.register(CancellationSignal, { useValue: this.#disposeToken.signal });
-
-    this.#addDisposeHandler = (handler: DisposeHandler): void => {
-      if (isSyncOrAsyncDisposable(handler)) {
-        this.#disposableStack.use(handler);
-      }
-      else {
-        this.#disposableStack.defer(handler);
-      }
-    };
-
-    this.#disposableStack.defer(() => this.#registrations.clear());
-    this.#disposableStack.defer(() => this.#injectorScopedResolutions.clear());
-    this.#disposableStack.defer(() => this.#disposableStackRegistrations.clear());
-  }
-
-  /**
-   * Globally register a provider for a token
-   * @param token token to register
-   * @param provider provider used to resolve the token
-   * @param options registration options
-   */
-  static register<T, A = any, D extends Record = Record>(token: InjectionToken<T, A>, providers: OneOrMany<Provider<T, A, D>>, options: RegistrationOptions<T, A, D> = {}): void {
-    const multi = isArray(providers);
-
-    for (const provider of toArray(providers)) {
-      const registration: GlobalRegistration<T> = {
-        token,
-        provider,
-        providers: options.providers ?? [],
-        options: { multi, ...options },
-      };
-
-      addRegistration(Injector.#globalRegistrations, registration);
-    }
-  }
-
-  /**
-   * Globally 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
-   */
-  static registerSingleton<T, A = undefined, C extends Record = Record>(token: InjectionToken<T, A>, providers: OneOrMany<Provider<T, A, C>>, options?: TypedOmit<RegistrationOptions<T, A, C>, 'lifecycle'>): void {
-    Injector.register(token, providers, { ...options, lifecycle: 'singleton' });
-  }
-
-  async dispose(): Promise<void> {
-    this.#disposeToken.set();
-    await this.#disposableStack.disposeAsync();
-  }
-
-  async [Symbol.asyncDispose](): Promise<void> {
-    await this.dispose();
-  }
-
-  /**
-   * Creates a new child `Injector` instance with the specified name.
-   *
-   * @param name - The name to assign to the child injector.
-   * @returns The newly created child `Injector` instance.
-   */
-  fork(name: string): Injector {
-    const child = new Injector(name, this);
-
-    this.#children.push(child);
-    this.#disposableStack.use(child);
-
-    return child;
-  }
-
-  /**
-   * 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, C extends Record = Record>(token: InjectionToken<T, A>, providers: OneOrMany<Provider<T, A, C>>, options: RegistrationOptions<T, A, C> = {}): this {
-    this.assertNotDisposed();
-
-    const multi = isArray(providers);
-
-    for (const provider of toArray(providers)) {
-      const registration: Registration<T> = {
-        token,
-        provider,
-        providers: options.providers ?? [],
-        options: { multi, ...options },
-        resolutions: new Map(),
-      };
-
-      addRegistration(this.#registrations, registration);
-    }
-
-    return this;
-  }
-
-  /**
-   * 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, C extends Record = Record>(token: InjectionToken<T, A>, providers: OneOrMany<Provider<T, A, C>>, options?: TypedOmit<RegistrationOptions<T, A, C>, 'lifecycle'>): this {
-    this.register(token, providers, { ...options, lifecycle: 'singleton' });
-    return this;
-  }
-
-  /**
-   * Check if token has a registered provider
-   * @param token token check
-   */
-  hasRegistration(token: InjectionToken, options?: GetRegistrationOptions): boolean {
-    const registration = this.tryGetRegistration(token, options);
-    return isDefined(registration);
-  }
-
-  /**
-   * Try to get registration
-   * @param token token to get registration for
-   */
-  tryGetRegistration<T, A>(token: InjectionToken<T, A>, options?: GetRegistrationOptions): Registration<T, A> | Registration<T, A>[] | undefined {
-    if (isNull(this.#parent) && !this.#registrations.has(token)) {
-      const globalRegistrations = toArray(Injector.#globalRegistrations.get(token) ?? []);
-
-      for (const globalRegistration of globalRegistrations) {
-        this.register(globalRegistration.token, globalRegistration.provider, globalRegistration.options);
-      }
-    }
-
-    const skipSelf = Number(options?.skipSelf ?? 0);
-
-    if (skipSelf > 0) {
-      return this.#parent?.tryGetRegistration(token, { ...options, skipSelf: skipSelf - 1 });
-    }
-
-    const ownRegistration = this.#registrations.get(token);
-
-    if (isDefined(ownRegistration)) {
-      return ownRegistration;
-    }
-
-    if (options?.onlySelf != true) {
-      return this.#parent?.tryGetRegistration(token, options);
-    }
-
-    return undefined;
-  }
-
-  /**
-   * Get registration
-   * @param token token to get registration for
-   */
-  getRegistration<T, A>(token: InjectionToken<T, A>, options?: GetRegistrationOptions): Registration<T, A> | Registration<T, A>[] {
-    const registration = this.tryGetRegistration(token, options);
-
-    if (isUndefined(registration)) {
-      const tokenName = getTokenName(token);
-      throw new Error(`No provider for ${tokenName} registered.`);
-    }
-
-    return registration;
-  }
-
-  resolve<T, A>(token: InjectionToken<T, A>, argument: ResolveArgument<T, A>, options: ResolveOptions<T, A> & { optional: true }): T | undefined;
-  resolve<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: ResolveOptions<T, A>): T;
-  resolve<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options: ResolveOptions<T, A> = {}): T | undefined {
-    const context: InternalResolveContext = newInternalResolveContext();
-    const value = this._resolve(token, argument, options, context, ResolveChain.startWith(this, token));
-
-    try {
-      postProcess(context);
-      context.$done.resolve();
-    }
-    catch (error) {
-      context.$done.reject(error); // eslint-disable-line @typescript-eslint/prefer-promise-reject-errors
-      throw error;
-    }
-
-    if (context.forwardRefs.has(value as ForwardRef)) {
-      return ForwardRef.deref(value as ForwardRef) as T;
-    }
-
-    return value;
-  }
-
-  resolveAll<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options: ResolveOptions<T, A> = {}): T[] {
-    const context: InternalResolveContext = newInternalResolveContext();
-    const values = this._resolveAll(token, argument, options, context, ResolveChain.startWith(this, token));
-
-    try {
-      postProcess(context);
-      context.$done.resolve();
-    }
-    catch (error) {
-      context.$done.reject(error); // eslint-disable-line @typescript-eslint/prefer-promise-reject-errors
-      throw error;
-    }
-
-    if (context.forwardRefs.has(values as ForwardRef)) {
-      return ForwardRef.deref(values as ForwardRef) as T[];
-    }
-
-    return values;
-  }
-
-  resolveMany<T extends ResolveManyItem<any, any>[]>(...tokens: T): ResolveManyReturnType<T> {
-    const context: InternalResolveContext = newInternalResolveContext();
-    const values = this._resolveManyTokens(tokens, context);
-
-    try {
-      postProcess(context);
-      context.$done.resolve();
-    }
-    catch (error) {
-      context.$done.reject(error); // eslint-disable-line @typescript-eslint/prefer-promise-reject-errors
-      throw error;
-    }
-
-    return values.map((value): unknown => context.forwardRefs.has(value as ForwardRef)
-      ? ForwardRef.deref(value as ForwardRef)
-      : value
-    ) as ResolveManyReturnType<T>;
-  }
-
-  async resolveAsync<T, A>(token: InjectionToken<T, A>, argument: ResolveArgument<T, A>, options: ResolveOptions<T, A> & { optional: true }): Promise<T | undefined>;
-  async resolveAsync<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: ResolveOptions<T, A>): Promise<T>;
-  async resolveAsync<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options: ResolveOptions<T, A> = {}): Promise<T | undefined> {
-    const context: InternalResolveContext = newInternalResolveContext();
-    const value = this._resolve(token, argument, options, context, ResolveChain.startWith(this, token));
-
-    try {
-      await postProcessAsync(context);
-      context.$done.resolve();
-    }
-    catch (error) {
-      context.$done.reject(error); // eslint-disable-line @typescript-eslint/prefer-promise-reject-errors
-      throw error;
-    }
-
-    if (context.forwardRefs.has(value as ForwardRef)) {
-      return ForwardRef.deref(value as ForwardRef) as T;
-    }
-
-    return value;
-  }
-
-  async resolveAllAsync<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options: ResolveOptions<T, A> = {}): Promise<T[]> {
-    const context: InternalResolveContext = newInternalResolveContext();
-    const values = this._resolveAll(token, argument, options, context, ResolveChain.startWith(this, token));
-
-    try {
-      await postProcessAsync(context);
-      context.$done.resolve();
-    }
-    catch (error) {
-      context.$done.reject(error); // eslint-disable-line @typescript-eslint/prefer-promise-reject-errors
-      throw error;
-    }
-
-    if (context.forwardRefs.has(values as ForwardRef)) {
-      return ForwardRef.deref(values as ForwardRef) as T[];
-    }
-
-    return values;
-  }
-
-  async resolveManyAsync<T extends ResolveManyItem<any, any>[]>(...tokens: T): Promise<ResolveManyReturnType<T>> {
-    const context: InternalResolveContext = newInternalResolveContext();
-    const values = this._resolveManyTokens(tokens, context);
-
-    try {
-      await postProcessAsync(context);
-      context.$done.resolve();
-    }
-    catch (error) {
-      context.$done.reject(error); // eslint-disable-line @typescript-eslint/prefer-promise-reject-errors
-      throw error;
-    }
-
-    return values.map(
-      (value): unknown => context.forwardRefs.has(value as ForwardRef)
-        ? ForwardRef.deref(value as ForwardRef)
-        : value
-    ) as ResolveManyReturnType<T>;
-  }
-
-  private _resolveManyTokens<T extends ResolveManyItem<any, any>[]>(tokens: T, context: InternalResolveContext): ResolveManyReturnType<T> {
-    return tokens.map(
-      (token) => (
-        isArray(token)
-          ? this._resolve(token[0], token[1], token[2] ?? {}, context, ResolveChain.startWith(this, token[0]))
-          : this._resolve(token, undefined, {}, context, ResolveChain.startWith(this, token))
-      ) as ResolveManyItemReturnType<any>
-    ) as ResolveManyReturnType<T>;
-  }
-
-  private _resolve<T, A>(token: InjectionToken<T, A>, argument: ResolveArgument<T, A>, options: ResolveOptions<T, A>, context: InternalResolveContext, chain: ResolveChain): T | undefined {
-    this.assertNotDisposed();
-
-    const skipSelf = Number(options.skipSelf ?? 0);
-
-    if (skipSelf > 0) {
-      if (isNull(this.#parent) && (options.optional != true)) {
-        throw new ResolveError(`No parent injector available.`, chain);
-      }
-
-      return this.#parent?._resolve(token, argument, { ...options, skipSelf: skipSelf - 1 }, context, chain);
-    }
-
-    if (isDefined(options.forwardRef) && (options.forwardRef != false)) {
-      assert(options.optional != true, 'ForwardRef does not support optional without resolveAll/injectAll as undefined is not forwardable.');
-
-      const forwardToken = isFunction(options.forwardRef) ? options.forwardRef() : token;
-      const forwardRef = ForwardRef.create<object>({ typeHint: options.forwardRefTypeHint ?? isFunction(forwardToken) ? forwardToken as AbstractConstructor : undefined });
-
-      context.forwardRefQueue.add(() => ForwardRef.setRef(forwardRef, this._resolve(forwardToken, argument, { ...options, forwardRef: false }, context, chain.markAsForwardRef(forwardToken)) as object));
-      context.forwardRefs.add(forwardRef);
-
-      return forwardRef as T;
-    }
-
-    if (isUndefined(token)) {
-      throw new ResolveError('Token is undefined. This might be due to a circular dependency. Consider using an alias or forwardRef.', chain);
-    }
-
-    const registration = this.tryGetRegistration(token, options);
-
-    if (isDefined(registration)) {
-      const singleRegistration = isArray(registration) ? registration[0]! : registration;
-      return this._resolveRegistration(singleRegistration, argument, options, context, chain);
-    }
-
-    if ((options.onlySelf != true) && isNotNull(this.#parent)) {
-      return this.#parent._resolve(token, argument, options, context, chain);
-    }
-
-    if (options.optional == true) {
-      return undefined;
-    }
-
-    throw new ResolveError(`No provider for ${getTokenName(token)} registered.`, chain);
-  }
-
-  private _resolveAll<T, A>(token: InjectionToken<T, A>, argument: ResolveArgument<T, A>, options: ResolveOptions<T, A>, context: InternalResolveContext, chain: ResolveChain): T[] {
-    this.assertNotDisposed();
-
-    const skipSelf = Number(options.skipSelf ?? 0);
-
-    if (skipSelf > 0) {
-      if (isNull(this.#parent) && (options.optional != true)) {
-        throw new ResolveError(`No parent injector available.`, chain);
-      }
-
-      return this.#parent?._resolveAll(token, argument, { ...options, skipSelf: skipSelf - 1 }, context, chain) ?? [];
-    }
-
-    if (isDefined(options.forwardRef) && (options.forwardRef != false)) {
-      const forwardToken = isFunction(options.forwardRef) ? options.forwardRef() : token;
-      const forwardRef = ForwardRef.create<T[]>({ typeHint: options.forwardRefTypeHint ?? isFunction(forwardToken) ? forwardToken as AbstractConstructor : undefined });
-
-      context.forwardRefQueue.add(() => ForwardRef.setRef(forwardRef, this._resolveAll(forwardToken, argument, { ...options, forwardRef: false }, context, chain.markAsForwardRef(forwardToken))));
-      context.forwardRefs.add(forwardRef);
-
-      return forwardRef as T[];
-    }
-
-    if (isUndefined(token)) {
-      throw new ResolveError('Token is undefined. This might be due to a circular dependency. Consider using an alias or forwardRef.', chain);
-    }
-
-    const registration = this.tryGetRegistration(token);
-
-    if (isDefined(registration)) {
-      const registrations = isArray(registration) ? registration : [registration];
-      return registrations.map((reg) => this._resolveRegistration(reg, argument, options, context, chain));
-    }
-
-    if ((options.onlySelf != true) && isNotNull(this.#parent)) {
-      return this.#parent._resolveAll(token, argument, { ...options, skipSelf: false }, context, chain);
-    }
-
-    if (options.optional == true) {
-      return [];
-    }
-
-    throw new ResolveError(`No provider for ${getTokenName(token)} registered.`, chain);
-  }
-
-  private _resolveRegistration<T, A>(registration: Registration<T, A>, argument: ResolveArgument<T, A>, options: ResolveOptions<T, A>, context: InternalResolveContext, chain: ResolveChain): T {
-    checkOverflow(chain, context);
-
-    const { token, provider, providers } = registration;
-
-    const resolutionTag = Symbol('ResolutionTag');
-    const resolutionScoped = registration.options.lifecycle == 'resolution';
-    const injectorScoped = registration.options.lifecycle == 'injector';
-    const singletonScoped = registration.options.lifecycle == 'singleton';
-
-    let resolveArgument = argument ?? registration.options.defaultArgument;
-
-    if (isUndefined(resolveArgument) && isFunction(registration.options.defaultArgumentProvider)) {
-      resolveArgument = wrapInResolveError(() => registration.options.defaultArgumentProvider!(this.getResolveContext(resolutionTag, context, chain)), 'Error in defaultArgumentProvider', chain);
-    }
-
-    const argumentIdentity = resolveArgumentIdentity(registration, resolveArgument, chain);
-
-    if (resolutionScoped && context.resolutionScopedResolutions.hasFlat(token, argumentIdentity)) {
-      return context.resolutionScopedResolutions.getFlat(token, argumentIdentity)!.value as T;
-    }
-    else if (injectorScoped && this.#injectorScopedResolutions.hasFlat(token, argumentIdentity)) {
-      return this.#injectorScopedResolutions.getFlat(token, argumentIdentity)!.value as T;
-    }
-    else if (singletonScoped && registration.resolutions.has(argumentIdentity)) {
-      return registration.resolutions.get(argumentIdentity)!;
-    }
-
-    // A new scope is only needed if we are instantiating a class, running a factory, or if the registration explicitly defines scoped providers.
-    const needsNewScope = isClassProvider(provider) || isFactoryProvider(provider) || (providers.length > 0);
-    const injector = needsNewScope ? this.fork(`[${getTokenName(token)}]Injector`) : this;
-
-    for (const nestedProvider of providers) {
-      injector.registerSingleton(nestedProvider.provide, nestedProvider, { multi: nestedProvider.multi });
-    }
-
-    const injectionContext = injector.getInjectionContext(context, resolveArgument, chain);
-    const previousInjectionContext = setCurrentInjectionContext(injectionContext);
-
-    try {
-      const resolutionContext: ResolutionContext<A> = { afterResolveRegistrations: [] };
-
-      const value = injector._resolveProvider(resolutionTag, registration, resolveArgument, options, context, resolutionContext, injectionContext, chain);
-
-      const resolution: Resolution<T, A> = {
-        tag: resolutionTag,
-        registration,
-        value,
-        argument: injectionContext.argument as ResolveArgument<T, A>,
-        afterResolveRegistrations: resolutionContext.afterResolveRegistrations,
-        afterResolveContext: injector.getAfterResolveContext(resolutionTag, context),
-        chain,
-      };
-
-      context.resolutions.push(resolution);
-
-      if (resolutionScoped) {
-        context.resolutionScopedResolutions.setFlat(token, argumentIdentity, resolution);
-      }
-
-      if (injectorScoped) {
-        this.#injectorScopedResolutions.setFlat(token, argumentIdentity, resolution);
-      }
-
-      if (singletonScoped) {
-        registration.resolutions.set(argumentIdentity, value);
-      }
-
-      return value;
-    }
-    finally {
-      setCurrentInjectionContext(previousInjectionContext);
-    }
-  }
-
-  private _resolveProvider<T, A>(resolutionTag: ResolutionTag, registration: Registration<T, A>, resolveArgument: ResolveArgument<T, A>, options: ResolveOptions<T, A>, context: InternalResolveContext, resolutionContext: ResolutionContext<A>, injectionContext: InjectionContext, chain: ResolveChain): T {
-    try {
-      setResolving(this, registration.token, context, chain);
-
-      const { provider } = registration;
-      let result: { value: T } | undefined;
-
-      if (isClassProvider(provider)) {
-        const typeMetadata = reflectionRegistry.getMetadata(provider.useClass);
-        const arg = resolveArgument ?? provider.defaultArgument ?? provider.defaultArgumentProvider?.();
-        injectionContext.argument = arg;
-
-        if ((provider.useClass.length > 0) && (isUndefined(typeMetadata) || !typeMetadata.data.has(injectableMetadataSymbol))) {
-          throw new ResolveError(`${provider.useClass.name} has constructor parameters but is not decorated with @Injectable.`, chain);
-        }
-
-        const parameters = (typeMetadata?.parameters ?? []).map((metadata): unknown => this.resolveClassInjection(resolutionTag, context, provider.useClass, metadata, arg, chain));
-        const value = wrapInResolveError(() => runInResolutionContext(resolutionContext, () => Reflect.construct(provider.useClass, parameters)), `Error during construction of '${provider.useClass.name}'`, chain);
-        result = { value };
-      }
-      else if (isValueProvider(provider)) {
-        result = { value: provider.useValue };
-      }
-      else if (isTokenProvider(provider)) {
-        const innerToken = (provider.useToken ?? provider.useTokenProvider()) as InjectionToken<T>;
-        const arg = resolveArgument ?? provider.defaultArgument ?? provider.defaultArgumentProvider?.();
-        injectionContext.argument = arg;
-
-        if (provider.resolveAll == true) {
-          return this._resolveAll<T, A>(innerToken, arg, options, context, chain.addToken(this, innerToken)) as T;
-        }
-
-        result = { value: this._resolve<T, A>(innerToken, arg, options, context, chain.addToken(this, innerToken))! };
-      }
-      else if (isFactoryProvider<T, A>(provider)) {
-        const arg = resolveArgument ?? provider.defaultArgument ?? provider.defaultArgumentProvider?.();
-        injectionContext.argument = arg;
-
-        const value = wrapInResolveError(() => runInResolutionContext(resolutionContext, () => provider.useFactory(arg, this.getResolveContext(resolutionTag, context, chain))), 'Error in provider factory', chain);
-        result = { value };
-      }
-      else {
-        throw new Error('Unsupported provider.');
-      }
-
-      if (isSyncOrAsyncDisposable(result.value) && !this.#disposableStackRegistrations.has(result.value)) {
-        this.#disposableStack.use(result.value);
-        this.#disposableStackRegistrations.add(result.value);
-      }
-
-      return result.value;
-    }
-    finally {
-      deleteResolving(this, registration.token, context);
-    }
-  }
-
-  private resolveClassInjection(resolutionTag: ResolutionTag, context: InternalResolveContext, constructor: Constructor, metadata: ConstructorParameterMetadata, resolveArgument: any, chain: ResolveChain): unknown {
-    const getChain = (injectToken: InjectionToken): ResolveChain => chain.addParameter(this, constructor, metadata.index, injectToken);
-    const injectMetadata: InjectMetadata = metadata.data.tryGet(injectMetadataSymbol) ?? {};
-    const injectToken = (injectMetadata.injectToken ?? metadata.type)!;
-
-    if (isDefined(injectMetadata.injectArgumentMapper) && (!this.hasRegistration(injectToken) || isDefined(resolveArgument) || isUndefined(injectToken))) {
-      return wrapInResolveError(() => injectMetadata.injectArgumentMapper!(resolveArgument), 'Error in injectArgumentMapper', getChain(injectToken));
-    }
-
-    const parameterResolveArgument = wrapInResolveError(
-      () => injectMetadata.forwardArgumentMapper?.(resolveArgument) ?? injectMetadata.resolveArgumentProvider?.(this.getResolveContext(resolutionTag, context, getChain(injectToken))),
-      'Error in parameter argument provider (forwardArgumentMapper or resolveArgumentProvider)',
-      getChain(injectToken)
-    );
-
-    const { forwardRef } = injectMetadata;
-
-    if (isDefined(forwardRef) && isDefined(injectMetadata.mapper)) {
-      const forwardToken = isFunction(forwardRef) ? forwardRef() : isBoolean(forwardRef) ? injectToken : forwardRef;
-      throw new ResolveError('Cannot use inject mapper with forwardRef.', getChain(forwardToken));
-    }
-
-    const resolveFn = (injectMetadata.resolveAll == true) ? '_resolveAll' : '_resolve';
-    const resolved = this[resolveFn](injectToken, parameterResolveArgument, { optional: injectMetadata.optional, forwardRef, forwardRefTypeHint: injectMetadata.forwardRefTypeHint }, context, getChain(injectToken));
-
-    if (isDefined(injectMetadata.mapper)) {
-      return wrapInResolveError(() => injectMetadata.mapper!(resolved), 'Error in inject mapper', getChain(injectToken));
-    }
-    return resolved;
-  }
-
-  private resolveInjection<T, A>(token: InjectionToken<T>, argument: ResolveArgument<T, A>, options: InjectOptions<T, A>, context: InternalResolveContext, injectIndex: number, chain: ResolveChain): T {
-    return this._resolve(token, argument, options, context, chain.addInject(this, token, injectIndex))!;
-  }
-
-  private async resolveInjectionAsync<T, A>(token: InjectionToken<T>, argument: ResolveArgument<T, A>, options: InjectOptions<T, A>, context: InternalResolveContext, injectIndex: number, chain: ResolveChain): Promise<T> {
-    const value = this.resolveInjection(token, argument, options, context, injectIndex, chain);
-    await context.$done;
-
-    return value;
-  }
-
-  private resolveInjectionAll<T, A>(token: InjectionToken<T>, argument: ResolveArgument<T, A>, options: InjectOptions<T, A>, context: InternalResolveContext, injectIndex: number, chain: ResolveChain): T[] {
-    return this._resolveAll(token, argument, options, context, chain.addInject(this, token, injectIndex));
-  }
-
-  private async resolveInjectionAllAsync<T, A>(token: InjectionToken<T>, argument: ResolveArgument<T, A>, options: InjectOptions<T, A>, context: InternalResolveContext, injectIndex: number, chain: ResolveChain): Promise<T[]> {
-    const values = this.resolveInjectionAll(token, argument, options, context, injectIndex, chain);
-    await context.$done;
-
-    return values;
-  }
-
-  private getResolveContext(resolutionTag: ResolutionTag, resolveContext: InternalResolveContext, chain: ResolveChain): ResolveContext<any> {
-    return {
-      resolve: (token, argument, options) => this._resolve(token, argument, options ?? {}, resolveContext, chain.addToken(this, token)),
-      resolveAll: (token, argument, options) => this._resolveAll(token, argument, options ?? {}, resolveContext, chain.addToken(this, token)),
-      cancellationSignal: this.#disposeToken,
-      addDisposeHandler: this.#addDisposeHandler,
-      get data() {
-        return resolveContext.resolutionContextData.get(resolutionTag);
-      },
-    };
-  }
-
-  private getAfterResolveContext(resolutionTag: ResolutionTag, resolveContext: InternalResolveContext): AfterResolveContext<any> {
-    return {
-      cancellationSignal: this.#disposeToken,
-      addDisposeHandler: this.#addDisposeHandler,
-      get data() {
-        return resolveContext.resolutionContextData.get(resolutionTag);
-      },
-    };
-  }
-
-  private getInjectionContext(resolveContext: InternalResolveContext, resolveArgument: any, chain: ResolveChain): InjectionContext {
-    let injectIndex = 0;
-    return {
-      injector: this,
-      argument: resolveArgument,
-      inject: (token, argument, options) => this.resolveInjection(token, argument, options ?? {}, resolveContext, injectIndex++, chain),
-      injectAll: (token, argument, options) => this.resolveInjectionAll(token, argument, options ?? {}, resolveContext, injectIndex++, chain),
-      injectMany: (...tokens) => this.resolveMany(...tokens),
-      injectAsync: async (token, argument, options) => await this.resolveInjectionAsync(token, argument, options ?? {}, resolveContext, injectIndex++, chain),
-      injectAllAsync: async (token, argument, options) => await this.resolveInjectionAllAsync(token, argument, options ?? {}, resolveContext, injectIndex++, chain),
-      injectManyAsync: async (...tokens) => await this.resolveManyAsync(...tokens),
-    };
-  }
-
-  private assertNotDisposed(): void {
-    if (this.disposed) {
-      throw new Error('Injector is disposed.');
-    }
-  }
-}
-
-export function provide<T = any, A = any, D extends Record = Record>(token: InjectionToken<T, A>, provider: Provider<T, A, D> & { multi?: boolean }): ProvidersItem<T, A, D> {
-  return { provide: token, ...provider };
-}
-
-function addRegistration<T extends GlobalRegistration>(registrations: Map<InjectionToken, WritableOneOrMany<T>>, registration: T): void {
-  if (isClassProvider(registration.provider)) {
-    const injectable = reflectionRegistry.getMetadata(registration.provider.useClass)?.data.has(injectableMetadataSymbol) ?? false;
-
-    if (!injectable) {
-      throw new RegistrationError(`${registration.provider.useClass.name} is not decorated with Injectable and cannot be registered.`);
-    }
-  }
-
-  const multi = registration.options.multi ?? false;
-  const existingRegistration = registrations.get(registration.token);
-  const hasExistingRegistration = isDefined(existingRegistration);
-  const existingIsMulti = hasExistingRegistration && isArray(existingRegistration);
-
-  if (hasExistingRegistration && (existingIsMulti != multi)) {
-    const tokenName = getTokenName(registration.token);
-    throw new RegistrationError(`Cannot mix multi and non-multi registrations for token: ${tokenName}.`);
-  }
-
-  if (multi && existingIsMulti) {
-    existingRegistration.push(registration);
-  }
-  else {
-    registrations.set(registration.token, multi ? [registration] : registration);
-  }
-}
-
-function newInternalResolveContext(): InternalResolveContext {
-  return {
-    resolves: 0,
-    resolving: new FactoryMap(() => new Set()),
-    resolutionScopedResolutions: new MultiKeyMap(),
-    resolutions: [],
-    resolutionContextData: new FactoryMap(() => ({})),
-    forwardRefQueue: new CircularBuffer(),
-    forwardRefs: new Set(),
-    $done: new DeferredPromise(),
-  };
-}
-
-function postProcess(context: InternalResolveContext): void {
-  for (const fn of context.forwardRefQueue.consume()) {
-    fn();
-  }
-
-  derefForwardRefs(context);
-
-  for (const resolution of context.resolutions) {
-    const { registration, value, argument, afterResolveContext, afterResolveRegistrations, chain } = resolution;
-    const provider = registration.provider;
-
-    for (const afterResolveHandler of afterResolveRegistrations) {
-      wrapInResolveError(() => {
-        const returnValue = afterResolveHandler(argument, afterResolveContext);
-        throwOnPromise(returnValue, 'registerAfterResolve()', chain);
-      }, 'Error in registered afterResolve handler', chain);
-    }
-
-    if (!isTokenProvider(provider) && isFunction((value as Resolvable | undefined)?.[afterResolve])) {
-      wrapInResolveError(() => {
-        const returnValue = (value as Resolvable)[afterResolve]!(argument, afterResolveContext);
-        throwOnPromise(returnValue, '[afterResolve] method', chain);
-      }, 'Error in [afterResolve] method', chain);
-    }
-
-    if (isProviderWithInitializer(provider)) {
-      wrapInResolveError(() => {
-        const returnValue = provider.afterResolve?.(value, argument, afterResolveContext);
-        throwOnPromise(returnValue, 'provider afterResolve handler', chain);
-      }, 'Error in providers afterResolve handler', chain);
-    }
-
-    if (isDefined(registration.options.afterResolve)) {
-      wrapInResolveError(() => {
-        const returnValue = registration.options.afterResolve!(value, argument, afterResolveContext);
-        throwOnPromise(returnValue, 'registration afterResolve handler', resolution.chain);
-      }, `Error in registration afterResolve handler`, chain);
-    }
-  }
-}
-
-async function postProcessAsync(context: InternalResolveContext): Promise<void> {
-  for (const fn of context.forwardRefQueue.consume()) {
-    fn();
-  }
-
-  derefForwardRefs(context);
-
-  for (const resolution of context.resolutions) {
-    const { registration, value, argument, afterResolveContext, afterResolveRegistrations, chain } = resolution;
-    const provider = registration.provider;
-
-    for (const afterResolveHandler of afterResolveRegistrations) {
-      await wrapInResolveErrorAsync(async () => await afterResolveHandler(argument, afterResolveContext), 'Error in registered async afterResolve handler', chain);
-    }
-    if (!isTokenProvider(provider) && isFunction((value as Resolvable | undefined)?.[afterResolve])) {
-      await wrapInResolveErrorAsync(async () => await (value as Resolvable)[afterResolve]!(argument, afterResolveContext), 'Error in async [afterResolve] method', chain);
-    }
-    if (isProviderWithInitializer(provider)) {
-      await wrapInResolveErrorAsync(async () => await provider.afterResolve?.(value, argument, afterResolveContext), 'Error in providers async afterResolve handler', chain);
-    }
-    if (isDefined(registration.options.afterResolve)) {
-      await wrapInResolveErrorAsync((): any => registration.options.afterResolve!(value, argument, afterResolveContext), 'Error in registration async afterResolve handler', chain);
-    }
-  }
-}
-
-function resolveArgumentIdentity(registration: Registration, resolveArgument: any, chain: ResolveChain): any {
-  if (isDefined(registration.options.argumentIdentityProvider) && ((registration.options.lifecycle == 'resolution') || (registration.options.lifecycle == 'singleton'))) {
-    return wrapInResolveError(() => registration.options.argumentIdentityProvider!(resolveArgument), 'Error in argumentIdentityProvider', chain);
-  }
-  return resolveArgument;
-}
-
-function setResolving(injector: Injector, token: InjectionToken, context: InternalResolveContext, chain: ResolveChain): void {
-  const resolvingSet = context.resolving.get(injector);
-
-  if (resolvingSet.has(token)) {
-    throw new ResolveError('Circular dependency detected. Use forwardRef for circular dependencies between classes.', chain);
-  }
-
-  resolvingSet.add(token);
-}
-
-function deleteResolving(injector: Injector, token: InjectionToken, context: InternalResolveContext): void {
-  context.resolving.get(injector).delete(token);
-}
-
-function throwOnPromise<T>(value: T | Promise<T>, type: string, chain: ResolveChain): asserts value is T {
-  if (isPromise(value)) {
-    throw new ResolveError(`Cannot evaluate async ${type} in a synchronous resolve. Use resolveAsync() instead.`, chain);
-  }
-}
-
-function checkOverflow(chain: ResolveChain, context: InternalResolveContext): void {
-  if ((chain.length > 100) || (++context.resolves > 7500)) {
-    throw new ResolveError('Resolve stack overflow. This may indicate a circular dependency with transient lifecycles. Consider using a scoped or singleton lifecycle, or forwardRef.', chain);
-  }
-}
-
-function derefForwardRefs(context: InternalResolveContext): void {
-  for (const resolution of context.resolutions.values()) {
-    if (isNotObject(resolution.value)) {
-      continue;
-    }
-    for (const [key, value] of objectEntries(resolution.value as Record)) {
-      if (context.forwardRefs.has(value as ForwardRef)) {
-        (resolution.value as Record)[key] = ForwardRef.deref(value);
-      }
-    }
-  }
-}
-
-function wrapInResolveError<T>(action: () => T, errorMessage: string, chain: ResolveChain): T {
-  try {
-    return action();
-  }
-  catch (error) {
-    if (error instanceof ResolveError) {
-      throw error;
-    }
-
-    throw new ResolveError(errorMessage, chain, error as Error);
-  }
-}
-
-async function wrapInResolveErrorAsync<T>(action: () => T | Promise<T>, errorMessage: string, chain: ResolveChain): Promise<T> {
-  try {
-    return await action();
-  }
-  catch (error) {
-    if (error instanceof ResolveError) {
-      throw error;
-    }
-
-    throw new ResolveError(errorMessage, chain, error as Error);
-  }
-}