@codefast/di 0.3.14-canary.0 → 0.3.14-canary.2

package/dist/module.d.mts

@@ -1,92 +1,38 @@
+import { Constructor } from "./constructor-type.mjs";
 import { Token } from "./token.mjs";
-import { BindingBuilder, Constructor } from "./binding.mjs";
+import { BindToBuilder } from "./binding.mjs";
 
 //#region src/module.d.ts
-/**
- * Builder passed to the setup callback of a synchronous {@link Module}.
- * Use `import()` to declare module dependencies (sync modules only —
- * passing an {@link AsyncModule} throws {@link InternalError}) and `bind()` to register tokens.
- *
- * **Single slot (last-wins)** — `bind(key).to*(...)` with no `whenNamed` / `whenTagged` / `when`
- * *before* the `to*()` call replaces all prior bindings for `key` from this module pass.
- *
- * **Multi-binding** — put at least one disambiguator *before* `to*()` (e.g.
- * `bind(key).whenNamed("a").to*(...)`, `whenTagged` before `to*()`, or `when` before `to*()`).
- * Each such line **appends** another binding so {@link Container.resolveAll} can return every
- * implementation. Use this order in modules; chaining `.to*(...).whenNamed()` only updates that
- * binding in place and does not stack multiple registrations across lines.
- */
-type ModuleBuilder = {
-  readonly import: (...modules: Module[]) => void;
-  readonly bind: <Value>(key: Token<Value> | Constructor<Value>) => BindingBuilder<Value>;
-};
-/**
- * Builder passed to the setup callback of an {@link AsyncModule}.
- * Unlike {@link ModuleBuilder}, `import()` accepts both sync and async modules.
- * Async sub-imports are collected and awaited **after** the setup callback returns.
- */
-type AsyncModuleBuilder = {
-  readonly import: (...modules: (Module | AsyncModule)[]) => void;
-  readonly bind: <Value>(key: Token<Value> | Constructor<Value>) => BindingBuilder<Value>;
-};
-/**
- * Immutable description of a bundle of bindings. A {@link Module} holds no runtime state and the
- * same instance may be loaded into any number of containers independently (spec §7.3).
- *
- * The owning container is responsible for tracking which modules have been loaded and which
- * binding ids each module produced; the module itself never sees a container reference.
- */
-declare class Module {
-  /**
-   * Human-readable label used in error messages, graph output, and module-cycle diagnostics.
-   */
+declare const SYNC_MODULE_BRAND: unique symbol;
+declare const ASYNC_MODULE_BRAND: unique symbol;
+interface SyncModule {
   readonly name: string;
-  /**
-   * The user-supplied setup callback; invoked exactly once per `load()` call.
-   */
-  private readonly syncSetup;
-  /**
-   * @internal Use {@link Module.create} instead.
-   */
-  private constructor();
-  /**
-   * Defines a synchronous module.
-   * @param name - Human-readable label used in error messages and debug output.
-   * @param setup - Callback that registers bindings via the {@link ModuleBuilder}.
-   */
-  static create(name: string, setup: (builder: ModuleBuilder) => void): Module;
-  /**
-   * Defines an async module — use when setup requires awaiting (e.g. reading config, dynamic imports).
-   * Load with {@link Container.loadAsync} or {@link Container.fromModulesAsync}.
-   */
-  static createAsync(name: string, setup: (builder: AsyncModuleBuilder) => Promise<void>): AsyncModule;
-  /**
-   * @internal Invoked by the container while loading this module.
-   */
-  runSyncSetup(builder: ModuleBuilder): void;
+  readonly [SYNC_MODULE_BRAND]: true;
+  readonly _setup: (builder: ModuleBuilder) => void;
 }
-/**
- * An async module whose setup callback may `await` before registering bindings.
- * Prefer {@link Module.createAsync} over constructing this class directly.
- *
- * Load via `Container.loadAsync()` or `Container.fromModulesAsync()`;
- * passing an `AsyncModule` to the synchronous `Container.load()` throws
- * {@link AsyncModuleLoadError}.
- */
-declare class AsyncModule {
-  /**
-   * Human-readable label used in error messages and graph output.
-   */
+interface AsyncModule {
   readonly name: string;
-  /**
-   * The user-supplied async setup callback; invoked exactly once per `loadAsync()` call.
-   */
-  private readonly asyncSetup;
-  constructor(name: string, asyncSetup: (builder: AsyncModuleBuilder) => Promise<void>);
-  /**
-   * @internal Invoked by the container while loading this module.
-   */
-  runAsyncSetup(builder: AsyncModuleBuilder): Promise<void>;
+  readonly [ASYNC_MODULE_BRAND]: true;
+  readonly _setup: (builder: AsyncModuleBuilder) => Promise<void>;
+}
+interface ModuleBuilder {
+  bind<const Value>(token: Token<Value> | Constructor<Value>): BindToBuilder<Value>;
+  import(...modules: SyncModule[]): void;
+}
+interface AsyncModuleBuilder {
+  bind<const Value>(token: Token<Value> | Constructor<Value>): BindToBuilder<Value>;
+  import(...modules: Array<SyncModule | AsyncModule>): void;
 }
+declare const SyncModule: {
+  create(name: string, setup: (builder: ModuleBuilder) => void): SyncModule;
+};
+declare const AsyncModule: {
+  create(name: string, setup: (builder: AsyncModuleBuilder) => Promise<void>): AsyncModule;
+};
+declare const Module: {
+  create(name: string, setup: (builder: ModuleBuilder) => void): SyncModule;
+  createAsync(name: string, setup: (builder: AsyncModuleBuilder) => Promise<void>): AsyncModule;
+};
+declare function isSyncModule(m: SyncModule | AsyncModule): m is SyncModule;
 //#endregion
-export { AsyncModule, AsyncModuleBuilder, Module, ModuleBuilder };
+export { AsyncModule, AsyncModuleBuilder, Module, ModuleBuilder, SyncModule, isSyncModule };

package/dist/module.mjs

@@ -1,76 +1,30 @@
 //#region src/module.ts
-/**
-* Immutable description of a bundle of bindings. A {@link Module} holds no runtime state and the
-* same instance may be loaded into any number of containers independently (spec §7.3).
-*
-* The owning container is responsible for tracking which modules have been loaded and which
-* binding ids each module produced; the module itself never sees a container reference.
-*/
-var Module = class Module {
-	/**
-	* Human-readable label used in error messages, graph output, and module-cycle diagnostics.
-	*/
-	name;
-	/**
-	* The user-supplied setup callback; invoked exactly once per `load()` call.
-	*/
-	syncSetup;
-	/**
-	* @internal Use {@link Module.create} instead.
-	*/
-	constructor(name, syncSetup) {
-		this.name = name;
-		this.syncSetup = syncSetup;
-	}
-	/**
-	* Defines a synchronous module.
-	* @param name - Human-readable label used in error messages and debug output.
-	* @param setup - Callback that registers bindings via the {@link ModuleBuilder}.
-	*/
-	static create(name, setup) {
-		return new Module(name, setup);
-	}
-	/**
-	* Defines an async module — use when setup requires awaiting (e.g. reading config, dynamic imports).
-	* Load with {@link Container.loadAsync} or {@link Container.fromModulesAsync}.
-	*/
-	static createAsync(name, setup) {
-		return new AsyncModule(name, setup);
-	}
-	/**
-	* @internal Invoked by the container while loading this module.
-	*/
-	runSyncSetup(builder) {
-		this.syncSetup(builder);
-	}
-};
-/**
-* An async module whose setup callback may `await` before registering bindings.
-* Prefer {@link Module.createAsync} over constructing this class directly.
-*
-* Load via `Container.loadAsync()` or `Container.fromModulesAsync()`;
-* passing an `AsyncModule` to the synchronous `Container.load()` throws
-* {@link AsyncModuleLoadError}.
-*/
-var AsyncModule = class {
-	/**
-	* Human-readable label used in error messages and graph output.
-	*/
-	name;
-	/**
-	* The user-supplied async setup callback; invoked exactly once per `loadAsync()` call.
-	*/
-	asyncSetup;
-	constructor(name, asyncSetup) {
-		this.name = name;
-		this.asyncSetup = asyncSetup;
-	}
-	/**
-	* @internal Invoked by the container while loading this module.
-	*/
-	async runAsyncSetup(builder) {
-		await this.asyncSetup(builder);
+const SYNC_MODULE_BRAND = Symbol("di:sync-module");
+const ASYNC_MODULE_BRAND = Symbol("di:async-module");
+const SyncModule = { create(name, setup) {
+	return {
+		name,
+		[SYNC_MODULE_BRAND]: true,
+		_setup: setup
+	};
+} };
+const AsyncModule = { create(name, setup) {
+	return {
+		name,
+		[ASYNC_MODULE_BRAND]: true,
+		_setup: setup
+	};
+} };
+const Module = {
+	create(name, setup) {
+		return SyncModule.create(name, setup);
+	},
+	createAsync(name, setup) {
+		return AsyncModule.create(name, setup);
 	}
 };
+function isSyncModule(m) {
+	return m[SYNC_MODULE_BRAND] === true;
+}
 //#endregion
-export { AsyncModule, Module };
+export { AsyncModule, Module, SyncModule, isSyncModule };

package/dist/registry.d.mts

@@ -1,69 +1,38 @@
+import { Constructor } from "./constructor-type.mjs";
 import { Token } from "./token.mjs";
-import { Binding, BindingIdentifier, Constructor } from "./binding.mjs";
+import { BindingIdentifier } from "./types.mjs";
+import { Binding } from "./binding.mjs";
 
 //#region src/registry.d.ts
-/**
- * Key used to group {@link Binding} instances in the registry (reference equality for tokens).
- */
-type RegistryKey = Token<unknown> | Constructor<unknown>;
-/**
- * Flat, in-memory storage for {@link Binding} entries keyed by {@link RegistryKey}.
- * Each key maps to an ordered list of bindings (multi-binding support).
- *
- * The registry is a "dumb" store — it does not perform selection, scope caching, or
- * lifecycle management. Those concerns live in `DependencyResolver` and `ScopeManager`.
- *
- * Mutation styles:
- * - `add` — append-only; never removes existing entries.
- * - `replaceById` — swaps a single binding in place by ID; no removal callback.
- * - `remove` / `removeById` — delete entries **without** notifying callers; the caller
- *   is responsible for draining the scope cache before calling these.
- * - `replaceKeyLastWins` — replaces all bindings for a key with a single new one **and**
- *   invokes the `onReplaced` callback for each evicted binding, giving the caller
- *   (typically the container or scope manager) a chance to run deactivation.
- */
 declare class BindingRegistry {
-  /**
-   * Primary index: registry key → ordered binding list.
-   * Reference equality on the key (i.e. the same {@link Token} or {@link Constructor} object).
-   */
-  private readonly bindingsByKey;
-  /**
-   * Appends `binding` to the list for `key` (multi-binding: each call adds an entry).
-   */
-  add<Value>(key: Token<Value> | Constructor<Value>, binding: Binding<Value>): void;
-  /**
-   * Returns all bindings registered for `key`, or `undefined` if none exist.
-   */
-  get<Value>(key: Token<Value> | Constructor<Value>): readonly Binding<Value>[] | undefined;
-  /**
-   * Removes all bindings for `key`. Does **not** invoke any callback — the caller must
-   * drain the scope cache (run deactivation) for the affected bindings before calling this.
-   */
-  remove(key: RegistryKey): void;
-  /**
-   * Returns owned registry rows (does not include parent containers).
-   */
-  listEntries(): readonly {
-    key: RegistryKey;
-    bindings: readonly Binding<unknown>[];
-  }[];
-  /**
-   * Removes the single binding whose `id` matches, scanning all keys.
-   * Like {@link remove}, does **not** invoke a removal callback.
-   */
-  removeById(id: BindingIdentifier): void;
-  /**
-   * Swaps the binding with the given `id` in place, preserving its position in the list.
-   */
-  replaceById(id: BindingIdentifier, next: Binding<unknown>): void;
-  /**
-   * Replaces all bindings for `key` with a single new binding (module "last-wins" semantics).
-   * Unlike {@link remove} / {@link removeById}, this method invokes `onReplaced` for every
-   * evicted binding **before** inserting the replacement, giving the caller (e.g. the
-   * container's scope manager) a chance to release cached instances and run deactivation hooks.
-   */
-  replaceKeyLastWins<Value>(key: Token<Value> | Constructor<Value>, binding: Binding<Value>, onReplaced: (removed: Binding<unknown>) => void): void;
+  private readonly _bindings;
+  private readonly _byId;
+  private readonly _simpleNamed;
+  private readonly _fastDefault;
+  /** Add or replace binding using slot-aware last-wins. */
+  add(binding: Binding): void;
+  /** Remove all bindings for a token. Returns removed bindings. */
+  removeByToken(t: Token<unknown> | Constructor): Binding[];
+  /** Remove a specific binding by ID. Returns the removed binding or undefined. */
+  removeById(id: BindingIdentifier): Binding | undefined;
+  /** Get all bindings for a token. */
+  getAll(t: Token<unknown> | Constructor): readonly Binding[];
+  /** Get binding by ID. */
+  getById(id: BindingIdentifier): Binding | undefined;
+  /** Check if any binding exists for token. */
+  has(t: Token<unknown> | Constructor): boolean;
+  /** All bindings in the registry. */
+  allBindings(): readonly Binding[];
+  /** Remove all bindings. Returns all removed. */
+  clear(): readonly Binding[];
+  getSimpleNamed(token: Token<unknown> | Constructor, name: string): Binding | undefined;
+  getFastDefault(token: Token<unknown> | Constructor): Binding | undefined;
+  /** Summarize available slot strings for a token (for error messages). */
+  availableSlotStrings(t: Token<unknown> | Constructor): string[];
+  private _isPurePredicateBinding;
+  private _indexSimpleNamedBinding;
+  private _deindexSimpleNamedBinding;
+  private _refreshFastDefaultForToken;
 }
 //#endregion
-export { BindingRegistry, RegistryKey };
+export { BindingRegistry };

package/dist/registry.mjs

@@ -1,95 +1,144 @@
+import { slotKeyEquals } from "./binding.mjs";
 //#region src/registry.ts
-/**
-* Flat, in-memory storage for {@link Binding} entries keyed by {@link RegistryKey}.
-* Each key maps to an ordered list of bindings (multi-binding support).
-*
-* The registry is a "dumb" store — it does not perform selection, scope caching, or
-* lifecycle management. Those concerns live in `DependencyResolver` and `ScopeManager`.
-*
-* Mutation styles:
-* - `add` — append-only; never removes existing entries.
-* - `replaceById` — swaps a single binding in place by ID; no removal callback.
-* - `remove` / `removeById` — delete entries **without** notifying callers; the caller
-*   is responsible for draining the scope cache before calling these.
-* - `replaceKeyLastWins` — replaces all bindings for a key with a single new one **and**
-*   invokes the `onReplaced` callback for each evicted binding, giving the caller
-*   (typically the container or scope manager) a chance to run deactivation.
-*/
 var BindingRegistry = class {
-	/**
-	* Primary index: registry key → ordered binding list.
-	* Reference equality on the key (i.e. the same {@link Token} or {@link Constructor} object).
-	*/
-	bindingsByKey = /* @__PURE__ */ new Map();
-	/**
-	* Appends `binding` to the list for `key` (multi-binding: each call adds an entry).
-	*/
-	add(key, binding) {
-		const registryKey = key;
-		const nextBinding = binding;
-		const existing = this.bindingsByKey.get(registryKey);
-		const merged = existing === void 0 ? [nextBinding] : [...existing, nextBinding];
-		this.bindingsByKey.set(registryKey, merged);
+	_bindings = /* @__PURE__ */ new Map();
+	_byId = /* @__PURE__ */ new Map();
+	_simpleNamed = /* @__PURE__ */ new Map();
+	_fastDefault = /* @__PURE__ */ new Map();
+	/** Add or replace binding using slot-aware last-wins. */
+	add(binding) {
+		const key = binding.token;
+		let list = this._bindings.get(key);
+		if (list === void 0) {
+			list = [];
+			this._bindings.set(key, list);
+		}
+		if (!this._isPurePredicateBinding(binding)) {
+			const existingIndex = list.findIndex((b) => !this._isPurePredicateBinding(b) && slotKeyEquals(b.slot, binding.slot));
+			if (existingIndex !== -1) {
+				const old = list[existingIndex];
+				this._byId.delete(old.id);
+				list.splice(existingIndex, 1);
+			}
+		}
+		list.push(binding);
+		this._byId.set(binding.id, binding);
+		this._indexSimpleNamedBinding(key, binding);
+		this._refreshFastDefaultForToken(key);
 	}
-	/**
-	* Returns all bindings registered for `key`, or `undefined` if none exist.
-	*/
-	get(key) {
-		return this.bindingsByKey.get(key);
+	/** Remove all bindings for a token. Returns removed bindings. */
+	removeByToken(t) {
+		const key = t;
+		const list = this._bindings.get(key) ?? [];
+		this._bindings.delete(key);
+		this._simpleNamed.delete(key);
+		this._fastDefault.delete(key);
+		for (const b of list) this._byId.delete(b.id);
+		return list;
 	}
-	/**
-	* Removes all bindings for `key`. Does **not** invoke any callback — the caller must
-	* drain the scope cache (run deactivation) for the affected bindings before calling this.
-	*/
-	remove(key) {
-		this.bindingsByKey.delete(key);
+	/** Remove a specific binding by ID. Returns the removed binding or undefined. */
+	removeById(id) {
+		const binding = this._byId.get(id);
+		if (binding === void 0) return;
+		this._byId.delete(id);
+		const key = binding.token;
+		const list = this._bindings.get(key);
+		if (list !== void 0) {
+			const idx = list.findIndex((b) => b.id === id);
+			if (idx !== -1) list.splice(idx, 1);
+			this._deindexSimpleNamedBinding(key, binding);
+			if (list.length === 0) {
+				this._bindings.delete(key);
+				this._simpleNamed.delete(key);
+				this._fastDefault.delete(key);
+			} else this._refreshFastDefaultForToken(key);
+		}
+		return binding;
 	}
-	/**
-	* Returns owned registry rows (does not include parent containers).
-	*/
-	listEntries() {
-		return [...this.bindingsByKey.entries()].map(([key, bindings]) => ({
-			key,
-			bindings
-		}));
+	/** Get all bindings for a token. */
+	getAll(t) {
+		return this._bindings.get(t) ?? [];
 	}
-	/**
-	* Removes the single binding whose `id` matches, scanning all keys.
-	* Like {@link remove}, does **not** invoke a removal callback.
-	*/
-	removeById(id) {
-		for (const [registryKey, list] of [...this.bindingsByKey.entries()]) {
-			const filtered = list.filter((binding) => binding.id !== id);
-			if (filtered.length === list.length) continue;
-			if (filtered.length === 0) this.bindingsByKey.delete(registryKey);
-			else this.bindingsByKey.set(registryKey, filtered);
+	/** Get binding by ID. */
+	getById(id) {
+		return this._byId.get(id);
+	}
+	/** Check if any binding exists for token. */
+	has(t) {
+		const key = t;
+		const list = this._bindings.get(key);
+		return list !== void 0 && list.length > 0;
+	}
+	/** All bindings in the registry. */
+	allBindings() {
+		const result = [];
+		for (const list of this._bindings.values()) result.push(...list);
+		return result;
+	}
+	/** Remove all bindings. Returns all removed. */
+	clear() {
+		const all = this.allBindings();
+		this._bindings.clear();
+		this._byId.clear();
+		this._simpleNamed.clear();
+		this._fastDefault.clear();
+		return all;
+	}
+	getSimpleNamed(token, name) {
+		return this._simpleNamed.get(token)?.get(name);
+	}
+	getFastDefault(token) {
+		return this._fastDefault.get(token);
+	}
+	/** Summarize available slot strings for a token (for error messages). */
+	availableSlotStrings(t) {
+		return (this._bindings.get(t) ?? []).map((b) => {
+			const s = b.slot;
+			if (s.name === void 0 && s.tags.length === 0) return "default";
+			const parts = [];
+			if (s.name !== void 0) parts.push(`name:${s.name}`);
+			for (const [k, v] of s.tags) parts.push(`tag:${k}=${String(v)}`);
+			return parts.join(",");
+		});
+	}
+	_isPurePredicateBinding(binding) {
+		const slot = binding.slot;
+		const hasPredicate = binding.predicate !== void 0;
+		const hasConstraint = slot.name !== void 0 || slot.tags.length > 0;
+		return hasPredicate && !hasConstraint;
+	}
+	_indexSimpleNamedBinding(tokenKeyValue, binding) {
+		const slot = binding.slot;
+		if (slot.name === void 0 || slot.tags.length > 0) return;
+		let byName = this._simpleNamed.get(tokenKeyValue);
+		if (byName === void 0) {
+			byName = /* @__PURE__ */ new Map();
+			this._simpleNamed.set(tokenKeyValue, byName);
 		}
+		byName.set(slot.name, binding);
 	}
-	/**
-	* Swaps the binding with the given `id` in place, preserving its position in the list.
-	*/
-	replaceById(id, next) {
-		for (const [registryKey, list] of this.bindingsByKey.entries()) {
-			const index = list.findIndex((binding) => binding.id === id);
-			if (index === -1) continue;
-			const updated = [...list];
-			updated[index] = next;
-			this.bindingsByKey.set(registryKey, updated);
-			return;
+	_deindexSimpleNamedBinding(tokenKeyValue, binding) {
+		const slot = binding.slot;
+		if (slot.name === void 0 || slot.tags.length > 0) return;
+		const byName = this._simpleNamed.get(tokenKeyValue);
+		if (byName === void 0) return;
+		if (byName.get(slot.name)?.id === binding.id) {
+			byName.delete(slot.name);
+			if (byName.size === 0) this._simpleNamed.delete(tokenKeyValue);
 		}
 	}
-	/**
-	* Replaces all bindings for `key` with a single new binding (module "last-wins" semantics).
-	* Unlike {@link remove} / {@link removeById}, this method invokes `onReplaced` for every
-	* evicted binding **before** inserting the replacement, giving the caller (e.g. the
-	* container's scope manager) a chance to release cached instances and run deactivation hooks.
-	*/
-	replaceKeyLastWins(key, binding, onReplaced) {
-		const registryKey = key;
-		const nextBinding = binding;
-		const existing = this.bindingsByKey.get(registryKey);
-		if (existing !== void 0) for (const removed of existing) onReplaced(removed);
-		this.bindingsByKey.set(registryKey, [nextBinding]);
+	_refreshFastDefaultForToken(tokenKeyValue) {
+		const list = this._bindings.get(tokenKeyValue);
+		if (list === void 0 || list.length !== 1) {
+			this._fastDefault.delete(tokenKeyValue);
+			return;
+		}
+		const onlyBinding = list[0];
+		if (!(onlyBinding.slot.name === void 0 && onlyBinding.slot.tags.length === 0) || onlyBinding.predicate !== void 0) {
+			this._fastDefault.delete(tokenKeyValue);
+			return;
+		}
+		this._fastDefault.set(tokenKeyValue, onlyBinding);
 	}
 };
 //#endregion

package/dist/resolve-options.d.mts

@@ -0,0 +1,18 @@
+import { ResolveOptions } from "./types.mjs";
+import { SlotKey } from "./binding.mjs";
+
+//#region src/resolve-options.d.ts
+/**
+ * Builds a {@link ResolveOptions} safe for `exactOptionalPropertyTypes`:
+ * omits keys instead of assigning `undefined`.
+ */
+declare function injectableSlotToResolveOptions(slot: {
+  readonly name?: string;
+  readonly tags?: ReadonlyArray<readonly [string, unknown]>;
+}): ResolveOptions | undefined;
+/**
+ * Hint from a binding {@link SlotKey} (tags may be empty; omits when nothing to match).
+ */
+declare function slotKeyToResolveOptions(slot: SlotKey): ResolveOptions | undefined;
+//#endregion
+export { injectableSlotToResolveOptions, slotKeyToResolveOptions };

package/dist/resolve-options.mjs

@@ -0,0 +1,22 @@
+//#region src/resolve-options.ts
+/**
+* Builds a {@link ResolveOptions} safe for `exactOptionalPropertyTypes`:
+* omits keys instead of assigning `undefined`.
+*/
+function injectableSlotToResolveOptions(slot) {
+	const options = {};
+	if (slot.name !== void 0) options.name = slot.name;
+	if (slot.tags !== void 0) options.tags = slot.tags;
+	return options.name !== void 0 || options.tags !== void 0 ? options : void 0;
+}
+/**
+* Hint from a binding {@link SlotKey} (tags may be empty; omits when nothing to match).
+*/
+function slotKeyToResolveOptions(slot) {
+	const options = {};
+	if (slot.name !== void 0) options.name = slot.name;
+	if (slot.tags.length > 0) options.tags = slot.tags;
+	return options.name !== void 0 || options.tags !== void 0 ? options : void 0;
+}
+//#endregion
+export { injectableSlotToResolveOptions, slotKeyToResolveOptions };