@tstdl/base 0.86.0-beta2 → 0.86.0-beta4

package/.eslintrc.json

@@ -26,6 +26,7 @@
   "rules": {
     /** typescript */
     "@typescript-eslint/brace-style": ["error", "stroustrup", { "allowSingleLine": true }],
+    "@typescript-eslint/class-methods-use-this": ["error", { "ignoreOverrideMethods": true, "ignoreClassesThatImplementAnInterface": true }],
     "@typescript-eslint/consistent-type-definitions": "off",
     "@typescript-eslint/explicit-function-return-type": ["error", { "allowExpressions": true }],
     "@typescript-eslint/explicit-member-accessibility": ["error", { "accessibility": "no-public" }],

package/__container/decorators.d.ts

@@ -0,0 +1,2 @@
+export { ForwardArg as forwardArg, ForwardRef as forwardRef, Inject as inject, InjectArg as injectArg, Injectable as injectable, Optional as optional, ReplaceClass as replaceClass, ResolveArg as resolveArg, ResolveArgProvider as resolveArgProvider, Scoped as scoped, Singleton as singleton } from '../injector/decorators.js';
+export type { InjectableOptionsWithoutLifecycle } from '../injector/decorators.js';

package/__container/decorators.js

@@ -0,0 +1,34 @@
+"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 decorators_exports = {};
+__export(decorators_exports, {
+  forwardArg: () => import_decorators.ForwardArg,
+  forwardRef: () => import_decorators.ForwardRef,
+  inject: () => import_decorators.Inject,
+  injectArg: () => import_decorators.InjectArg,
+  injectable: () => import_decorators.Injectable,
+  optional: () => import_decorators.Optional,
+  replaceClass: () => import_decorators.ReplaceClass,
+  resolveArg: () => import_decorators.ResolveArg,
+  resolveArgProvider: () => import_decorators.ResolveArgProvider,
+  scoped: () => import_decorators.Scoped,
+  singleton: () => import_decorators.Singleton
+});
+module.exports = __toCommonJS(decorators_exports);
+var import_decorators = require("../injector/decorators.js");

package/__container/index.d.ts

@@ -0,0 +1,3 @@
+export * from './decorators.js';
+export * from './interfaces.js';
+export * from './token.js';

package/__container/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var container_exports = {};
+module.exports = __toCommonJS(container_exports);
+__reExport(container_exports, require("./decorators.js"), module.exports);
+__reExport(container_exports, require("./interfaces.js"), module.exports);
+__reExport(container_exports, require("./token.js"), module.exports);

package/__container/interfaces.d.ts

@@ -0,0 +1,2 @@
+export { afterResolve, resolveArgumentType } from '../injector/interfaces.js';
+export type { AfterResolve, Resolvable as Injectable, ResolveArgument as InjectableArgument } from '../injector/interfaces.js';

package/__container/interfaces.js

@@ -0,0 +1,25 @@
+"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 interfaces_exports = {};
+__export(interfaces_exports, {
+  afterResolve: () => import_interfaces.afterResolve,
+  resolveArgumentType: () => import_interfaces.resolveArgumentType
+});
+module.exports = __toCommonJS(interfaces_exports);
+var import_interfaces = require("../injector/interfaces.js");

package/__container/token.d.ts

@@ -0,0 +1,2 @@
+export { ReifyingInjectionToken, getTokenName, injectionToken } from '../injector/token.js';
+export type { ArgumentedInjectionToken, InjectionToken, SimpleInjectionToken } from '../injector/token.js';

package/__container/token.js

@@ -0,0 +1,26 @@
+"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 token_exports = {};
+__export(token_exports, {
+  ReifyingInjectionToken: () => import_token.ReifyingInjectionToken,
+  getTokenName: () => import_token.getTokenName,
+  injectionToken: () => import_token.injectionToken
+});
+module.exports = __toCommonJS(token_exports);
+var import_token = require("../injector/token.js");

package/_container/container.js

@@ -0,0 +1,443 @@
+"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();