ditox 3.1.0 → 3.3.0

package/dist/index.umd.js

@@ -0,0 +1,524 @@
+(function(global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ?  factory(exports) :
+  typeof define === 'function' && define.amd ? define(['exports'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.Ditox = {})));
+})(this, function(exports) {
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region src/tokens.ts
+	function token(options) {
+		const normalized = typeof options === "string" ? { description: options } : options;
+		return { symbol: (normalized === null || normalized === void 0 ? void 0 : normalized.key) ? Symbol.for(normalized.key) : Symbol(normalized === null || normalized === void 0 ? void 0 : normalized.description) };
+	}
+	function optional(token, optionalValue) {
+		return {
+			symbol: token.symbol,
+			isOptional: true,
+			optionalValue
+		};
+	}
+
+//#endregion
+//#region src/container.ts
+/**
+	* ResolverError is thrown by the resolver when a token is not found in a container.
+	*/
+	var ResolverError = class extends Error {
+		constructor(message) {
+			super(message);
+			Object.setPrototypeOf(this, new.target.prototype);
+			this.name = "ResolverError";
+		}
+	};
+	/** @internal */
+	const CONTAINER = token("ditox.Container");
+	/** @internal */
+	const PARENT_CONTAINERS = token("ditox.ParentContainer");
+	/** @internal */
+	const RESOLVER = token("ditox.Resolver");
+	/** @internal */
+	const NOT_FOUND = Symbol();
+	/** @internal */
+	const DEFAULT_SCOPE = "singleton";
+	/** @internal */
+	const FACTORIES_MAP = token("ditox.FactoriesMap");
+	/** @internal */
+	function getScope(options) {
+		var _options$scope;
+		return (_options$scope = options === null || options === void 0 ? void 0 : options.scope) !== null && _options$scope !== void 0 ? _options$scope : DEFAULT_SCOPE;
+	}
+	/** @internal */
+	function getOnRemoved(options) {
+		return options.scope === void 0 || options.scope === "scoped" || options.scope === "singleton" ? options.onRemoved : void 0;
+	}
+	/** @internal */
+	function isInternalToken(token) {
+		return token.symbol === CONTAINER.symbol || token.symbol === PARENT_CONTAINERS.symbol || token.symbol === RESOLVER.symbol;
+	}
+	/**
+	* Creates a new dependency container.
+	*
+	* Container can have an optional parent to chain token resolution. The parent is used in case the current container does not have a registered token.
+	*
+	* @param parentArg - Optional parent container or an array of containers.
+	*/
+	function createContainer(parentArg) {
+		const parents = parentArg ? Array.isArray(parentArg) ? [...parentArg] : [parentArg] : void 0;
+		const values = /* @__PURE__ */ new Map();
+		const factories = /* @__PURE__ */ new Map();
+		const container = {
+			bindValue(token, value) {
+				if (isInternalToken(token)) return;
+				values.set(token.symbol, value);
+			},
+			bindFactory(token, factory, options) {
+				if (isInternalToken(token)) return;
+				factories.set(token.symbol, {
+					factory,
+					options
+				});
+			},
+			remove(token) {
+				var _factories$get;
+				if (isInternalToken(token)) return;
+				const options = (_factories$get = factories.get(token.symbol)) === null || _factories$get === void 0 ? void 0 : _factories$get.options;
+				if (options) executeOnRemoved(token.symbol, options);
+				values.delete(token.symbol);
+				factories.delete(token.symbol);
+			},
+			removeAll() {
+				factories.forEach((context, tokenSymbol) => {
+					if (context.options) executeOnRemoved(tokenSymbol, context.options);
+				});
+				values.clear();
+				factories.clear();
+				bindInternalTokens();
+			},
+			hasToken(token) {
+				return values.has(token.symbol) || factories.has(token.symbol) || parentContainersHaveToken(parents, token);
+			},
+			get(token) {
+				const value = resolver(token, container);
+				if (value !== NOT_FOUND) return value;
+				if (token.isOptional) return token.optionalValue;
+			},
+			resolve(token) {
+				var _token$symbol$descrip;
+				const value = resolver(token, container);
+				if (value !== NOT_FOUND) return value;
+				if (token.isOptional) return token.optionalValue;
+				throw new ResolverError(`Token "${(_token$symbol$descrip = token.symbol.description) !== null && _token$symbol$descrip !== void 0 ? _token$symbol$descrip : ""}" is not provided`);
+			}
+		};
+		function resolver(token, origin) {
+			const value = values.get(token.symbol);
+			const hasValue = value !== void 0 || values.has(token.symbol);
+			if (hasValue && origin === container) return value;
+			const factoryContext = factories.get(token.symbol);
+			if (factoryContext) switch (getScope(factoryContext.options)) {
+				case "singleton": if (hasValue) return value;
+				else if (parentContainersHaveToken(parents, token)) break;
+				else {
+					const value = factoryContext.factory(container);
+					container.bindValue(token, value);
+					return value;
+				}
+				case "scoped": if (hasValue) return value;
+				else {
+					const value = factoryContext.factory(container);
+					container.bindValue(token, value);
+					return value;
+				}
+				case "transient": return factoryContext.factory(origin);
+			}
+			if (hasValue) return value;
+			if (parents) return parentContainersResolveToken(parents, token, origin);
+			return NOT_FOUND;
+		}
+		function executeOnRemoved(tokenSymbol, options) {
+			const onRemoved = getOnRemoved(options);
+			if (onRemoved) {
+				const value = values.get(tokenSymbol);
+				if (value !== void 0 || values.has(tokenSymbol)) onRemoved(value);
+			}
+		}
+		function bindInternalTokens() {
+			values.set(CONTAINER.symbol, container);
+			values.set(RESOLVER.symbol, resolver);
+			values.set(FACTORIES_MAP.symbol, factories);
+			if (parents) values.set(PARENT_CONTAINERS.symbol, parents);
+		}
+		bindInternalTokens();
+		return container;
+	}
+	function parentContainersHaveToken(parents, token) {
+		if (!parents) return false;
+		for (let i = 0; i < parents.length; i++) if (parents[i].hasToken(token)) return true;
+		return false;
+	}
+	function parentContainersResolveToken(parents, token, origin) {
+		for (const parentContainer of parents) {
+			const parentResolver = parentContainer.get(RESOLVER);
+			if (parentResolver) {
+				const resolved = parentResolver(token, origin);
+				if (resolved !== NOT_FOUND) return resolved;
+			}
+		}
+		return NOT_FOUND;
+	}
+
+//#endregion
+//#region src/utils.ts
+/**
+	* Checks if a value is the token
+	*/
+	function isToken(value) {
+		return value !== void 0 && value !== null && typeof value === "object" && "symbol" in value && typeof value.symbol === "symbol";
+	}
+	/**
+	* Rebinds the array by the token with added new value.
+	* @param container - Dependency container.
+	* @param token - Token for an array of values.
+	* @param value - New value which is added to the end of the array.
+	*/
+	function bindMultiValue(container, token, value) {
+		var _container$get;
+		const nextValues = [...(_container$get = container.get(token)) !== null && _container$get !== void 0 ? _container$get : [], value];
+		container.bindValue(token, nextValues);
+	}
+	/**
+	* Tries to resolve a value by the provided token.
+	*
+	* If an argument is an object which has tokens as its properties,
+	* then returns an object containing resolved values as properties.
+	
+	* If a token is not found, then `undefined` value is used.
+	*
+	* @example
+	* ```ts
+	* const value = tryResolveValue(container, tokenA);
+	* console.log(value); // 1
+	*
+	* const props = tryResolveValue(container, {a: tokenA, b: tokenB});
+	* console.log(props); // {a: 1, b: 2}
+	* ```
+	*/
+	function tryResolveValue(container, token) {
+		if (isToken(token)) return container.get(token);
+		const obj = {};
+		Object.keys(token).forEach((key) => obj[key] = container.get(token[key]));
+		return obj;
+	}
+	/**
+	* Returns an array of resolved values or objects with resolved values.
+	*
+	* If an item of the array is an object which has tokens as its properties,
+	* then returns an object containing resolved values as properties.
+	
+	* If a token is not found, then `undefined` value is used.
+	*
+	* @example
+	* ```ts
+	* const items1 = tryResolveValues(container, tokenA);
+	* console.log(items1); // [1]
+	*
+	* const items2 = tryResolveValues(container, tokenA, {a: tokenA, b: tokenB});
+	* console.log(items2); // [1, {a: 1, b: 2}]
+	* ```
+	*/
+	function tryResolveValues(container, ...tokens) {
+		return tokens.map((item) => tryResolveValue(container, item));
+	}
+	/**
+	* Resolves a value by the provided token.
+	*
+	* If an argument is an object which has tokens as its properties,
+	* then returns an object containing resolved values as properties.
+	
+	* If a value is not found by the token, then `ResolverError` is thrown.
+	*
+	* @example
+	* ```ts
+	* const value = resolveValue(container, tokenA);
+	* console.log(value); // 1
+	*
+	* const props = resolveValue(container, {a: tokenA, b: tokenB});
+	* console.log(props); // {a: 1, b: 2}
+	* ```
+	*/
+	function resolveValue(container, token) {
+		if (isToken(token)) return container.resolve(token);
+		const obj = {};
+		Object.keys(token).forEach((key) => obj[key] = container.resolve(token[key]));
+		return obj;
+	}
+	/**
+	* Returns an array of resolved values or objects with resolved values.
+	*
+	* If an item of the array is an object which has tokens as its properties,
+	* then returns an object containing resolved values as properties.
+	
+	* If a token is not found, then `ResolverError` is thrown.
+	*
+	* @example
+	* ```ts
+	* const items1 = resolveValues(container, tokenA);
+	* console.log(items1); // [1]
+	*
+	* const items2 = resolveValues(container, tokenA, {a: tokenA, b: tokenB});
+	* console.log(items2); // [1, {a: 1, b: 2}]
+	* ```
+	*/
+	function resolveValues(container, ...tokens) {
+		return tokens.map((item) => resolveValue(container, item));
+	}
+	/**
+	* Decorates a factory by passing resolved values as factory arguments.
+	*
+	* If an argument is an object which has tokens as its properties,
+	* then returns an object containing resolved values as properties.
+	*
+	* @param factory - A factory.
+	* @param tokens - Tokens which correspond to factory arguments.
+	*
+	* @return Decorated factory which takes a dependency container as a single argument.
+	*/
+	function injectable(factory, ...tokens) {
+		return (container) => {
+			const values = resolveValues(container, ...tokens);
+			return factory.apply(this, values);
+		};
+	}
+	/**
+	* Decorates a class by passing resolved values as arguments to its constructor.
+	*
+	* If an argument is an object which has tokens as its properties,
+	* then returns an object containing resolved values as properties.
+	*
+	* @param constructor - Constructor of a class
+	* @param tokens - Tokens which correspond to constructor arguments
+	*
+	* @return A factory function which takes a dependency container as a single argument
+	* and returns a new created class.
+	*/
+	function injectableClass(constructor, ...tokens) {
+		return injectable((...values) => new constructor(...values), ...tokens);
+	}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.112.0/helpers/typeof.js
+	function _typeof(o) {
+		"@babel/helpers - typeof";
+		return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
+			return typeof o;
+		} : function(o) {
+			return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+		}, _typeof(o);
+	}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.112.0/helpers/toPrimitive.js
+	function toPrimitive(t, r) {
+		if ("object" != _typeof(t) || !t) return t;
+		var e = t[Symbol.toPrimitive];
+		if (void 0 !== e) {
+			var i = e.call(t, r || "default");
+			if ("object" != _typeof(i)) return i;
+			throw new TypeError("@@toPrimitive must return a primitive value.");
+		}
+		return ("string" === r ? String : Number)(t);
+	}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.112.0/helpers/toPropertyKey.js
+	function toPropertyKey(t) {
+		var i = toPrimitive(t, "string");
+		return "symbol" == _typeof(i) ? i : i + "";
+	}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.112.0/helpers/defineProperty.js
+	function _defineProperty(e, r, t) {
+		return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+			value: t,
+			enumerable: !0,
+			configurable: !0,
+			writable: !0
+		}) : e[r] = t, e;
+	}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.112.0/helpers/objectSpread2.js
+	function ownKeys(e, r) {
+		var t = Object.keys(e);
+		if (Object.getOwnPropertySymbols) {
+			var o = Object.getOwnPropertySymbols(e);
+			r && (o = o.filter(function(r) {
+				return Object.getOwnPropertyDescriptor(e, r).enumerable;
+			})), t.push.apply(t, o);
+		}
+		return t;
+	}
+	function _objectSpread2(e) {
+		for (var r = 1; r < arguments.length; r++) {
+			var t = null != arguments[r] ? arguments[r] : {};
+			r % 2 ? ownKeys(Object(t), !0).forEach(function(r) {
+				_defineProperty(e, r, t[r]);
+			}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r) {
+				Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+			});
+		}
+		return e;
+	}
+
+//#endregion
+//#region src/modules.ts
+/**
+	* Binds the dependency module to the container
+	* @param container - Dependency container.
+	* @param moduleDeclaration - Declaration of the dependency module.
+	* @param options - Options for module binding.
+	*
+	* @example
+	* ```ts
+	* bindModule(container, LOGGER_MODULE);
+	* ```
+	*/
+	function bindModule(container, moduleDeclaration, options) {
+		const rootEntry = {
+			module: moduleDeclaration,
+			options: options !== null && options !== void 0 ? options : {}
+		};
+		const bfsVisits = new Set([rootEntry]);
+		const bfsQueue = [rootEntry];
+		let bfsIndex = 0;
+		while (bfsIndex < bfsQueue.length) {
+			var _m$imports;
+			const entry = bfsQueue[bfsIndex];
+			(_m$imports = ("module" in entry ? entry.module : entry).imports) === null || _m$imports === void 0 || _m$imports.forEach((depEntry) => {
+				if (!bfsVisits.has(depEntry)) {
+					bfsVisits.add(depEntry);
+					bfsQueue.push(depEntry);
+				}
+			});
+			bfsIndex++;
+		}
+		for (let i = 0; i < bfsQueue.length; i++) {
+			var _m$beforeBinding;
+			const entry = bfsQueue[i];
+			const m = "module" in entry ? entry.module : entry;
+			(_m$beforeBinding = m.beforeBinding) === null || _m$beforeBinding === void 0 || _m$beforeBinding.call(m, container);
+		}
+		for (let i = 0; i < bfsQueue.length; i++) {
+			const entry = bfsQueue[i];
+			bindModuleEntry(container, entry);
+		}
+		for (let i = bfsQueue.length - 1; i >= 0; i--) {
+			var _m$afterBinding;
+			const entry = bfsQueue[i];
+			const m = "module" in entry ? entry.module : entry;
+			(_m$afterBinding = m.afterBinding) === null || _m$afterBinding === void 0 || _m$afterBinding.call(m, container);
+		}
+		for (let i = bfsQueue.length - 1; i >= 0; i--) {
+			const entry = bfsQueue[i];
+			const m = "module" in entry ? entry.module : entry;
+			if (m.strategy === "eager") container.resolve(m.token);
+		}
+	}
+	function bindModuleEntry(container, entry) {
+		let module;
+		let options;
+		if ("module" in entry) {
+			module = entry.module;
+			options = entry.options;
+		} else module = entry;
+		const scope = options === null || options === void 0 ? void 0 : options.scope;
+		const exportedValueTokens = /* @__PURE__ */ new Set();
+		const moduleExports = module.exports;
+		if (moduleExports) Object.keys(moduleExports).forEach((valueKey) => {
+			const valueToken = moduleExports[valueKey];
+			if (valueToken) {
+				exportedValueTokens.add(valueToken);
+				container.bindFactory(valueToken, injectable((module) => module[valueKey], module.token), { scope });
+			}
+		});
+		container.bindFactory(module.token, module.factory, {
+			scope,
+			onRemoved: (moduleInstance) => {
+				if (moduleInstance.destroy) moduleInstance.destroy();
+				exportedValueTokens.forEach((valueToken) => container.remove(valueToken));
+				exportedValueTokens.clear();
+			}
+		});
+	}
+	/**
+	* Binds dependency modules to the container
+	*
+	* @param container - Dependency container for binding
+	* @param modules - Array of module binding entries: module declaration or `{module: ModuleDeclaration, options: BindModuleOptions}` objects.
+	*/
+	function bindModules(container, modules) {
+		modules.forEach((entry) => {
+			if ("module" in entry) bindModule(container, entry.module, entry.options);
+			else bindModule(container, entry);
+		});
+	}
+	/**
+	* Declares a module binding
+	*
+	* @param declaration - a module declaration
+	* @param declaration.token - optional field
+	*
+	*  @example
+	* ```ts
+	* const LOGGER_MODULE = declareModule<LoggerModule>({
+	*   factory: (container) => {
+	*     const transport = container.resolve(TRANSPORT_TOKEN).open();
+	*     return {
+	*       logger: { log: (message) => transport.write(message) },
+	*       destroy: () => transport.close(),
+	*     }
+	*   },
+	*   exports: {
+	*     logger: LOGGER_TOKEN,
+	*   },
+	* });
+	* ```
+	*/
+	function declareModule(declaration) {
+		var _declaration$token;
+		return _objectSpread2(_objectSpread2({}, declaration), {}, { token: (_declaration$token = declaration.token) !== null && _declaration$token !== void 0 ? _declaration$token : token() });
+	}
+	/**
+	* @deprecated Use `declareModule` instead
+	*
+	* Declares bindings of several modules
+	*
+	* @param modules - module declaration entries
+	*/
+	function declareModuleBindings(modules) {
+		return declareModule({
+			factory: () => ({}),
+			imports: modules
+		});
+	}
+
+//#endregion
+exports.ResolverError = ResolverError;
+exports.bindModule = bindModule;
+exports.bindModules = bindModules;
+exports.bindMultiValue = bindMultiValue;
+exports.createContainer = createContainer;
+exports.declareModule = declareModule;
+exports.declareModuleBindings = declareModuleBindings;
+exports.injectable = injectable;
+exports.injectableClass = injectableClass;
+exports.isToken = isToken;
+exports.optional = optional;
+exports.resolveValue = resolveValue;
+exports.resolveValues = resolveValues;
+exports.token = token;
+exports.tryResolveValue = tryResolveValue;
+exports.tryResolveValues = tryResolveValues;
+});
+//# sourceMappingURL=index.umd.js.map

package/dist/index.umd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.umd.js","names":[],"sources":["../src/tokens.ts","../src/container.ts","../src/utils.ts","../src/modules.ts"],"sourcesContent":["/**\n * @ignore\n * Binding token for mandatory value\n */\nexport type RequiredToken<T> = {\n  symbol: symbol;\n  type?: T; // Anchor for Typescript type inference.\n  isOptional?: false;\n};\n\n/**\n * @ignore\n * Binding token for optional value\n */\nexport type OptionalToken<T> = {\n  symbol: symbol;\n  type?: T; // Anchor for Typescript type inference.\n  isOptional: true;\n  optionalValue: T;\n};\n\n/**\n * Binding token\n */\nexport type Token<T> = RequiredToken<T> | OptionalToken<T>;\n\n/**\n * Token options\n */\nexport type TokenOptions =\n  | {\n      /**\n       * Key for token's symbol. It allows to create shareable tokens.\n       */\n      key: string;\n\n      /** @ignore */\n      description?: undefined;\n    }\n  | {\n      /** Description for better error messages */\n      description?: string;\n\n      /** @ignore */\n      key?: undefined;\n    };\n\n/**\n * Creates a new binding token.\n * @param description - Token description for better error messages.\n */\nexport function token<T>(description?: string): Token<T>;\n/**\n * Creates a new binding token.\n * @param options - Token description for better error messages.\n */ export function token<T>(options?: TokenOptions): Token<T>;\nexport function token<T>(options?: TokenOptions | string): Token<T> {\n  const normalized: TokenOptions | undefined =\n    typeof options === 'string' ? { description: options } : options;\n\n  const symbol: symbol = normalized?.key\n    ? Symbol.for(normalized.key)\n    : Symbol(normalized?.description);\n\n  return { symbol };\n}\n\n/**\n * Decorate a token with an optional value.\n * This value is be used as default value in case a container does not have registered token.\n * @param token - Existed token.\n * @param optionalValue - Default value for the resolver.\n */\nexport function optional<T>(\n  token: Token<T>,\n  optionalValue: T,\n): OptionalToken<T>;\nexport function optional<T>(token: Token<T>): OptionalToken<T | undefined>;\nexport function optional<T>(\n  token: Token<T>,\n  optionalValue?: T,\n): OptionalToken<T | undefined> {\n  return {\n    symbol: token.symbol,\n    isOptional: true,\n    optionalValue,\n  };\n}\n","import { Token, token } from './tokens';\n\n/**\n * ResolverError is thrown by the resolver when a token is not found in a container.\n */\nexport class ResolverError extends Error {\n  constructor(message: string) {\n    super(message);\n    Object.setPrototypeOf(this, new.target.prototype);\n    this.name = 'ResolverError';\n  }\n}\n\n/**\n * @see https://github.com/mnasyrov/ditox#factory-lifetimes\n */\nexport type FactoryScope = 'scoped' | 'singleton' | 'transient';\n\n/**\n * Options for factory binding.\n *\n * `scope` types:\n *   - `singleton` - **This is the default**. The value is created and cached by the most distant parent container which owns the factory function.\n *   - `scoped` - The value is created and cached by the nearest container which owns the factory function.\n *   - `transient` - The value is created every time it is resolved.\n *\n * `scoped` and `singleton` scopes can have `onRemoved` callback. It is called when a token is removed from the container.\n */\nexport type FactoryOptions<T> =\n  | {\n      scope?: 'scoped' | 'singleton';\n      onRemoved?: (value: T) => void;\n    }\n  | {\n      scope: 'transient';\n    };\n\n/**\n * Dependency container.\n */\nexport type Container = {\n  /**\n   * Binds a value for the token\n   */\n  bindValue<T>(token: Token<T>, value: T): void;\n\n  /**\n   * Binds a factory for the token.\n   */\n  bindFactory<T>(\n    token: Token<T>,\n    factory: (container: Container) => T,\n    options?: FactoryOptions<T>,\n  ): void;\n\n  /**\n   * Checks if the token is registered in the container hierarchy.\n   */\n  hasToken(token: Token<unknown>): boolean;\n\n  /**\n   * Returns a resolved value by the token, or returns `undefined` in case the token is not found.\n   */\n  get<T>(token: Token<T>): T | undefined;\n\n  /**\n   * Returns a resolved value by the token or throws `ResolverError` in case the token is not found.\n   */\n  resolve<T>(token: Token<T>): T;\n\n  /**\n   * Removes a binding for the token.\n   */\n  remove<T>(token: Token<T>): void;\n\n  /**\n   * Removes all bindings in the container.\n   */\n  removeAll(): void;\n};\n\n/**\n * A subset of Container interface that provides read-only access to dependency resolution.\n * This type is used for parent containers to allow token resolution without exposing mutation methods.\n */\nexport type ContainerResolver = Pick<Container, 'hasToken' | 'get' | 'resolve'>;\n\n/** @internal */\nexport const CONTAINER: Token<Container> = token('ditox.Container');\n/** @internal */\nexport const PARENT_CONTAINERS: Token<ReadonlyArray<Container>> = token(\n  'ditox.ParentContainer',\n);\n/** @internal */\nexport const RESOLVER: Token<Resolver> = token('ditox.Resolver');\n\n/** @internal */\nconst NOT_FOUND = Symbol();\n\n/** @internal */\nconst DEFAULT_SCOPE: FactoryScope = 'singleton';\n\n/** @internal */\ntype FactoryContext<T> = {\n  factory: (container: Container) => T;\n  options?: FactoryOptions<T>;\n};\n\n/** @internal */\ntype ValuesMap = Map<symbol, any>;\n\n/** @internal */\nexport type FactoriesMap = Map<symbol, FactoryContext<any>>;\n\n/** @internal */\nexport const FACTORIES_MAP: Token<FactoriesMap> = token('ditox.FactoriesMap');\n\n/** @internal */\ntype Resolver = <T>(token: Token<T>, origin: Container) => T | typeof NOT_FOUND;\n\n/** @internal */\nfunction getScope<T>(options?: FactoryOptions<T>): FactoryScope {\n  return options?.scope ?? DEFAULT_SCOPE;\n}\n\n/** @internal */\nfunction getOnRemoved<T>(options: FactoryOptions<T>) {\n  return options.scope === undefined ||\n    options.scope === 'scoped' ||\n    options.scope === 'singleton'\n    ? options.onRemoved\n    : undefined;\n}\n\n/** @internal */\nfunction isInternalToken<T>(token: Token<T>): boolean {\n  return (\n    token.symbol === CONTAINER.symbol ||\n    token.symbol === PARENT_CONTAINERS.symbol ||\n    token.symbol === RESOLVER.symbol\n  );\n}\n\n/**\n * Creates a new dependency container.\n *\n * Container can have an optional parent to chain token resolution. The parent is used in case the current container does not have a registered token.\n *\n * @param parentArg - Optional parent container or an array of containers.\n */\nexport function createContainer(\n  parentArg?: ContainerResolver | ReadonlyArray<ContainerResolver>,\n): Container {\n  const parents: ReadonlyArray<ContainerResolver> | undefined = parentArg\n    ? Array.isArray(parentArg)\n      ? [...parentArg]\n      : [parentArg]\n    : undefined;\n\n  const values: ValuesMap = new Map<symbol, any>();\n  const factories: FactoriesMap = new Map<symbol, FactoryContext<any>>();\n\n  const container: Container = {\n    bindValue<T>(token: Token<T>, value: T): void {\n      if (isInternalToken(token)) {\n        return;\n      }\n\n      values.set(token.symbol, value);\n    },\n\n    bindFactory<T>(\n      token: Token<T>,\n      factory: (container: Container) => T,\n      options?: FactoryOptions<T>,\n    ): void {\n      if (isInternalToken(token)) {\n        return;\n      }\n\n      factories.set(token.symbol, { factory, options });\n    },\n\n    remove<T>(token: Token<T>): void {\n      if (isInternalToken(token)) {\n        return;\n      }\n\n      const options = factories.get(token.symbol)?.options;\n      if (options) {\n        executeOnRemoved(token.symbol, options);\n      }\n\n      values.delete(token.symbol);\n      factories.delete(token.symbol);\n    },\n\n    removeAll(): void {\n      factories.forEach((context, tokenSymbol) => {\n        if (context.options) {\n          executeOnRemoved(tokenSymbol, context.options);\n        }\n      });\n\n      values.clear();\n      factories.clear();\n      bindInternalTokens();\n    },\n\n    hasToken(token: Token<unknown>): boolean {\n      return (\n        values.has(token.symbol) ||\n        factories.has(token.symbol) ||\n        parentContainersHaveToken(parents, token)\n      );\n    },\n\n    get<T>(token: Token<T>): T | undefined {\n      const value = resolver(token, container);\n      if (value !== NOT_FOUND) {\n        return value;\n      }\n\n      if (token.isOptional) {\n        return token.optionalValue;\n      }\n\n      return undefined;\n    },\n\n    resolve<T>(token: Token<T>): T {\n      const value = resolver(token, container);\n      if (value !== NOT_FOUND) {\n        return value;\n      }\n\n      if (token.isOptional) {\n        return token.optionalValue;\n      }\n\n      throw new ResolverError(\n        `Token \"${token.symbol.description ?? ''}\" is not provided`,\n      );\n    },\n  };\n\n  function resolver<T>(\n    token: Token<T>,\n    origin: Container,\n  ): T | typeof NOT_FOUND {\n    const value = values.get(token.symbol);\n    const hasValue = value !== undefined || values.has(token.symbol);\n\n    if (hasValue && origin === container) {\n      return value;\n    }\n\n    const factoryContext = factories.get(token.symbol);\n    if (factoryContext) {\n      const scope = getScope(factoryContext.options);\n\n      switch (scope) {\n        case 'singleton': {\n          if (hasValue) {\n            return value;\n          } else if (parentContainersHaveToken(parents, token)) {\n            break;\n          } else {\n            // Cache the value in the same container where the factory is registered.\n            const value = factoryContext.factory(container);\n            container.bindValue(token, value);\n            return value;\n          }\n        }\n\n        case 'scoped': {\n          if (hasValue) {\n            return value;\n          } else {\n            // Create a value within the factory's container and cache it.\n            const value = factoryContext.factory(container);\n            container.bindValue(token, value);\n            return value;\n          }\n        }\n\n        case 'transient': {\n          // Create a value within the origin container and don't cache it.\n          return factoryContext.factory(origin);\n        }\n      }\n    }\n\n    if (hasValue) {\n      return value;\n    }\n\n    if (parents) {\n      return parentContainersResolveToken(parents, token, origin);\n    }\n\n    return NOT_FOUND;\n  }\n\n  function executeOnRemoved<T>(\n    tokenSymbol: symbol,\n    options: FactoryOptions<T>,\n  ) {\n    const onRemoved = getOnRemoved(options);\n    if (onRemoved) {\n      const value = values.get(tokenSymbol);\n      if (value !== undefined || values.has(tokenSymbol)) {\n        onRemoved(value);\n      }\n    }\n  }\n\n  function bindInternalTokens() {\n    values.set(CONTAINER.symbol, container);\n    values.set(RESOLVER.symbol, resolver);\n    values.set(FACTORIES_MAP.symbol, factories);\n\n    if (parents) {\n      values.set(PARENT_CONTAINERS.symbol, parents);\n    }\n  }\n\n  bindInternalTokens();\n  return container;\n}\n\nfunction parentContainersHaveToken<T>(\n  parents: ReadonlyArray<ContainerResolver> | undefined,\n  token: Token<T>,\n): boolean {\n  if (!parents) return false;\n\n  for (let i = 0; i < parents.length; i++) {\n    if (parents[i].hasToken(token)) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\nfunction parentContainersResolveToken<T>(\n  parents: ReadonlyArray<ContainerResolver>,\n  token: Token<T>,\n  origin: Container,\n): T | typeof NOT_FOUND {\n  for (const parentContainer of parents) {\n    const parentResolver = parentContainer.get(RESOLVER);\n    if (parentResolver) {\n      const resolved = parentResolver(token, origin);\n      if (resolved !== NOT_FOUND) {\n        return resolved;\n      }\n    }\n  }\n\n  return NOT_FOUND;\n}\n","import type { Container } from './container';\nimport { Token } from './tokens';\n\ntype ValuesProps = { [key: string]: unknown };\ntype TokenProps<Props extends ValuesProps> = {\n  [K in keyof Props]: Token<Props[K]>;\n};\n\n/**\n * Checks if a value is the token\n */\nexport function isToken<T>(value: unknown): value is Token<T> {\n  return (\n    value !== undefined &&\n    value !== null &&\n    typeof value === 'object' &&\n    'symbol' in value &&\n    typeof (value as any).symbol === 'symbol'\n  );\n}\n\n/**\n * Rebinds the array by the token with added new value.\n * @param container - Dependency container.\n * @param token - Token for an array of values.\n * @param value - New value which is added to the end of the array.\n */\nexport function bindMultiValue<T>(\n  container: Container,\n  token: Token<ReadonlyArray<T>>,\n  value: T,\n): void {\n  const prevValues = container.get(token) ?? [];\n  const nextValues = [...prevValues, value];\n  container.bindValue(token, nextValues);\n}\n\n/**\n * Tries to resolve a value by the provided token.\n *\n * If an argument is an object which has tokens as its properties,\n * then returns an object containing resolved values as properties.\n\n * If a token is not found, then `undefined` value is used.\n *\n * @example\n * ```ts\n * const value = tryResolveValue(container, tokenA);\n * console.log(value); // 1\n *\n * const props = tryResolveValue(container, {a: tokenA, b: tokenB});\n * console.log(props); // {a: 1, b: 2}\n * ```\n */\nexport function tryResolveValue<\n  Tokens extends Token<unknown> | { [key: string]: Token<unknown> },\n  Values extends Tokens extends Token<infer V>\n    ? V | undefined\n    : Tokens extends TokenProps<infer Props>\n      ? Partial<Props>\n      : never,\n>(container: Container, token: Tokens): Values {\n  if (isToken(token)) {\n    return container.get(token) as Values;\n  }\n\n  const obj: any = {};\n  Object.keys(token).forEach((key) => (obj[key] = container.get(token[key])));\n  return obj;\n}\n\n/**\n * Returns an array of resolved values or objects with resolved values.\n *\n * If an item of the array is an object which has tokens as its properties,\n * then returns an object containing resolved values as properties.\n\n * If a token is not found, then `undefined` value is used.\n *\n * @example\n * ```ts\n * const items1 = tryResolveValues(container, tokenA);\n * console.log(items1); // [1]\n *\n * const items2 = tryResolveValues(container, tokenA, {a: tokenA, b: tokenB});\n * console.log(items2); // [1, {a: 1, b: 2}]\n * ```\n */\nexport function tryResolveValues<\n  Tokens extends (Token<unknown> | { [key: string]: Token<unknown> })[],\n  Values extends {\n    [K in keyof Tokens]: Tokens[K] extends Token<infer V>\n      ? V | undefined\n      : Tokens[K] extends TokenProps<infer Props>\n        ? Partial<Props>\n        : never;\n  },\n>(container: Container, ...tokens: Tokens): Values {\n  return tokens.map((item) => tryResolveValue(container, item)) as Values;\n}\n\n/**\n * Resolves a value by the provided token.\n *\n * If an argument is an object which has tokens as its properties,\n * then returns an object containing resolved values as properties.\n\n * If a value is not found by the token, then `ResolverError` is thrown.\n *\n * @example\n * ```ts\n * const value = resolveValue(container, tokenA);\n * console.log(value); // 1\n *\n * const props = resolveValue(container, {a: tokenA, b: tokenB});\n * console.log(props); // {a: 1, b: 2}\n * ```\n */\nexport function resolveValue<\n  Tokens extends Token<unknown> | { [key: string]: Token<unknown> },\n  Values extends Tokens extends Token<infer V>\n    ? V\n    : Tokens extends TokenProps<infer Props>\n      ? Props\n      : never,\n>(container: Container, token: Tokens): Values {\n  if (isToken(token)) {\n    return container.resolve(token) as Values;\n  }\n\n  const obj: any = {};\n  Object.keys(token).forEach(\n    (key) => (obj[key] = container.resolve(token[key])),\n  );\n  return obj;\n}\n\n/**\n * Returns an array of resolved values or objects with resolved values.\n *\n * If an item of the array is an object which has tokens as its properties,\n * then returns an object containing resolved values as properties.\n\n * If a token is not found, then `ResolverError` is thrown.\n *\n * @example\n * ```ts\n * const items1 = resolveValues(container, tokenA);\n * console.log(items1); // [1]\n *\n * const items2 = resolveValues(container, tokenA, {a: tokenA, b: tokenB});\n * console.log(items2); // [1, {a: 1, b: 2}]\n * ```\n */\nexport function resolveValues<\n  Tokens extends (Token<unknown> | { [key: string]: Token<unknown> })[],\n  Values extends {\n    [K in keyof Tokens]: Tokens[K] extends Token<infer V>\n      ? V\n      : Tokens[K] extends TokenProps<infer Props>\n        ? Props\n        : never;\n  },\n>(container: Container, ...tokens: Tokens): Values {\n  return tokens.map((item) => resolveValue(container, item)) as Values;\n}\n\n/**\n * Decorates a factory by passing resolved values as factory arguments.\n *\n * If an argument is an object which has tokens as its properties,\n * then returns an object containing resolved values as properties.\n *\n * @param factory - A factory.\n * @param tokens - Tokens which correspond to factory arguments.\n *\n * @return Decorated factory which takes a dependency container as a single argument.\n */\nexport function injectable<\n  Tokens extends (Token<unknown> | { [key: string]: Token<unknown> })[],\n  Values extends {\n    [K in keyof Tokens]: Tokens[K] extends Token<infer V>\n      ? V\n      : Tokens[K] extends TokenProps<infer Props>\n        ? Props\n        : never;\n  },\n  Result,\n>(\n  this: unknown,\n  factory: (...params: Values) => Result,\n  ...tokens: Tokens\n): (container: Container) => Result {\n  return (container) => {\n    const values: Values = resolveValues(container, ...tokens);\n    return factory.apply(this, values);\n  };\n}\n\n/**\n * Decorates a class by passing resolved values as arguments to its constructor.\n *\n * If an argument is an object which has tokens as its properties,\n * then returns an object containing resolved values as properties.\n *\n * @param constructor - Constructor of a class\n * @param tokens - Tokens which correspond to constructor arguments\n *\n * @return A factory function which takes a dependency container as a single argument\n * and returns a new created class.\n */\nexport function injectableClass<\n  Tokens extends (Token<unknown> | { [key: string]: Token<unknown> })[],\n  Values extends {\n    [K in keyof Tokens]: Tokens[K] extends Token<infer V>\n      ? V\n      : Tokens[K] extends TokenProps<infer Props>\n        ? Props\n        : never;\n  },\n  Result,\n>(\n  this: unknown,\n  constructor: new (...params: Values) => Result,\n  ...tokens: Tokens\n): (container: Container) => Result {\n  return injectable<Tokens, Values, Result>(\n    (...values) => new constructor(...values),\n    ...tokens,\n  );\n}\n","import { Container } from './container';\nimport { Token, token } from './tokens';\nimport { injectable } from './utils';\n\ntype AnyObject = Record<string, any>;\ntype EmptyObject = Record<string, never>;\n\ntype ModuleController = {\n  /** Dispose the module and clean its resources */\n  destroy?: () => void;\n};\n\n/**\n * Dependency module\n *\n * @example\n * ```ts\n * type LoggerModule = Module<{\n *   logger: Logger;\n * }>;\n * ```\n */\nexport type Module<ModuleProps extends AnyObject = EmptyObject> =\n  ModuleController & ModuleProps;\n\ntype GetModuleProps<T> = T extends Module<infer Props> ? Props : never;\n\n/**\n * Description how to bind the module in declarative way.\n *\n * @example\n * ```ts\n * const LOGGER_MODULE: ModuleDeclaration<LoggerModule> = {\n *   token: LOGGER_MODULE_TOKEN,\n *   factory: (container) => {\n *     const transport = container.resolve(TRANSPORT_TOKEN).open();\n *     return {\n *       logger: { log: (message) => transport.write(message) },\n *       destroy: () => transport.close(),\n *     }\n *   },\n *   exports: {\n *     logger: LOGGER_TOKEN,\n *   },\n * };\n * ```\n */\nexport type ModuleDeclaration<T extends Module<AnyObject>> = {\n  /** Token for the module */\n  token: Token<T>;\n\n  /** Modules for binding  */\n  imports?: ReadonlyArray<ModuleBindingEntry>;\n\n  /** Factory of the module */\n  factory: (container: Container) => T;\n\n  /** Dictionary of module properties which are bound to tokens. */\n  exports?: {\n    [K in keyof GetModuleProps<T>]?: Token<GetModuleProps<T>[K]>;\n  };\n\n  /** Callback could be used to prepare an environment. It is called before binding the module. */\n  beforeBinding?: (container: Container) => void;\n\n  /** Callback could be used to export complex dependencies from the module. It is called after binding the module.  */\n  afterBinding?: (container: Container) => void;\n\n  /**\n   * Strategy for executing the factory:\n   *   - `lazy` - **This is the default**. The factory is called when the module is resolved.\n   *   - `eager` - The factory is called immediately after the module is bound to the container.\n   */\n  strategy?: 'eager' | 'lazy';\n};\n\nexport type AnyModuleDeclaration = ModuleDeclaration<Module<AnyObject>>;\n\n/**\n * Options for module binding.\n *\n * `scope` types:\n *   - `singleton` - **This is the default**. The value is created and cached by the most distant parent container which owns the factory function.\n *   - `scoped` - The value is created and cached by the nearest container which owns the factory function.\n */\nexport type BindModuleOptions = {\n  scope?: 'scoped' | 'singleton';\n};\n\ntype ModuleDeclarationWithOptions = {\n  module: ModuleDeclaration<AnyObject>;\n  options: BindModuleOptions;\n};\n\nexport type ModuleBindingEntry =\n  | ModuleDeclaration<AnyObject>\n  | ModuleDeclarationWithOptions;\n\n/**\n * Binds the dependency module to the container\n * @param container - Dependency container.\n * @param moduleDeclaration - Declaration of the dependency module.\n * @param options - Options for module binding.\n *\n * @example\n * ```ts\n * bindModule(container, LOGGER_MODULE);\n * ```\n */\nexport function bindModule<T extends Module<AnyObject>>(\n  container: Container,\n  moduleDeclaration: ModuleDeclaration<T>,\n  options?: BindModuleOptions,\n): void {\n  const rootEntry: ModuleBindingEntry = {\n    module: moduleDeclaration,\n    options: options ?? {},\n  };\n\n  const bfsVisits = new Set<ModuleBindingEntry>([rootEntry]);\n  const bfsQueue: ModuleBindingEntry[] = [rootEntry];\n\n  let bfsIndex = 0;\n  while (bfsIndex < bfsQueue.length) {\n    const entry = bfsQueue[bfsIndex];\n\n    const m = 'module' in entry ? entry.module : entry;\n\n    m.imports?.forEach((depEntry) => {\n      if (!bfsVisits.has(depEntry)) {\n        bfsVisits.add(depEntry);\n        bfsQueue.push(depEntry);\n      }\n    });\n\n    bfsIndex++;\n  }\n\n  for (let i = 0; i < bfsQueue.length; i++) {\n    const entry = bfsQueue[i];\n    const m = 'module' in entry ? entry.module : entry;\n    m.beforeBinding?.(container);\n  }\n\n  for (let i = 0; i < bfsQueue.length; i++) {\n    const entry = bfsQueue[i];\n    bindModuleEntry(container, entry);\n  }\n\n  for (let i = bfsQueue.length - 1; i >= 0; i--) {\n    const entry = bfsQueue[i];\n    const m = 'module' in entry ? entry.module : entry;\n    m.afterBinding?.(container);\n  }\n\n  for (let i = bfsQueue.length - 1; i >= 0; i--) {\n    const entry = bfsQueue[i];\n    const m = 'module' in entry ? entry.module : entry;\n    if (m.strategy === 'eager') {\n      container.resolve(m.token);\n    }\n  }\n}\n\nfunction bindModuleEntry(\n  container: Container,\n  entry: ModuleBindingEntry,\n): void {\n  let module: ModuleDeclaration<AnyObject>;\n  let options: BindModuleOptions | undefined;\n\n  if ('module' in entry) {\n    module = entry.module;\n    options = entry.options;\n  } else {\n    module = entry;\n  }\n\n  const scope = options?.scope;\n  const exportedValueTokens = new Set<Token<unknown>>();\n  const moduleExports = module.exports;\n\n  if (moduleExports) {\n    const keys = Object.keys(moduleExports);\n\n    keys.forEach((valueKey) => {\n      const valueToken = moduleExports[valueKey];\n      if (valueToken) {\n        exportedValueTokens.add(valueToken);\n\n        container.bindFactory(\n          valueToken,\n          injectable((module) => module[valueKey], module.token),\n          { scope },\n        );\n      }\n    });\n  }\n\n  container.bindFactory(module.token, module.factory, {\n    scope,\n    onRemoved: (moduleInstance) => {\n      if (moduleInstance.destroy) {\n        moduleInstance.destroy();\n      }\n\n      exportedValueTokens.forEach((valueToken) => container.remove(valueToken));\n      exportedValueTokens.clear();\n    },\n  });\n}\n\n/**\n * Binds dependency modules to the container\n *\n * @param container - Dependency container for binding\n * @param modules - Array of module binding entries: module declaration or `{module: ModuleDeclaration, options: BindModuleOptions}` objects.\n */\nexport function bindModules(\n  container: Container,\n  modules: ReadonlyArray<ModuleBindingEntry>,\n): void {\n  modules.forEach((entry) => {\n    if ('module' in entry) {\n      bindModule(container, entry.module, entry.options);\n    } else {\n      bindModule(container, entry);\n    }\n  });\n}\n\n/**\n * Declares a module binding\n *\n * @param declaration - a module declaration\n * @param declaration.token - optional field\n *\n *  @example\n * ```ts\n * const LOGGER_MODULE = declareModule<LoggerModule>({\n *   factory: (container) => {\n *     const transport = container.resolve(TRANSPORT_TOKEN).open();\n *     return {\n *       logger: { log: (message) => transport.write(message) },\n *       destroy: () => transport.close(),\n *     }\n *   },\n *   exports: {\n *     logger: LOGGER_TOKEN,\n *   },\n * });\n * ```\n */\nexport function declareModule<T extends Module<AnyObject>>(\n  declaration: Omit<ModuleDeclaration<T>, 'token'> &\n    Partial<Pick<ModuleDeclaration<T>, 'token'>>,\n): ModuleDeclaration<T> {\n  return { ...declaration, token: declaration.token ?? token() };\n}\n\n/**\n * @deprecated Use `declareModule` instead\n *\n * Declares bindings of several modules\n *\n * @param modules - module declaration entries\n */\nexport function declareModuleBindings(\n  modules: ReadonlyArray<ModuleBindingEntry>,\n): ModuleDeclaration<Module> {\n  return declareModule({\n    factory: () => ({}),\n    imports: modules,\n  });\n}\n"],"mappings":";;;;;;;;CAwDA,SAAgB,MAAS,SAA2C;EAClE,MAAM,aACJ,OAAO,YAAY,WAAW,EAAE,aAAa,SAAS,GAAG;AAM3D,SAAO,EAAE,iEAJc,WAAY,OAC/B,OAAO,IAAI,WAAW,IAAI,GAC1B,+DAAO,WAAY,YAAY,EAElB;;CAcnB,SAAgB,SACd,OACA,eAC8B;AAC9B,SAAO;GACL,QAAQ,MAAM;GACd,YAAY;GACZ;GACD;;;;;;;;CCjFH,IAAa,gBAAb,cAAmC,MAAM;EACvC,YAAY,SAAiB;AAC3B,SAAM,QAAQ;AACd,UAAO,eAAe,MAAM,IAAI,OAAO,UAAU;AACjD,QAAK,OAAO;;;;CA+EhB,MAAa,YAA8B,MAAM,kBAAkB;;CAEnE,MAAa,oBAAqD,MAChE,wBACD;;CAED,MAAa,WAA4B,MAAM,iBAAiB;;CAGhE,MAAM,YAAY,QAAQ;;CAG1B,MAAM,gBAA8B;;CAepC,MAAa,gBAAqC,MAAM,qBAAqB;;CAM7E,SAAS,SAAY,SAA2C;;AAC9D,6EAAO,QAAS,gEAAS;;;CAI3B,SAAS,aAAgB,SAA4B;AACnD,SAAO,QAAQ,UAAU,UACvB,QAAQ,UAAU,YAClB,QAAQ,UAAU,cAChB,QAAQ,YACR;;;CAIN,SAAS,gBAAmB,OAA0B;AACpD,SACE,MAAM,WAAW,UAAU,UAC3B,MAAM,WAAW,kBAAkB,UACnC,MAAM,WAAW,SAAS;;;;;;;;;CAW9B,SAAgB,gBACd,WACW;EACX,MAAM,UAAwD,YAC1D,MAAM,QAAQ,UAAU,GACtB,CAAC,GAAG,UAAU,GACd,CAAC,UAAU,GACb;EAEJ,MAAM,yBAAoB,IAAI,KAAkB;EAChD,MAAM,4BAA0B,IAAI,KAAkC;EAEtE,MAAM,YAAuB;GAC3B,UAAa,OAAiB,OAAgB;AAC5C,QAAI,gBAAgB,MAAM,CACxB;AAGF,WAAO,IAAI,MAAM,QAAQ,MAAM;;GAGjC,YACE,OACA,SACA,SACM;AACN,QAAI,gBAAgB,MAAM,CACxB;AAGF,cAAU,IAAI,MAAM,QAAQ;KAAE;KAAS;KAAS,CAAC;;GAGnD,OAAU,OAAuB;;AAC/B,QAAI,gBAAgB,MAAM,CACxB;IAGF,MAAM,4BAAU,UAAU,IAAI,MAAM,OAAO,kEAAE;AAC7C,QAAI,QACF,kBAAiB,MAAM,QAAQ,QAAQ;AAGzC,WAAO,OAAO,MAAM,OAAO;AAC3B,cAAU,OAAO,MAAM,OAAO;;GAGhC,YAAkB;AAChB,cAAU,SAAS,SAAS,gBAAgB;AAC1C,SAAI,QAAQ,QACV,kBAAiB,aAAa,QAAQ,QAAQ;MAEhD;AAEF,WAAO,OAAO;AACd,cAAU,OAAO;AACjB,wBAAoB;;GAGtB,SAAS,OAAgC;AACvC,WACE,OAAO,IAAI,MAAM,OAAO,IACxB,UAAU,IAAI,MAAM,OAAO,IAC3B,0BAA0B,SAAS,MAAM;;GAI7C,IAAO,OAAgC;IACrC,MAAM,QAAQ,SAAS,OAAO,UAAU;AACxC,QAAI,UAAU,UACZ,QAAO;AAGT,QAAI,MAAM,WACR,QAAO,MAAM;;GAMjB,QAAW,OAAoB;;IAC7B,MAAM,QAAQ,SAAS,OAAO,UAAU;AACxC,QAAI,UAAU,UACZ,QAAO;AAGT,QAAI,MAAM,WACR,QAAO,MAAM;AAGf,UAAM,IAAI,cACR,mCAAU,MAAM,OAAO,oFAAe,GAAG,mBAC1C;;GAEJ;EAED,SAAS,SACP,OACA,QACsB;GACtB,MAAM,QAAQ,OAAO,IAAI,MAAM,OAAO;GACtC,MAAM,WAAW,UAAU,UAAa,OAAO,IAAI,MAAM,OAAO;AAEhE,OAAI,YAAY,WAAW,UACzB,QAAO;GAGT,MAAM,iBAAiB,UAAU,IAAI,MAAM,OAAO;AAClD,OAAI,eAGF,SAFc,SAAS,eAAe,QAAQ,EAE9C;IACE,KAAK,YACH,KAAI,SACF,QAAO;aACE,0BAA0B,SAAS,MAAM,CAClD;SACK;KAEL,MAAM,QAAQ,eAAe,QAAQ,UAAU;AAC/C,eAAU,UAAU,OAAO,MAAM;AACjC,YAAO;;IAIX,KAAK,SACH,KAAI,SACF,QAAO;SACF;KAEL,MAAM,QAAQ,eAAe,QAAQ,UAAU;AAC/C,eAAU,UAAU,OAAO,MAAM;AACjC,YAAO;;IAIX,KAAK,YAEH,QAAO,eAAe,QAAQ,OAAO;;AAK3C,OAAI,SACF,QAAO;AAGT,OAAI,QACF,QAAO,6BAA6B,SAAS,OAAO,OAAO;AAG7D,UAAO;;EAGT,SAAS,iBACP,aACA,SACA;GACA,MAAM,YAAY,aAAa,QAAQ;AACvC,OAAI,WAAW;IACb,MAAM,QAAQ,OAAO,IAAI,YAAY;AACrC,QAAI,UAAU,UAAa,OAAO,IAAI,YAAY,CAChD,WAAU,MAAM;;;EAKtB,SAAS,qBAAqB;AAC5B,UAAO,IAAI,UAAU,QAAQ,UAAU;AACvC,UAAO,IAAI,SAAS,QAAQ,SAAS;AACrC,UAAO,IAAI,cAAc,QAAQ,UAAU;AAE3C,OAAI,QACF,QAAO,IAAI,kBAAkB,QAAQ,QAAQ;;AAIjD,sBAAoB;AACpB,SAAO;;CAGT,SAAS,0BACP,SACA,OACS;AACT,MAAI,CAAC,QAAS,QAAO;AAErB,OAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,IAClC,KAAI,QAAQ,GAAG,SAAS,MAAM,CAC5B,QAAO;AAIX,SAAO;;CAGT,SAAS,6BACP,SACA,OACA,QACsB;AACtB,OAAK,MAAM,mBAAmB,SAAS;GACrC,MAAM,iBAAiB,gBAAgB,IAAI,SAAS;AACpD,OAAI,gBAAgB;IAClB,MAAM,WAAW,eAAe,OAAO,OAAO;AAC9C,QAAI,aAAa,UACf,QAAO;;;AAKb,SAAO;;;;;;;;CC9VT,SAAgB,QAAW,OAAmC;AAC5D,SACE,UAAU,UACV,UAAU,QACV,OAAO,UAAU,YACjB,YAAY,SACZ,OAAQ,MAAc,WAAW;;;;;;;;CAUrC,SAAgB,eACd,WACA,OACA,OACM;;EAEN,MAAM,aAAa,CAAC,qBADD,UAAU,IAAI,MAAM,2DAAI,EAAE,EACV,MAAM;AACzC,YAAU,UAAU,OAAO,WAAW;;;;;;;;;;;;;;;;;;;CAoBxC,SAAgB,gBAOd,WAAsB,OAAuB;AAC7C,MAAI,QAAQ,MAAM,CAChB,QAAO,UAAU,IAAI,MAAM;EAG7B,MAAM,MAAW,EAAE;AACnB,SAAO,KAAK,MAAM,CAAC,SAAS,QAAS,IAAI,OAAO,UAAU,IAAI,MAAM,KAAK,CAAE;AAC3E,SAAO;;;;;;;;;;;;;;;;;;;CAoBT,SAAgB,iBASd,WAAsB,GAAG,QAAwB;AACjD,SAAO,OAAO,KAAK,SAAS,gBAAgB,WAAW,KAAK,CAAC;;;;;;;;;;;;;;;;;;;CAoB/D,SAAgB,aAOd,WAAsB,OAAuB;AAC7C,MAAI,QAAQ,MAAM,CAChB,QAAO,UAAU,QAAQ,MAAM;EAGjC,MAAM,MAAW,EAAE;AACnB,SAAO,KAAK,MAAM,CAAC,SAChB,QAAS,IAAI,OAAO,UAAU,QAAQ,MAAM,KAAK,CACnD;AACD,SAAO;;;;;;;;;;;;;;;;;;;CAoBT,SAAgB,cASd,WAAsB,GAAG,QAAwB;AACjD,SAAO,OAAO,KAAK,SAAS,aAAa,WAAW,KAAK,CAAC;;;;;;;;;;;;;CAc5D,SAAgB,WAYd,SACA,GAAG,QAC+B;AAClC,UAAQ,cAAc;GACpB,MAAM,SAAiB,cAAc,WAAW,GAAG,OAAO;AAC1D,UAAO,QAAQ,MAAM,MAAM,OAAO;;;;;;;;;;;;;;;CAgBtC,SAAgB,gBAYd,aACA,GAAG,QAC+B;AAClC,SAAO,YACJ,GAAG,WAAW,IAAI,YAAY,GAAG,OAAO,EACzC,GAAG,OACJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CCxHH,SAAgB,WACd,WACA,mBACA,SACM;EACN,MAAM,YAAgC;GACpC,QAAQ;GACR,SAAS,mDAAW,EAAE;GACvB;EAED,MAAM,YAAY,IAAI,IAAwB,CAAC,UAAU,CAAC;EAC1D,MAAM,WAAiC,CAAC,UAAU;EAElD,IAAI,WAAW;AACf,SAAO,WAAW,SAAS,QAAQ;;GACjC,MAAM,QAAQ,SAAS;AAIvB,kBAFU,YAAY,QAAQ,MAAM,SAAS,OAE3C,yDAAS,SAAS,aAAa;AAC/B,QAAI,CAAC,UAAU,IAAI,SAAS,EAAE;AAC5B,eAAU,IAAI,SAAS;AACvB,cAAS,KAAK,SAAS;;KAEzB;AAEF;;AAGF,OAAK,IAAI,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK;;GACxC,MAAM,QAAQ,SAAS;GACvB,MAAM,IAAI,YAAY,QAAQ,MAAM,SAAS;AAC7C,yBAAE,mFAAgB,UAAU;;AAG9B,OAAK,IAAI,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK;GACxC,MAAM,QAAQ,SAAS;AACvB,mBAAgB,WAAW,MAAM;;AAGnC,OAAK,IAAI,IAAI,SAAS,SAAS,GAAG,KAAK,GAAG,KAAK;;GAC7C,MAAM,QAAQ,SAAS;GACvB,MAAM,IAAI,YAAY,QAAQ,MAAM,SAAS;AAC7C,wBAAE,gFAAe,UAAU;;AAG7B,OAAK,IAAI,IAAI,SAAS,SAAS,GAAG,KAAK,GAAG,KAAK;GAC7C,MAAM,QAAQ,SAAS;GACvB,MAAM,IAAI,YAAY,QAAQ,MAAM,SAAS;AAC7C,OAAI,EAAE,aAAa,QACjB,WAAU,QAAQ,EAAE,MAAM;;;CAKhC,SAAS,gBACP,WACA,OACM;EACN,IAAI;EACJ,IAAI;AAEJ,MAAI,YAAY,OAAO;AACrB,YAAS,MAAM;AACf,aAAU,MAAM;QAEhB,UAAS;EAGX,MAAM,0DAAQ,QAAS;EACvB,MAAM,sCAAsB,IAAI,KAAqB;EACrD,MAAM,gBAAgB,OAAO;AAE7B,MAAI,cAGF,CAFa,OAAO,KAAK,cAAc,CAElC,SAAS,aAAa;GACzB,MAAM,aAAa,cAAc;AACjC,OAAI,YAAY;AACd,wBAAoB,IAAI,WAAW;AAEnC,cAAU,YACR,YACA,YAAY,WAAW,OAAO,WAAW,OAAO,MAAM,EACtD,EAAE,OAAO,CACV;;IAEH;AAGJ,YAAU,YAAY,OAAO,OAAO,OAAO,SAAS;GAClD;GACA,YAAY,mBAAmB;AAC7B,QAAI,eAAe,QACjB,gBAAe,SAAS;AAG1B,wBAAoB,SAAS,eAAe,UAAU,OAAO,WAAW,CAAC;AACzE,wBAAoB,OAAO;;GAE9B,CAAC;;;;;;;;CASJ,SAAgB,YACd,WACA,SACM;AACN,UAAQ,SAAS,UAAU;AACzB,OAAI,YAAY,MACd,YAAW,WAAW,MAAM,QAAQ,MAAM,QAAQ;OAElD,YAAW,WAAW,MAAM;IAE9B;;;;;;;;;;;;;;;;;;;;;;;;CAyBJ,SAAgB,cACd,aAEsB;;AACtB,2CAAY,oBAAa,6BAAO,YAAY,wEAAS,OAAO;;;;;;;;;CAU9D,SAAgB,sBACd,SAC2B;AAC3B,SAAO,cAAc;GACnB,gBAAgB,EAAE;GAClB,SAAS;GACV,CAAC"}

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "ditox",
-  "version": "3.1.0",
-  "description": "Dependency injection for modular web applications",
+  "version": "3.3.0",
+  "description": "Dependency injection for web applications",
   "license": "MIT",
   "author": "Mikhail Nasyrov <mikhail@mnasyrov.com> (https://github.com/mnasyrov)",
   "homepage": "https://github.com/mnasyrov/ditox",
   "bugs": "https://github.com/mnasyrov/ditox/issues",
   "repository": {
     "type": "git",
-    "url": "https://github.com/mnasyrov/ditox.git"
+    "url": "git+https://github.com/mnasyrov/ditox.git"
   },
   "keywords": [
     "dependency container",
@@ -26,16 +26,6 @@
   "engines": {
     "node": ">=12"
   },
-  "main": "dist/cjs/index.js",
-  "module": "dist/esm/index.js",
-  "jsnext:main": "dist/esm/index.js",
-  "unpkg": "dist/umd/index.js",
-  "umd:main": "dist/umd/index.js",
-  "browser": "dist/browser/index.js",
-  "react-native": "dist/browser/index.js",
-  "types": "dist/esm/index.d.ts",
-  "source": "src/index.ts",
-  "sideEffects": false,
   "files": [
     "dist",
     "docs",
@@ -43,13 +33,26 @@
     "LICENSE",
     "README.md"
   ],
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "unpkg": "dist/index.umd.js",
+  "umd:main": "dist/index.umd.js",
+  "browser": "dist/index.js",
+  "react-native": "dist/index.js",
+  "types": "./dist/index.d.cts",
+  "source": "src/index.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
   "scripts": {
-    "clean": "shx rm -rf dist lib",
-    "build": "npm run build:cjs && npm run build:esm && npm run build:rollup",
-    "build:cjs": "tsc -p tsconfig.build.json --outDir dist/cjs --module commonjs",
-    "build:esm": "tsc -p tsconfig.build.json --outDir dist/esm --module es2015",
-    "build:rollup": "rollup -c",
+    "clean": "rm -rf dist lib",
+    "build": "tsdown",
     "typedoc": "typedoc"
   },
-  "gitHead": "e9d435838d465b1a878d3b7bc5c7cc6e90fd241a"
+  "gitHead": "b092f487c06b35fb2c1125303d6e4942bc2a66b9"
 }