@codefast/di 0.5.0-canary.5 → 0.5.0-canary.7

package/dist/container.mjs

@@ -1,741 +0,0 @@
-import { effectiveBindingScope } from "./binding-scope.mjs";
-import { AsyncModuleLoadError, CircularDependencyError, DisposedContainerError, InternalError, RebindUnboundTokenError, ScopeViolationError, SyncDisposalNotSupportedError } from "./errors.mjs";
-import { DEFAULT_BINDING_SLOT, generateBindingId } from "./binding.mjs";
-import { tokenName } from "./token.mjs";
-import { bindingSlotToResolveOptions, injectionSlotToResolveOptions } from "./resolve-options.mjs";
-import { normalizeToDescriptor } from "./decorators/inject.mjs";
-import { buildDependencyGraph } from "./dependency-graph.mjs";
-import { Inspector } from "./inspector.mjs";
-import { LifecycleManager } from "./lifecycle.mjs";
-import { MetadataReaderToken } from "./metadata/metadata-reader-token.mjs";
-import { defaultMetadataReader } from "./metadata/symbol-metadata-reader.mjs";
-import { isSyncModule } from "./module.mjs";
-import { BindingRegistry } from "./registry.mjs";
-import { DependencyResolver } from "./resolver.mjs";
-import { ScopeManager } from "./scope.mjs";
-//#region src/container.ts
-var DefaultContainer = class DefaultContainer {
-	_disposed = false;
-	_registry;
-	_scope;
-	_lifecycle;
-	_resolver;
-	_inspector;
-	_parent;
-	_moduleRefs = /* @__PURE__ */ new Map();
-	_moduleBindingIds = /* @__PURE__ */ new Map();
-	constructor(parent) {
-		this._parent = parent;
-		this._registry = new BindingRegistry();
-		this._scope = new ScopeManager(parent !== void 0);
-		this._lifecycle = new LifecycleManager();
-		this._inspector = new Inspector(this._registry, this._scope, parent !== void 0, () => this._disposed);
-		this._initResolver();
-	}
-	_initResolver() {
-		const metadataReader = this._getMetadataReader();
-		const parentResolver = this._parent?._resolver;
-		this._resolver = new DependencyResolver(this._registry, this._scope, this._lifecycle, metadataReader, this, parentResolver);
-	}
-	_getMetadataReader() {
-		if (this._registry.getAll(MetadataReaderToken).length > 0) try {
-			return this._resolver.resolve(MetadataReaderToken, void 0, [], []);
-		} catch {}
-		if (this._parent !== void 0) return this._parent._getMetadataReader();
-		return defaultMetadataReader;
-	}
-	get isDisposed() {
-		return this._disposed;
-	}
-	bind(token) {
-		this._assertNotDisposed();
-		return this._createBindToBuilder(token);
-	}
-	_createBindToBuilder(token, moduleRef) {
-		const registry = this._registry;
-		const commitBinding = (binding, previousId) => {
-			if (previousId !== void 0) {
-				registry.removeById(previousId);
-				if (moduleRef !== void 0) {
-					const ids = this._moduleBindingIds.get(moduleRef);
-					if (ids !== void 0) {
-						const idx = ids.indexOf(previousId);
-						if (idx !== -1) ids.splice(idx, 1);
-					}
-				}
-			}
-			registry.add(binding);
-			if (moduleRef !== void 0) {
-				let ids = this._moduleBindingIds.get(moduleRef);
-				if (ids === void 0) {
-					ids = [];
-					this._moduleBindingIds.set(moduleRef, ids);
-				}
-				ids.push(binding.id);
-			}
-			return binding.id;
-		};
-		return new BindingEntry(token, commitBinding);
-	}
-	unbind(tokenOrId) {
-		this._assertNotDisposed();
-		this._unbindSync(tokenOrId);
-	}
-	/** Remove bindings from registry + scope and collect [binding, instance] pairs for deactivation. */
-	_collectDeactivationPairs(tokenOrId) {
-		const pairs = [];
-		for (const binding of this._getBindingsForTokenOrId(tokenOrId)) {
-			this._registry.removeById(binding.id);
-			if (this._scope.hasSingleton(binding.id)) {
-				pairs.push([binding, this._scope.getSingleton(binding.id)]);
-				this._scope.deleteSingleton(binding.id);
-			}
-		}
-		return pairs;
-	}
-	/** Drain singleton scope entries for a set of already-removed bindings. */
-	_drainSingletons(bindings) {
-		const pairs = [];
-		for (const binding of bindings) if (this._scope.hasSingleton(binding.id)) {
-			pairs.push([binding, this._scope.getSingleton(binding.id)]);
-			this._scope.deleteSingleton(binding.id);
-		}
-		return pairs;
-	}
-	_unbindSync(tokenOrId) {
-		const reader = this._getMetadataReader();
-		for (const [binding, instance] of this._collectDeactivationPairs(tokenOrId)) this._lifecycle.runDeactivationSync(binding, instance, reader);
-	}
-	async unbindAsync(tokenOrId) {
-		this._assertNotDisposed();
-		const reader = this._getMetadataReader();
-		for (const [binding, instance] of this._collectDeactivationPairs(tokenOrId)) await this._lifecycle.runDeactivation(binding, instance, reader);
-	}
-	unbindAll() {
-		this._assertNotDisposed();
-		const reader = this._getMetadataReader();
-		for (const [binding, instance] of this._drainSingletons(this._registry.clear())) this._lifecycle.runDeactivationSync(binding, instance, reader);
-	}
-	async unbindAllAsync() {
-		this._assertNotDisposed();
-		const reader = this._getMetadataReader();
-		for (const [binding, instance] of this._drainSingletons(this._registry.clear())) await this._lifecycle.runDeactivation(binding, instance, reader);
-	}
-	rebind(token) {
-		this._assertNotDisposed();
-		if (!this._registry.has(token)) throw new RebindUnboundTokenError(tokenName(token));
-		this._unbindSync(token);
-		return this._createBindToBuilder(token);
-	}
-	_getBindingsForTokenOrId(tokenOrId) {
-		if (typeof tokenOrId === "string") {
-			const binding = this._registry.getById(tokenOrId);
-			return binding !== void 0 ? [binding] : [];
-		}
-		return [...this._registry.getAll(tokenOrId)];
-	}
-	load(...modules) {
-		this._assertNotDisposed();
-		this._loadSyncModules(modules);
-	}
-	_loadSyncModules(modules) {
-		const toLoad = this._collectModuleDeps(modules);
-		for (const module of toLoad) {
-			if (!isSyncModule(module)) throw new AsyncModuleLoadError(module.name);
-			const moduleRef = module;
-			const existing = this._moduleRefs.get(moduleRef);
-			if (existing !== void 0) {
-				this._moduleRefs.set(moduleRef, existing + 1);
-				continue;
-			}
-			this._moduleRefs.set(moduleRef, 1);
-			const builder = this._createModuleBuilder(moduleRef);
-			module._setup(builder);
-		}
-	}
-	_collectModuleDeps(modules) {
-		const seen = /* @__PURE__ */ new Set();
-		const result = [];
-		const visit = (module) => {
-			const moduleRef = module;
-			if (seen.has(moduleRef)) return;
-			seen.add(moduleRef);
-			result.push(module);
-		};
-		for (const module of modules) visit(module);
-		return result;
-	}
-	async loadAsync(...modules) {
-		this._assertNotDisposed();
-		for (const module of modules) await this._loadOneModuleAsync(module);
-	}
-	async _loadOneModuleAsync(module) {
-		const moduleRef = module;
-		const existing = this._moduleRefs.get(moduleRef);
-		if (existing !== void 0) {
-			this._moduleRefs.set(moduleRef, existing + 1);
-			return;
-		}
-		this._moduleRefs.set(moduleRef, 1);
-		if (isSyncModule(module)) {
-			const builder = this._createModuleBuilder(moduleRef);
-			module._setup(builder);
-		} else {
-			const importPromises = [];
-			const builder = this._createAsyncModuleBuilder(moduleRef, importPromises);
-			await module._setup(builder);
-			if (importPromises.length > 0) await Promise.all(importPromises);
-		}
-	}
-	_createModuleBuilder(moduleRef) {
-		return {
-			bind: (token) => this._createBindToBuilder(token, moduleRef),
-			import: (...modules) => {
-				this._loadSyncModules(modules);
-			}
-		};
-	}
-	_createAsyncModuleBuilder(moduleRef, importPromises) {
-		return {
-			bind: (token) => this._createBindToBuilder(token, moduleRef),
-			import: (...modules) => {
-				for (const module of modules) importPromises.push(this._loadOneModuleAsync(module));
-			}
-		};
-	}
-	unload(...modules) {
-		this._assertNotDisposed();
-		for (const module of modules) this._unloadModuleSync(module);
-	}
-	/** Unregister module bindings and collect [binding, instance] pairs for deactivation. */
-	_removeModuleBindings(ref) {
-		this._moduleRefs.delete(ref);
-		const ids = this._moduleBindingIds.get(ref) ?? [];
-		this._moduleBindingIds.delete(ref);
-		const pairs = [];
-		for (const id of ids) {
-			const binding = this._registry.getById(id);
-			if (binding !== void 0) {
-				this._registry.removeById(id);
-				if (this._scope.hasSingleton(id)) {
-					pairs.push([binding, this._scope.getSingleton(id)]);
-					this._scope.deleteSingleton(id);
-				}
-			}
-		}
-		return pairs;
-	}
-	_unloadModuleSync(ref) {
-		const count = this._moduleRefs.get(ref) ?? 0;
-		if (count <= 1) {
-			const reader = this._getMetadataReader();
-			for (const [binding, instance] of this._removeModuleBindings(ref)) this._lifecycle.runDeactivationSync(binding, instance, reader);
-		} else this._moduleRefs.set(ref, count - 1);
-	}
-	async unloadAsync(...modules) {
-		this._assertNotDisposed();
-		for (const module of modules) await this._unloadModuleAsync(module);
-	}
-	async _unloadModuleAsync(ref) {
-		const count = this._moduleRefs.get(ref) ?? 0;
-		if (count <= 1) {
-			const reader = this._getMetadataReader();
-			for (const [binding, instance] of this._removeModuleBindings(ref)) await this._lifecycle.runDeactivation(binding, instance, reader);
-		} else this._moduleRefs.set(ref, count - 1);
-	}
-	loadAutoRegistered(registry) {
-		this._assertNotDisposed();
-		const entries = registry.entries();
-		for (const { target, scope } of entries) {
-			const bindingBuilder = this._createBindToBuilder(target).toSelf();
-			if (scope === "singleton") bindingBuilder.singleton();
-			else if (scope === "scoped") bindingBuilder.scoped();
-			else bindingBuilder.transient();
-		}
-		return entries.length;
-	}
-	onActivation(token, handler) {
-		this._assertNotDisposed();
-		this._lifecycle.registerActivation(token, handler);
-	}
-	onDeactivation(token, handler) {
-		this._assertNotDisposed();
-		this._lifecycle.registerDeactivation(token, handler);
-	}
-	resolve(token, options) {
-		this._assertNotDisposed();
-		if (options === void 0) return this._resolver.resolveFromContext(token, [], []);
-		return this._resolver.resolve(token, options, [], []);
-	}
-	resolveAsync(token, options) {
-		this._assertNotDisposed();
-		if (options === void 0) return this._resolver.resolveAsyncFromContext(token, [], []);
-		return this._resolver.resolveAsync(token, options, [], []);
-	}
-	resolveOptional(token, options) {
-		this._assertNotDisposed();
-		return this._resolver.resolveOptional(token, options, [], []);
-	}
-	resolveOptionalAsync(token, options) {
-		this._assertNotDisposed();
-		return this._resolver.resolveOptionalAsync(token, options, [], []);
-	}
-	resolveAll(token, options) {
-		this._assertNotDisposed();
-		return this._resolver.resolveAll(token, options, [], []);
-	}
-	resolveAllAsync(token, options) {
-		this._assertNotDisposed();
-		return this._resolver.resolveAllAsync(token, options, [], []);
-	}
-	createChild() {
-		this._assertNotDisposed();
-		return new DefaultContainer(this);
-	}
-	async dispose() {
-		if (this._disposed) return;
-		this._disposed = true;
-		const reader = this._getMetadataReader();
-		for (const [id, instance] of this._scope.getAllSingletons()) {
-			const binding = this._registry.getById(id);
-			if (binding !== void 0) await this._lifecycle.runDeactivation(binding, instance, reader);
-		}
-		this._scope.clearAll();
-	}
-	[Symbol.asyncDispose]() {
-		return this.dispose();
-	}
-	[Symbol.dispose]() {
-		throw new SyncDisposalNotSupportedError();
-	}
-	async initializeAsync() {
-		this._assertNotDisposed();
-		const allBindings = this._registry.allBindings();
-		for (const binding of allBindings) {
-			if (binding.kind === "alias") continue;
-			if (effectiveBindingScope(binding) === "singleton" && !this._scope.hasSingleton(binding.id)) {
-				if (binding.predicate !== void 0) continue;
-				if (binding.kind === "constant" && binding.onActivation === void 0) continue;
-				const slotOptions = bindingSlotToResolveOptions(binding.slot);
-				await this.resolveAsync(binding.token, slotOptions);
-			}
-		}
-	}
-	validate() {
-		this._assertNotDisposed();
-		const reader = this._getMetadataReader();
-		const allBindings = this._registry.allBindings();
-		for (const binding of allBindings) {
-			if (!this._isSingletonStaticAnalyzableBinding(binding)) continue;
-			this._validateSingletonBindingGraph(binding, reader);
-		}
-	}
-	_isSingletonStaticAnalyzableBinding(binding) {
-		if (effectiveBindingScope(binding) !== "singleton") return false;
-		return binding.kind === "class" || binding.kind === "resolved" || binding.kind === "resolved-async";
-	}
-	/**
-	* DFS over explicit constructor / `toResolved*` dependency edges. Follows `toAlias` chains to the
-	* terminal binding for scope checks (SPEC §6.9). Skips `toDynamic*` subtrees (opaque).
-	*/
-	_validateSingletonBindingGraph(root, reader) {
-		const rootName = tokenName(root.token);
-		const dfs = (current, pathNames, pathBindingIds) => {
-			if (pathBindingIds.has(current.id)) return;
-			const extendedPathIds = new Set(pathBindingIds);
-			extendedPathIds.add(current.id);
-			for (const edge of this._collectStaticDependencyEdges(current, reader)) {
-				const { terminal, depTokenName } = edge;
-				const depScope = this._validationScopeFromTerminal(terminal);
-				if (depScope === "opaque") continue;
-				if (depScope === "scoped" || depScope === "transient") throw new ScopeViolationError({
-					consumerToken: rootName,
-					consumerScope: "singleton",
-					dependencyToken: depTokenName,
-					dependencyScope: depScope,
-					path: [...pathNames, depTokenName]
-				});
-				if (terminal.kind === "class" || terminal.kind === "resolved" || terminal.kind === "resolved-async") dfs(terminal, [...pathNames, depTokenName], extendedPathIds);
-			}
-		};
-		dfs(root, [rootName], /* @__PURE__ */ new Set());
-	}
-	_validationScopeFromTerminal(terminal) {
-		switch (terminal.kind) {
-			case "constant": return "singleton";
-			case "dynamic":
-			case "dynamic-async": return "opaque";
-			case "class":
-			case "resolved":
-			case "resolved-async": return terminal.scope;
-			case "alias": throw new InternalError("validate: expected terminal binding after alias resolution");
-			default: return terminal;
-		}
-	}
-	_followAliasChainToTerminal(binding, options) {
-		const cyclePath = [];
-		const seenAliasIds = /* @__PURE__ */ new Set();
-		let current = binding;
-		while (current !== void 0 && current.kind === "alias") {
-			if (seenAliasIds.has(current.id)) throw new CircularDependencyError(cyclePath);
-			seenAliasIds.add(current.id);
-			cyclePath.push(tokenName(current.token));
-			const nextToken = current.target;
-			const next = this._resolver.peekBindingForValidate(nextToken, options);
-			if (next === void 0) return;
-			current = next.binding;
-		}
-		return current;
-	}
-	_collectStaticDependencyEdges(binding, reader) {
-		const edges = [];
-		const pushTerminal = (terminal, displayName) => {
-			if (terminal === void 0) return;
-			edges.push({
-				terminal,
-				depTokenName: displayName
-			});
-		};
-		if (binding.kind === "class") {
-			const meta = reader.getConstructorMetadata(binding.target);
-			if (meta === void 0) return edges;
-			for (const param of meta.params) {
-				const paramOptions = injectionSlotToResolveOptions(param);
-				if (param.optional) continue;
-				const tokenRef = param.token;
-				if (param.multi) {
-					const candidates = this._resolver.peekCandidateBindingsForValidate(tokenRef, paramOptions);
-					for (const cand of candidates) {
-						const term = this._followAliasChainToTerminal(cand, paramOptions);
-						pushTerminal(term, term !== void 0 ? tokenName(term.token) : "");
-					}
-					continue;
-				}
-				const found = paramOptions === void 0 ? this._resolver.peekBindingForValidate(tokenRef, void 0) : this._resolver.peekBindingForValidate(tokenRef, paramOptions);
-				if (found === void 0) continue;
-				const term = this._followAliasChainToTerminal(found.binding, paramOptions);
-				pushTerminal(term, term !== void 0 ? tokenName(term.token) : "");
-			}
-			return edges;
-		}
-		if (binding.kind === "resolved" || binding.kind === "resolved-async") for (const dep of binding.deps) {
-			const depOptions = injectionSlotToResolveOptions(dep);
-			if (dep.optional) continue;
-			const tokenRef = dep.token;
-			if (dep.multi) {
-				const candidates = this._resolver.peekCandidateBindingsForValidate(tokenRef, depOptions);
-				for (const cand of candidates) {
-					const term = this._followAliasChainToTerminal(cand, depOptions);
-					pushTerminal(term, term !== void 0 ? tokenName(term.token) : "");
-				}
-				continue;
-			}
-			const found = depOptions === void 0 ? this._resolver.peekBindingForValidate(tokenRef, void 0) : this._resolver.peekBindingForValidate(tokenRef, depOptions);
-			if (found === void 0) continue;
-			const term = this._followAliasChainToTerminal(found.binding, depOptions);
-			pushTerminal(term, term !== void 0 ? tokenName(term.token) : "");
-		}
-		return edges;
-	}
-	has(token, options) {
-		this._assertNotDisposed();
-		return this._inspector.has(token, options, () => this._parent?.has(token, options) ?? false);
-	}
-	hasOwn(token, options) {
-		this._assertNotDisposed();
-		return this._inspector.hasOwn(token, options);
-	}
-	lookupBindings(token) {
-		this._assertNotDisposed();
-		return this._inspector.lookupBindings(token);
-	}
-	inspect() {
-		this._assertNotDisposed();
-		return this._inspector.inspect();
-	}
-	generateDependencyGraph(options) {
-		this._assertNotDisposed();
-		return buildDependencyGraph(this._registry, this._getMetadataReader(), options, this._parent?._registry);
-	}
-	_assertNotDisposed() {
-		if (this._disposed) throw new DisposedContainerError();
-	}
-};
-function updateSlotTag(slot, tag, value) {
-	const existing = [...slot.tags];
-	const idx = existing.findIndex(([k]) => k === tag);
-	if (idx !== -1) existing[idx] = [tag, value];
-	else existing.push([tag, value]);
-	return {
-		...slot,
-		tags: existing
-	};
-}
-var SlotBuilder = class {
-	_slot = DEFAULT_BINDING_SLOT;
-	_predicate;
-	_committed;
-	when(predicate) {
-		this._predicate = predicate;
-		this._doCommit();
-		return this;
-	}
-	whenNamed(name) {
-		this._slot = {
-			...this._slot,
-			name
-		};
-		this._doCommit();
-		return this;
-	}
-	whenTagged(tag, value) {
-		this._slot = updateSlotTag(this._slot, tag, value);
-		this._doCommit();
-		return this;
-	}
-	whenDefault() {
-		return this;
-	}
-	id() {
-		return this._committed;
-	}
-};
-var BindingEntry = class {
-	_token;
-	_commit;
-	constructor(_token, _commit) {
-		this._token = _token;
-		this._commit = _commit;
-	}
-	to(type) {
-		return new ConstraintBuilder(this._token, {
-			kind: "class",
-			target: type,
-			scope: "transient"
-		}, this._commit);
-	}
-	toSelf() {
-		if (typeof this._token !== "function") throw new Error("toSelf() requires token to be a Constructor");
-		return new ConstraintBuilder(this._token, {
-			kind: "class",
-			target: this._token,
-			scope: "transient"
-		}, this._commit);
-	}
-	toConstantValue(value) {
-		return new ConstantBuilder(this._token, value, this._commit);
-	}
-	toDynamic(factory) {
-		return new ConstraintBuilder(this._token, {
-			kind: "dynamic",
-			factory,
-			scope: "transient"
-		}, this._commit);
-	}
-	toDynamicAsync(factory) {
-		return new ConstraintBuilder(this._token, {
-			kind: "dynamic-async",
-			factory,
-			scope: "transient"
-		}, this._commit);
-	}
-	toResolved(factory, deps) {
-		const normalizedDeps = deps.map((dependency) => normalizeToDescriptor(dependency));
-		return new ConstraintBuilder(this._token, {
-			kind: "resolved",
-			factory,
-			deps: normalizedDeps,
-			scope: "transient"
-		}, this._commit);
-	}
-	toResolvedAsync(factory, deps) {
-		const normalizedDeps = deps.map((dependency) => normalizeToDescriptor(dependency));
-		return new ConstraintBuilder(this._token, {
-			kind: "resolved-async",
-			factory,
-			deps: normalizedDeps,
-			scope: "transient"
-		}, this._commit);
-	}
-	toAlias(target) {
-		return new AliasBuilder(this._token, target, this._commit);
-	}
-};
-var ConstraintBuilder = class extends SlotBuilder {
-	_token;
-	_partial;
-	_commit;
-	constructor(_token, _partial, _commit) {
-		super();
-		this._token = _token;
-		this._partial = _partial;
-		this._commit = _commit;
-		this._doCommit();
-	}
-	_doCommit() {
-		const previousId = this._committed;
-		const binding = {
-			...this._partial,
-			id: generateBindingId(),
-			token: this._token,
-			slot: this._slot,
-			predicate: this._predicate
-		};
-		this._committed = this._commit(binding, previousId);
-	}
-	singleton() {
-		const previousId = this._committed;
-		this._committed = void 0;
-		return new ScopeBuilder(this._token, {
-			...this._partial,
-			scope: "singleton"
-		}, this._slot, this._predicate, this._commit, "singleton", previousId);
-	}
-	transient() {
-		const previousId = this._committed;
-		this._committed = void 0;
-		return new ScopeBuilder(this._token, {
-			...this._partial,
-			scope: "transient"
-		}, this._slot, this._predicate, this._commit, "transient", previousId);
-	}
-	scoped() {
-		const previousId = this._committed;
-		this._committed = void 0;
-		return new ScopeBuilder(this._token, {
-			...this._partial,
-			scope: "scoped"
-		}, this._slot, this._predicate, this._commit, "scoped", previousId);
-	}
-};
-var ScopeBuilder = class {
-	_token;
-	_partial;
-	_slot;
-	_predicate;
-	_commit;
-	_scope;
-	_initialPreviousId;
-	_onActivation;
-	_onDeactivation;
-	_committed;
-	constructor(_token, _partial, _slot, _predicate, _commit, _scope, _initialPreviousId) {
-		this._token = _token;
-		this._partial = _partial;
-		this._slot = _slot;
-		this._predicate = _predicate;
-		this._commit = _commit;
-		this._scope = _scope;
-		this._initialPreviousId = _initialPreviousId;
-		this._doCommit();
-	}
-	_doCommit() {
-		const previousId = this._committed ?? this._initialPreviousId;
-		const binding = {
-			...this._partial,
-			id: generateBindingId(),
-			token: this._token,
-			slot: this._slot,
-			predicate: this._predicate,
-			onActivation: this._onActivation,
-			onDeactivation: this._onDeactivation
-		};
-		this._committed = this._commit(binding, previousId);
-	}
-	onActivation(fn) {
-		this._onActivation = fn;
-		this._doCommit();
-		return this;
-	}
-	onDeactivation(fn) {
-		this._onDeactivation = fn;
-		this._doCommit();
-		return this;
-	}
-	id() {
-		return this._committed;
-	}
-};
-var ConstantBuilder = class extends SlotBuilder {
-	_token;
-	_value;
-	_commit;
-	_onActivation;
-	_onDeactivation;
-	constructor(_token, _value, _commit) {
-		super();
-		this._token = _token;
-		this._value = _value;
-		this._commit = _commit;
-		this._doCommit();
-	}
-	_doCommit() {
-		const previousId = this._committed;
-		const binding = {
-			kind: "constant",
-			id: generateBindingId(),
-			token: this._token,
-			slot: this._slot,
-			predicate: this._predicate,
-			value: this._value,
-			scope: "singleton",
-			onActivation: this._onActivation,
-			onDeactivation: this._onDeactivation
-		};
-		this._committed = this._commit(binding, previousId);
-	}
-	onActivation(fn) {
-		this._onActivation = fn;
-		this._doCommit();
-		return this;
-	}
-	onDeactivation(fn) {
-		this._onDeactivation = fn;
-		this._doCommit();
-		return this;
-	}
-};
-var AliasBuilder = class extends SlotBuilder {
-	_token;
-	_target;
-	_commit;
-	constructor(_token, _target, _commit) {
-		super();
-		this._token = _token;
-		this._target = _target;
-		this._commit = _commit;
-		this._doCommit();
-	}
-	_doCommit() {
-		const previousId = this._committed;
-		const binding = {
-			kind: "alias",
-			id: generateBindingId(),
-			token: this._token,
-			slot: this._slot,
-			predicate: this._predicate,
-			target: this._target
-		};
-		this._committed = this._commit(binding, previousId);
-	}
-};
-/**
-* @since 0.3.16-canary.0
-*/
-const Container = {
-	create() {
-		return new DefaultContainer();
-	},
-	fromModules(...modules) {
-		const container = new DefaultContainer();
-		container.load(...modules);
-		return container;
-	},
-	async fromModulesAsync(...modules) {
-		const container = new DefaultContainer();
-		await container.loadAsync(...modules);
-		return container;
-	}
-};
-//#endregion
-export { Container };