ts-ioc-container 72.1.0 → 72.2.0

package/typings/token/GroupAliasToken.d.ts

@@ -4,6 +4,18 @@ import { IRegistration } from '../registration/IRegistration.js';
 import { BindToken } from './BindToken.js';
 import { ArgsFn, ResolveOptions } from '../provider/IProvider.js';
 import { Serializable } from '../utils/basic.js';
+/**
+ * A token for every dependency registered under an alias. As a `bindTo(...)`
+ * target it adds the alias; resolving returns all matches as an array.
+ *
+ * @example
+ * const IMiddlewareToken = toGroupAlias<IMiddleware>('IMiddleware');
+ *
+ * @register(bindTo(IMiddlewareToken))
+ * class Auth implements IMiddleware {}
+ *
+ * IMiddlewareToken.resolve(scope); // IMiddleware[]
+ */
 export declare class GroupAliasToken<T = any> extends InjectionToken<T[]> implements BindToken<T>, Serializable {
     readonly token: DependencyKey;
     private readonly _getArgsFn;
@@ -22,4 +34,6 @@ export declare class GroupAliasToken<T = any> extends InjectionToken<T[]> implem
     addTags(...tags: string[]): GroupAliasToken<T>;
     toString(): string;
 }
+/** Creates a {@link GroupAliasToken} for `token`. */
 export declare const toGroupAlias: <T>(token: DependencyKey) => GroupAliasToken<T>;
+//# sourceMappingURL=GroupAliasToken.d.ts.map

package/typings/token/GroupAliasToken.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GroupAliasToken.d.ts","sourceRoot":"","sources":["../../lib/token/GroupAliasToken.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AACpE,OAAO,EAAe,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAC/D,OAAO,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAC9D,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC/D,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C;;;;;;;;;;;GAWG;AACH,qBAAa,eAAe,CAAC,CAAC,GAAG,GAAG,CAAE,SAAQ,cAAc,CAAC,CAAC,EAAE,CAAE,YAAW,SAAS,CAAC,CAAC,CAAC,EAAE,YAAY;IAKnG,QAAQ,CAAC,KAAK,EAAE,aAAa;IAJ/B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAU;gBAGvB,KAAK,EAAE,aAAa,EAC7B,EACE,SAAuB,EACvB,MAAc,EACd,IAAS,GACV,GAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,OAAO,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;KAAO;IAOnE,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,MAAM,EAAE,CAAC,EAAE,KAAK,CAAC,EAAE,IACxB,GAAG,UAAU;IAGvB,OAAO,CAAC,CAAC,EAAE,UAAU,EAAE,EAAE,IAAS,EAAE,IAAI,EAAE,GAAE,cAAmB,GAAG,CAAC,EAAE;IAOrE,MAAM,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC;IAI1B,IAAI,CAAC,GAAG,OAAO,EAAE,OAAO,EAAE;IAS1B,MAAM,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,OAAO,EAAE;IASvC,IAAI;IAQJ,OAAO,CAAC,GAAG,IAAI,EAAE,MAAM,EAAE,GAAG,eAAe,CAAC,CAAC,CAAC;IAQ9C,QAAQ,IAAI,MAAM;CAGnB;AAED,qDAAqD;AACrD,eAAO,MAAM,YAAY,GAAI,CAAC,EAAE,OAAO,aAAa,uBAAkC,CAAC"}

package/typings/token/GroupInstanceToken.d.ts

@@ -1,7 +1,12 @@
 import { InjectionToken } from './InjectionToken.js';
 import type { IContainer } from '../container/IContainer.js';
 import { Instance, Serializable } from '../utils/basic.js';
+/** Selects instances for a {@link GroupInstanceToken}. */
 export type InstancePredicate = (dep: unknown) => boolean;
+/**
+ * Resolves the instances already created in a scope (and, by default, its
+ * child scopes) that match a predicate. Created by `select.instances(...)`.
+ */
 export declare class GroupInstanceToken extends InjectionToken<Instance[]> implements Serializable {
     private predicate;
     private isCascade;
@@ -10,11 +15,25 @@ export declare class GroupInstanceToken extends InjectionToken<Instance[]> imple
         isCascade?: boolean;
     });
     select<R>(fn: (target: Instance) => R): (s: IContainer) => R[];
+    /**
+     * @throws {MethodNotImplementedError} always — a group instance token cannot receive static args.
+     */
     args(...deps: unknown[]): this;
+    /**
+     * @throws {MethodNotImplementedError} always — a group instance token cannot receive resolved args.
+     */
     argsFn(getArgsFn: (s: IContainer) => unknown[]): InjectionToken<Instance[]>;
+    /**
+     * @throws {MethodNotImplementedError} always — a group instance token cannot be made lazy.
+     */
     lazy(): InjectionToken<Instance[]>;
+    /** Whether instances of child scopes are included (default `true`). */
     cascade(isTrue: boolean): this;
     resolve(c: IContainer): Instance[];
     addTags(...tags: string[]): GroupInstanceToken;
+    /**
+     * @throws {MethodNotImplementedError} always — a group instance token has no underlying key.
+     */
     toString(): string;
 }
+//# sourceMappingURL=GroupInstanceToken.d.ts.map

package/typings/token/GroupInstanceToken.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GroupInstanceToken.d.ts","sourceRoot":"","sources":["../../lib/token/GroupInstanceToken.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAG1D,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAExD,0DAA0D;AAC1D,MAAM,MAAM,iBAAiB,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC;AAE1D;;;GAGG;AACH,qBAAa,kBAAmB,SAAQ,cAAc,CAAC,QAAQ,EAAE,CAAE,YAAW,YAAY;IAItF,OAAO,CAAC,SAAS;IAHnB,OAAO,CAAC,SAAS,CAAU;gBAGjB,SAAS,EAAE,iBAAiB,EACpC,EAAE,IAAS,EAAE,SAAgB,EAAE,GAAE;QAAE,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;QAAC,SAAS,CAAC,EAAE,OAAO,CAAA;KAAO;IAMhF,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,MAAM,EAAE,QAAQ,KAAK,CAAC,IAC3B,GAAG,UAAU;IAGvB;;OAEG;IACH,IAAI,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI;IAI9B;;OAEG;IACH,MAAM,CAAC,SAAS,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,OAAO,EAAE,GAAG,cAAc,CAAC,QAAQ,EAAE,CAAC;IAI3E;;OAEG;IACH,IAAI,IAAI,cAAc,CAAC,QAAQ,EAAE,CAAC;IAIlC,uEAAuE;IACvE,OAAO,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI;IAK9B,OAAO,CAAC,CAAC,EAAE,UAAU,GAAG,QAAQ,EAAE;IAIlC,OAAO,CAAC,GAAG,IAAI,EAAE,MAAM,EAAE,GAAG,kBAAkB;IAI9C;;OAEG;IACH,QAAQ,IAAI,MAAM;CAGnB"}

package/typings/token/InjectionToken.d.ts

@@ -1,6 +1,12 @@
 import { type IContainer, type Tag } from '../container/IContainer.js';
 import { ArgsFn, ResolveOptions } from '../provider/IProvider.js';
+/**
+ * The default `getArgsFn` of every token: the runtime `args` a token is
+ * resolved with reach the provider as they are, and `token.args(...)` /
+ * `token.argsFn(...)` append after them.
+ */
 export declare const forwardArgs: ArgsFn;
+/** Base class of every token: something resolvable from a scope that can be specialized with args, lazy and tags. */
 export declare abstract class InjectionToken<T = any> {
     private readonly tags;
     protected constructor(tags?: Tag[]);
@@ -12,4 +18,6 @@ export declare abstract class InjectionToken<T = any> {
     hasTag(tag: Tag): boolean;
     protected getTags(): Tag[];
 }
+/** Narrows `target` to an {@link InjectionToken}. */
 export declare function isInjectionToken<T = any>(target: unknown): target is InjectionToken<T>;
+//# sourceMappingURL=InjectionToken.d.ts.map

package/typings/token/InjectionToken.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InjectionToken.d.ts","sourceRoot":"","sources":["../../lib/token/InjectionToken.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,GAAG,EAAE,MAAM,yBAAyB,CAAC;AACpE,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAG/D;;;;GAIG;AACH,eAAO,MAAM,WAAW,EAAE,MAAgC,CAAC;AAE3D,qHAAqH;AACrH,8BAAsB,cAAc,CAAC,CAAC,GAAG,GAAG;IAC1C,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAW;IAEhC,SAAS,aAAa,IAAI,GAAE,GAAG,EAAO;IAItC,QAAQ,CAAC,OAAO,CAAC,CAAC,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,CAAC;IAC5D,QAAQ,CAAC,IAAI,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,cAAc,CAAC,CAAC,CAAC;IACpD,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,OAAO,EAAE,GAAG,cAAc,CAAC,CAAC,CAAC;IAC3E,QAAQ,CAAC,IAAI,IAAI,cAAc,CAAC,CAAC,CAAC;IAClC,QAAQ,CAAC,OAAO,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,cAAc,CAAC,CAAC,CAAC;IAEnD,MAAM,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO;IAIzB,SAAS,CAAC,OAAO,IAAI,GAAG,EAAE;CAG3B;AAED,qDAAqD;AACrD,wBAAgB,gBAAgB,CAAC,CAAC,GAAG,GAAG,EAAE,MAAM,EAAE,OAAO,GAAG,MAAM,IAAI,cAAc,CAAC,CAAC,CAAC,CAUtF"}

package/typings/token/SingleAliasToken.d.ts

@@ -4,6 +4,10 @@ import { IRegistration } from '../registration/IRegistration.js';
 import { BindToken } from './BindToken.js';
 import { ArgsFn, ResolveOptions } from '../provider/IProvider.js';
 import { Serializable } from '../utils/basic.js';
+/**
+ * Like {@link GroupAliasToken}, but resolves exactly one dependency registered
+ * under the alias, and throws `DependencyNotFoundError` when there is none.
+ */
 export declare class SingleAliasToken<T = any> extends InjectionToken<T> implements BindToken<T>, Serializable {
     readonly token: DependencyKey;
     private readonly _getArgsFn;
@@ -22,4 +26,6 @@ export declare class SingleAliasToken<T = any> extends InjectionToken<T> impleme
     addTags(...tags: string[]): SingleAliasToken<T>;
     toString(): string;
 }
+/** Creates a {@link SingleAliasToken} for `token`. */
 export declare const toSingleAlias: <T>(token: DependencyKey) => SingleAliasToken<T>;
+//# sourceMappingURL=SingleAliasToken.d.ts.map

package/typings/token/SingleAliasToken.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SingleAliasToken.d.ts","sourceRoot":"","sources":["../../lib/token/SingleAliasToken.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AACpE,OAAO,EAAe,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAC/D,OAAO,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAC9D,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC/D,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C;;;GAGG;AACH,qBAAa,gBAAgB,CAAC,CAAC,GAAG,GAAG,CAAE,SAAQ,cAAc,CAAC,CAAC,CAAE,YAAW,SAAS,CAAC,CAAC,CAAC,EAAE,YAAY;IAKlG,QAAQ,CAAC,KAAK,EAAE,aAAa;IAJ/B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAU;gBAGvB,KAAK,EAAE,aAAa,EAC7B,EACE,SAAuB,EACvB,MAAc,EACd,IAAS,GACV,GAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,OAAO,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;KAAO;IAOnE,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,IACpB,GAAG,UAAU;IAGvB,OAAO,CAAC,CAAC,EAAE,UAAU,EAAE,EAAE,IAAS,EAAE,IAAI,EAAE,GAAE,cAAmB,GAAG,CAAC;IAOnE,MAAM,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC;IAI1B,IAAI,CAAC,GAAG,OAAO,EAAE,OAAO,EAAE;IAS1B,MAAM,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,OAAO,EAAE;IASvC,IAAI;IAQJ,OAAO,CAAC,GAAG,IAAI,EAAE,MAAM,EAAE,GAAG,gBAAgB,CAAC,CAAC,CAAC;IAQ/C,QAAQ,IAAI,MAAM;CAGnB;AAED,sDAAsD;AACtD,eAAO,MAAM,aAAa,GAAI,CAAC,EAAE,OAAO,aAAa,wBAAmC,CAAC"}

package/typings/token/SingleToken.d.ts

@@ -3,6 +3,23 @@ import { InjectionToken } from './InjectionToken.js';
 import { IRegistration } from '../registration/IRegistration.js';
 import { ArgsFn, ResolveOptions } from '../provider/IProvider.js';
 import { Serializable } from '../utils/basic.js';
+/**
+ * A typed handle for one dependency key - the usual way to name a dependency.
+ * `args(...)`, `argsFn(...)` and `lazy()` return a new token and never change
+ * this one, so one token can be specialized per injection site.
+ *
+ * @example
+ * const ILoggerToken = new SingleToken<ILogger>('ILogger');
+ *
+ * @register(bindTo(ILoggerToken))
+ * class Logger implements ILogger {}
+ *
+ * class App {
+ *   constructor(@inject(by(ILoggerToken)) logger: ILogger) {}
+ * }
+ * ILoggerToken.resolve(scope);
+ * ILoggerToken.args('prefix').lazy().resolve(scope);
+ */
 export declare class SingleToken<T = any> extends InjectionToken<T> implements Serializable {
     token: DependencyKey;
     private readonly _getArgsFn;
@@ -21,3 +38,4 @@ export declare class SingleToken<T = any> extends InjectionToken<T> implements S
     addTags(...tags: string[]): SingleToken<T>;
     toString(): string;
 }
+//# sourceMappingURL=SingleToken.d.ts.map

package/typings/token/SingleToken.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SingleToken.d.ts","sourceRoot":"","sources":["../../lib/token/SingleToken.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AACpE,OAAO,EAAe,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAC/D,OAAO,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAC9D,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC/D,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,WAAW,CAAC,CAAC,GAAG,GAAG,CAAE,SAAQ,cAAc,CAAC,CAAC,CAAE,YAAW,YAAY;IAKxE,KAAK,EAAE,aAAa;IAJ7B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAU;gBAGzB,KAAK,EAAE,aAAa,EAC3B,EACE,SAAuB,EACvB,MAAc,EACd,IAAS,GACV,GAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,OAAO,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;KAAO;IAOnE,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,IACpB,GAAG,UAAU;IAGvB,OAAO,CAAC,CAAC,EAAE,UAAU,EAAE,EAAE,IAAS,EAAE,IAAI,EAAE,GAAE,cAAmB,GAAG,CAAC;IAOnE,MAAM,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC;IAI1B,IAAI,CAAC,GAAG,OAAO,EAAE,OAAO,EAAE;IAS1B,MAAM,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,OAAO,EAAE;IASvC,IAAI;IAQJ,OAAO,CAAC,GAAG,IAAI,EAAE,MAAM,EAAE,GAAG,WAAW,CAAC,CAAC,CAAC;IAQ1C,QAAQ,IAAI,MAAM;CAGnB"}

package/typings/token/toToken.d.ts

@@ -2,6 +2,18 @@ import { DependencyKey } from '../container/IContainer.js';
 import { InjectionToken } from './InjectionToken.js';
 import { InjectFn } from '../hooks/hook.js';
 import { type constructor } from '../utils/basic.js';
+/** Anything `toToken(...)` turns into a token: a token, a key, a class or an `InjectFn`. */
 export type Injectable<T = any> = InjectFn<T> | InjectionToken<T> | DependencyKey | constructor<T>;
+/**
+ * @throws {UnsupportedTokenTypeError} when `token` is not an `InjectionToken`, a `DependencyKey`, a constructor, or a function.
+ */
 export declare const toToken: <T = any>(token: Injectable<T>) => InjectionToken<T>;
+/**
+ * Wraps a runtime argument so it can be resolved uniformly: an `InjectionToken`
+ * is returned as-is, anything else becomes a `ConstantToken` of itself. The
+ * library never applies it to the args list - a call site that wants
+ * "resolve tokens, pass literals through" does so explicitly, e.g.
+ * `@inject(({ scope, args = [] }) => argToToken(args[0]).resolve(scope))`.
+ */
 export declare const argToToken: <T = unknown>(v: T) => InjectionToken<T>;
+//# sourceMappingURL=toToken.d.ts.map

package/typings/token/toToken.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toToken.d.ts","sourceRoot":"","sources":["../../lib/token/toToken.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAmB,MAAM,yBAAyB,CAAC;AAKzE,OAAO,EAAE,cAAc,EAAoB,MAAM,kBAAkB,CAAC;AACpE,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,KAAK,WAAW,EAAM,MAAM,gBAAgB,CAAC;AAGtD,4FAA4F;AAC5F,MAAM,MAAM,UAAU,CAAC,CAAC,GAAG,GAAG,IAAI,QAAQ,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,GAAG,aAAa,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC;AAEnG;;GAEG;AACH,eAAO,MAAM,OAAO,GAAI,CAAC,GAAG,GAAG,EAAE,OAAO,UAAU,CAAC,CAAC,CAAC,KAAG,cAAc,CAAC,CAAC,CAoBvE,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,GAAI,CAAC,GAAG,OAAO,EAAE,GAAG,CAAC,KAAG,cAAc,CAAC,CAAC,CAAwD,CAAC"}

package/typings/utils/ProxyRegistry.d.ts

@@ -1,20 +1,83 @@
+/**
+ * The proxy operations the library depends on. Depend on this rather than on
+ * {@link ProxyRegistry} itself, so a caller can substitute its own
+ * implementation - the concrete registry is a singleton and cannot be
+ * constructed a second time.
+ */
 export interface IProxyRegistry {
+    /**
+     * Returns the real object behind `value`, unwrapping proxies stacked to any
+     * depth. A value that is not a proxy is returned as is.
+     *
+     * The library calls this itself wherever a proxy would give the wrong answer -
+     * every read of class metadata (see `resolveConstructor`, `getHooks`,
+     * `resolveArgs`) and every identity check against a tracked instance (see
+     * `IContainer.hasInstance`). Pass the container's own values to those APIs as
+     * they come; unwrapping by hand is for code that needs the real object for its
+     * own reasons.
+     */
     unwrap<T extends object>(value: T): T;
     createProxy<T extends object>(target: T, handler?: ProxyHandler<T>): T;
+    /**
+     * Creates a proxy that resolves its target on first access and caches it.
+     */
     createLazyProxy<T extends object>(resolveInstance: () => T): T;
+    /**
+     * Wraps `resolveInstance` in a lazy proxy when `isLazy`, otherwise calls it
+     * right away.
+     */
     toLazyIf<T extends object>(resolveInstance: () => T, isLazy?: boolean): T;
 }
+/**
+ * Creates proxies and tracks them, so a proxy can be traced back to the real
+ * object it stands for. The library's own {@link IProxyRegistry}.
+ *
+ * Process-wide singleton: a proxy created anywhere must be unwrappable
+ * everywhere, and the registry holds no configuration that would justify a
+ * second instance. Obtain it with {@link ProxyRegistry.getInstance}.
+ *
+ * Entries are held weakly - a proxy that becomes unreachable is collected along
+ * with its state.
+ */
 export declare class ProxyRegistry implements IProxyRegistry {
     private static instance?;
     private readonly states;
     private constructor();
     static getInstance(): ProxyRegistry;
+    /**
+     * Returns the real object behind `value`, unwrapping proxies stacked to any
+     * depth. A value that is not a proxy is returned as is.
+     */
     unwrap<T extends object>(value: T): T;
     createProxy<T extends object>(target: T, handler?: ProxyHandler<T>): T;
+    /**
+     * Creates a proxy that resolves its target on first access and caches it.
+     * The target is unwrapped on resolution, so wrapping a lazy proxy in another
+     * lazy proxy never stacks beyond one level.
+     */
     createLazyProxy<T extends object>(resolveInstance: () => T): T;
+    /**
+     * Wraps `resolveInstance` in a lazy proxy when `isLazy`, otherwise calls it
+     * right away.
+     */
     toLazyIf<T extends object>(resolveInstance: () => T, isLazy?: boolean): T;
     private isProxy;
     private getTarget;
     private register;
 }
+/**
+ * The real object behind `value`, unwrapping proxies stacked to any depth. A
+ * value that is not a proxy is returned as is.
+ *
+ * A shortcut for `ProxyRegistry.getInstance().unwrap(value)` - the registry is a
+ * process-wide singleton, so unwrapping never needs an instance of its own. The
+ * library already unwraps wherever a proxy would give the wrong answer (reading
+ * class metadata, and `IContainer.hasInstance`), so reach for this only when
+ * your own code needs the real object - an identity check of your own, or
+ * bypassing a lazy proxy on purpose.
+ *
+ * Note that unwrapping a lazy proxy resolves its target, which is the point:
+ * there is no real object to hand back until it does.
+ */
 export declare const unwrapProxy: <T extends object>(value: T) => T;
+//# sourceMappingURL=ProxyRegistry.d.ts.map

package/typings/utils/ProxyRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProxyRegistry.d.ts","sourceRoot":"","sources":["../../lib/utils/ProxyRegistry.ts"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B;;;;;;;;;;OAUG;IACH,MAAM,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAAC;IAEtC,WAAW,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IAEvE;;OAEG;IACH,eAAe,CAAC,CAAC,SAAS,MAAM,EAAE,eAAe,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC;IAE/D;;;OAGG;IACH,QAAQ,CAAC,CAAC,SAAS,MAAM,EAAE,eAAe,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,CAAC,CAAC;CAC3E;AAED;;;;;;;;;;GAUG;AACH,qBAAa,aAAc,YAAW,cAAc;IAClD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAgB;IAExC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA6C;IAEpE,OAAO;IAEP,MAAM,CAAC,WAAW,IAAI,aAAa;IAKnC;;;OAGG;IACH,MAAM,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC;IAIrC,WAAW,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,OAAO,GAAE,YAAY,CAAC,CAAC,CAAM,GAAG,CAAC;IAK1E;;;;OAIG;IACH,eAAe,CAAC,CAAC,SAAS,MAAM,EAAE,eAAe,EAAE,MAAM,CAAC,GAAG,CAAC;IAgC9D;;;OAGG;IACH,QAAQ,CAAC,CAAC,SAAS,MAAM,EAAE,eAAe,EAAE,MAAM,CAAC,EAAE,MAAM,GAAE,OAAe,GAAG,CAAC;IAIhF,OAAO,CAAC,OAAO;IAIf,OAAO,CAAC,SAAS;IAKjB,OAAO,CAAC,QAAQ;CAIjB;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,MAAM,EAAE,OAAO,CAAC,KAAG,CAA8C,CAAC"}

package/typings/utils/TypedEvent.d.ts

@@ -1,17 +1,59 @@
 export type TypedEventListener<TArgs extends unknown[]> = (...args: TArgs) => void;
 export type Unsubscribe = () => void;
+/**
+ * The subscriber's side of a {@link TypedEvent}: attach, detach, tear down.
+ * Hand this out instead of the event itself so that only the owner can `emit`.
+ */
 export interface ITypedEvent<TArgs extends unknown[]> {
+    /**
+     * Attaches `listener` and returns a function which detaches it again. A
+     * listener subscribed more than once is still delivered each emission once.
+     *
+     * @throws {TypedEventDisposedError} when the event has already been disposed.
+     */
     subscribe(listener: TypedEventListener<TArgs>): Unsubscribe;
+    /**
+     * Detaches `listener`. Harmless when it is not subscribed, or after `dispose`.
+     */
     unsubscribe(listener: TypedEventListener<TArgs>): void;
+    /**
+     * Detaches every listener and rejects further `subscribe` / `emit` calls.
+     */
     dispose(): void;
 }
+/**
+ * A typed, multi-listener event. `TArgs` is the argument list a listener
+ * receives, so a `TypedEvent<[IContainer]>` accepts `(scope: IContainer) => void`
+ * listeners unchanged.
+ *
+ * Emission delivers to the listeners subscribed at the moment `emit` is called,
+ * in subscription order. A listener detached mid-emission is skipped for the
+ * rest of that emission; one attached mid-emission receives only later ones.
+ */
 export declare class TypedEvent<TArgs extends unknown[] = []> implements ITypedEvent<TArgs> {
     private readonly listeners;
     private isDisposed;
+    /**
+     * @throws {TypedEventDisposedError} when the event has already been disposed.
+     */
     subscribe(listener: TypedEventListener<TArgs>): Unsubscribe;
     unsubscribe(listener: TypedEventListener<TArgs>): void;
+    /**
+     * Calls every current listener with `args`. What a listener throws surfaces
+     * out of `emit` and stops delivery to the listeners after it.
+     *
+     * @throws {TypedEventDisposedError} when the event has already been disposed.
+     * @throws {unknown} rethrows whatever a listener threw.
+     */
     emit(...args: TArgs): void;
+    /**
+     * A copy of the current listeners, in subscription order.
+     */
     getListeners(): TypedEventListener<TArgs>[];
     dispose(): void;
+    /**
+     * @throws {TypedEventDisposedError} when the event has already been disposed.
+     */
     private validate;
 }
+//# sourceMappingURL=TypedEvent.d.ts.map

package/typings/utils/TypedEvent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypedEvent.d.ts","sourceRoot":"","sources":["../../lib/utils/TypedEvent.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,kBAAkB,CAAC,KAAK,SAAS,OAAO,EAAE,IAAI,CAAC,GAAG,IAAI,EAAE,KAAK,KAAK,IAAI,CAAC;AAEnF,MAAM,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC;AAErC;;;GAGG;AACH,MAAM,WAAW,WAAW,CAAC,KAAK,SAAS,OAAO,EAAE;IAClD;;;;;OAKG;IACH,SAAS,CAAC,QAAQ,EAAE,kBAAkB,CAAC,KAAK,CAAC,GAAG,WAAW,CAAC;IAE5D;;OAEG;IACH,WAAW,CAAC,QAAQ,EAAE,kBAAkB,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;IAEvD;;OAEG;IACH,OAAO,IAAI,IAAI,CAAC;CACjB;AAED;;;;;;;;GAQG;AACH,qBAAa,UAAU,CAAC,KAAK,SAAS,OAAO,EAAE,GAAG,EAAE,CAAE,YAAW,WAAW,CAAC,KAAK,CAAC;IACjF,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAwC;IAClE,OAAO,CAAC,UAAU,CAAS;IAE3B;;OAEG;IACH,SAAS,CAAC,QAAQ,EAAE,kBAAkB,CAAC,KAAK,CAAC,GAAG,WAAW;IAM3D,WAAW,CAAC,QAAQ,EAAE,kBAAkB,CAAC,KAAK,CAAC,GAAG,IAAI;IAItD;;;;;;OAMG;IACH,IAAI,CAAC,GAAG,IAAI,EAAE,KAAK,GAAG,IAAI;IAW1B;;OAEG;IACH,YAAY,IAAI,kBAAkB,CAAC,KAAK,CAAC,EAAE;IAI3C,OAAO,IAAI,IAAI;IAKf;;OAEG;IACH,OAAO,CAAC,QAAQ;CAMjB"}

package/typings/utils/array.d.ts

@@ -2,4 +2,11 @@ export type Predicate<T> = (value: T) => boolean;
 export declare const Filter: {
     exclude: <T>(arr: Set<T> | T[]) => (v: T) => boolean;
 };
+/**
+ * Returns a picker of the first argument in `args` matching `predicate` - the
+ * shape `singleton(getCacheKey)` consumers expect.
+ *
+ * @throws {ArgumentNotFoundError} when no argument matches `predicate`
+ */
 export declare const findOrFail: <T>(predicate: Predicate<T>) => (args?: unknown[]) => T;
+//# sourceMappingURL=array.d.ts.map

package/typings/utils/array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../../lib/utils/array.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC;AAEjD,eAAO,MAAM,MAAM;cACP,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,MAEpB,GAAG,CAAC;CAEf,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,UAAU,GACpB,CAAC,EAAE,WAAW,SAAS,CAAC,CAAC,CAAC,MAC1B,OAAM,OAAO,EAAO,KAAG,CAQvB,CAAC"}

package/typings/utils/basic.d.ts

@@ -1,10 +1,21 @@
+/** A class that constructs `T`. */
 export type constructor<T> = new (...args: any[]) => T;
+/** Something with a meaningful `toString()`, e.g. a token used as a cache key. */
 export interface Serializable {
     toString(): string;
 }
+/**
+ * Tags a structural type with a name, so `Instance` reads as its own type in
+ * signatures and error messages instead of a bare `object`. The tag is optional
+ * on purpose: values stay assignable without a cast.
+ */
 export type Branded<TBrand extends string, T> = T & {
     readonly __brand?: TBrand;
 };
+/**
+ * What the container tracks and reflects on: the object a constructor produced.
+ * Deliberately not a constructor signature - an instance is not its own constructor.
+ */
 export type Instance = Branded<'Instance', object>;
 export declare const Is: {
     nullish: <T>(value: T | undefined | null) => value is null | undefined;
@@ -14,3 +25,4 @@ export declare const Is: {
 };
 export declare function isSerializable(target: unknown): target is Serializable;
 export declare const toString: (target: unknown) => string;
+//# sourceMappingURL=basic.d.ts.map

package/typings/utils/basic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"basic.d.ts","sourceRoot":"","sources":["../../lib/utils/basic.ts"],"names":[],"mappings":"AAAA,mCAAmC;AACnC,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;AAEvD,kFAAkF;AAClF,MAAM,WAAW,YAAY;IAC3B,QAAQ,IAAI,MAAM,CAAC;CACpB;AAED;;;;GAIG;AACH,MAAM,MAAM,OAAO,CAAC,MAAM,SAAS,MAAM,EAAE,CAAC,IAAI,CAAC,GAAG;IAAE,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAElF;;;GAGG;AACH,MAAM,MAAM,QAAQ,GAAG,OAAO,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;AAEnD,eAAO,MAAM,EAAE;cACH,CAAC,SAAS,CAAC,GAAG,SAAS,GAAG,IAAI,KAAG,KAAK,IAAI,IAAI,GAAG,SAAS;qBACnD,OAAO,KAAG,MAAM,IAAI,MAAM;uBACxB,OAAO,KAAG,MAAM,IAAI,QAAQ;0BACzB,OAAO,KAAG,MAAM,IAAI,WAAW,CAAC,OAAO,CAAC;CAC/D,CAAC;AAGF,wBAAgB,cAAc,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,IAAI,YAAY,CAEtE;AAED,eAAO,MAAM,QAAQ,GAAI,QAAQ,OAAO,KAAG,MAAuE,CAAC"}

package/typings/utils/debounce.d.ts

@@ -1 +1,3 @@
+/** Method decorator: delays the call until `ms` passed without another call (per instance). */
 export declare const debounce: (ms: number) => MethodDecorator;
+//# sourceMappingURL=debounce.d.ts.map

package/typings/utils/debounce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debounce.d.ts","sourceRoot":"","sources":["../../lib/utils/debounce.ts"],"names":[],"mappings":"AAAA,+FAA+F;AAC/F,eAAO,MAAM,QAAQ,GAClB,IAAI,MAAM,KAAG,eAeb,CAAC"}

package/typings/utils/errorHandler.d.ts

@@ -1,6 +1,10 @@
+/** Receives the error with the class and method it came from. */
 export type HandleErrorParams = (error: unknown, context: {
     target: string;
     method: string;
 }) => void;
+/** Method decorator: routes a rejection of the async method to `errorHandler` instead of throwing. */
 export declare const handleAsyncError: (errorHandler: HandleErrorParams) => MethodDecorator;
+/** Method decorator: routes a throw of the method to `errorHandler` instead of throwing. */
 export declare const handleError: (errorHandler: HandleErrorParams) => MethodDecorator;
+//# sourceMappingURL=errorHandler.d.ts.map

package/typings/utils/errorHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errorHandler.d.ts","sourceRoot":"","sources":["../../lib/utils/errorHandler.ts"],"names":[],"mappings":"AAEA,iEAAiE;AACjE,MAAM,MAAM,iBAAiB,GAAG,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,KAAK,IAAI,CAAC;AAEtG,sGAAsG;AACtG,eAAO,MAAM,gBAAgB,GAC1B,cAAc,iBAAiB,KAAG,eAWlC,CAAC;AAEJ,4FAA4F;AAC5F,eAAO,MAAM,WAAW,GACrB,cAAc,iBAAiB,KAAG,eAWlC,CAAC"}

package/typings/utils/fp.d.ts

@@ -1,4 +1,11 @@
+/** A one-argument transform. */
 export type MapFn<A, B = A> = (value: A) => B;
+/**
+ * Composes functions left to right. With `by(...)` it maps an injected value.
+ *
+ * @example
+ * @inject(pipe(by(ConfigToken), (config) => config.apiUrl))
+ */
 export declare function pipe<A>(fn1: MapFn<A>): MapFn<A>;
 export declare function pipe<A, B>(fn1: MapFn<A, B>): MapFn<A, B>;
 export declare function pipe<A, B, C>(fn1: MapFn<A, B>, fn2: MapFn<B, C>): MapFn<A, C>;
@@ -11,3 +18,4 @@ export declare function pipe<A, B, C, D, E, F, G, H, I>(fn1: MapFn<A, B>, fn2: M
 export declare function pipe<A, B, C, D, E, F, G, H, I, J>(fn1: MapFn<A, B>, fn2: MapFn<B, C>, fn3: MapFn<C, D>, fn4: MapFn<D, E>, fn5: MapFn<E, F>, fn6: MapFn<F, G>, fn7: MapFn<G, H>, fn8: MapFn<H, I>, fn9: MapFn<I, J>): MapFn<A, J>;
 export declare function pipe<A, B, C, D, E, F, G, H, I, J, K>(fn1: MapFn<A, B>, fn2: MapFn<B, C>, fn3: MapFn<C, D>, fn4: MapFn<D, E>, fn5: MapFn<E, F>, fn6: MapFn<F, G>, fn7: MapFn<G, H>, fn8: MapFn<H, I>, fn9: MapFn<I, J>, fn10: MapFn<J, K>): MapFn<A, K>;
 export declare function pipe<T>(...mappers: MapFn<T>[]): MapFn<T>;
+//# sourceMappingURL=fp.d.ts.map

package/typings/utils/fp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fp.d.ts","sourceRoot":"","sources":["../../lib/utils/fp.ts"],"names":[],"mappings":"AAAA,gCAAgC;AAChC,MAAM,MAAM,KAAK,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,CAAC;AAG9C;;;;;GAKG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;AACjD,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAC1D,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAC/E,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AACpG,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAChC,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAChB,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAChB,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAChB,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,GACf,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AACf,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EACnC,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAChB,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAChB,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAChB,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAChB,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,GACf,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AACf,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EACtC,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAChB,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAChB,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAChB,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAChB,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAChB,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,GACf,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AACf,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EACzC,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAChB,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAChB,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAChB,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAChB,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAChB,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAChB,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,GACf,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AACf,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAC5C,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAChB,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAChB,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAChB,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAChB,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAChB,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAChB,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAChB,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,GACf,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AACf,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAC/C,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAChB,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAChB,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAChB,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAChB,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAChB,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAChB,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAChB,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAChB,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,GACf,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AACf,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAClD,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAChB,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAChB,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAChB,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAChB,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAChB,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAChB,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAChB,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAChB,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAChB,IAAI,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,GAChB,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAGf,wBAAgB,IAAI,CAAC,CAAC,EAAE,GAAG,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC"}

package/typings/utils/getConstructorChain.d.ts

@@ -1 +1,10 @@
+/**
+ * Walks a constructor's prototype chain, most-derived first, and collects each
+ * class in it: `[Derived, Base, ...]`, stopping before `Function.prototype`.
+ *
+ * Reading own metadata off each entry in turn is how a class inherits what its
+ * ancestors declared — `Reflect.getOwnMetadata` never looks up the chain itself.
+ * Anything which is not a function yields an empty chain.
+ */
 export declare const getConstructorChain: (ctor: unknown) => object[];
+//# sourceMappingURL=getConstructorChain.d.ts.map

package/typings/utils/getConstructorChain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getConstructorChain.d.ts","sourceRoot":"","sources":["../../lib/utils/getConstructorChain.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,GAAI,MAAM,OAAO,KAAG,MAAM,EAQzD,CAAC"}

package/typings/utils/memoize.d.ts

@@ -1 +1,11 @@
+/**
+ * Wraps a two-argument function so each `(target, key)` pair is computed once
+ * and reused. `target` is held weakly, so memoizing against a class or an
+ * instance keeps nothing alive.
+ *
+ * ```typescript
+ * const hooksOf = memoize((Target: constructor<unknown>, key: string | symbol) => merge(Target, key));
+ * ```
+ */
 export declare const memoize: <T extends object, K, R>(fn: (target: T, key: K) => R) => ((target: T, key: K) => R);
+//# sourceMappingURL=memoize.d.ts.map

package/typings/utils/memoize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memoize.d.ts","sourceRoot":"","sources":["../../lib/utils/memoize.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,eAAO,MAAM,OAAO,GAAI,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,KAAG,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,CAcvG,CAAC"}

package/typings/utils/once.d.ts

@@ -2,7 +2,9 @@ type RepeatOptions = {
     index: number;
     args: unknown[];
 };
+/** Method decorator: runs the method once per instance and returns the cached result afterwards. */
 export declare const once: ({ onRepeat }?: {
     onRepeat?: (options: RepeatOptions) => void;
 }) => MethodDecorator;
 export {};
+//# sourceMappingURL=once.d.ts.map

package/typings/utils/once.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"once.d.ts","sourceRoot":"","sources":["../../lib/utils/once.ts"],"names":[],"mappings":"AAAA,KAAK,aAAa,GAAG;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,OAAO,EAAE,CAAC;CACjB,CAAC;AAEF,oGAAoG;AACpG,eAAO,MAAM,IAAI,GACd,eAAc;IAAE,QAAQ,CAAC,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,IAAI,CAAA;CAAO,KAAG,eAgBrE,CAAC"}

package/typings/utils/shallowCache.d.ts

@@ -1 +1,3 @@
+/** Method decorator: caches results per instance by the key `getKeyByArgs` returns. */
 export declare const shallowCache: (getKeyByArgs: (...args: unknown[]) => unknown) => MethodDecorator;
+//# sourceMappingURL=shallowCache.d.ts.map

package/typings/utils/shallowCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shallowCache.d.ts","sourceRoot":"","sources":["../../lib/utils/shallowCache.ts"],"names":[],"mappings":"AAAA,uFAAuF;AACvF,eAAO,MAAM,YAAY,GACtB,cAAc,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,KAAG,eAmBhD,CAAC"}

package/typings/utils/task.d.ts

@@ -1,3 +1,16 @@
+/**
+ * A unit of work which may or may not go async: the sync-until-async shape the
+ * hook machinery is built on (ADR 0013).
+ */
 export type Task = () => void | Promise<void>;
+/**
+ * Runs `tasks` in order, staying synchronous until one returns a promise and
+ * awaiting the rest from that point. `undefined` when none went async.
+ */
 export declare const runInOrder: (tasks: Task[], from?: number) => void | Promise<void>;
+/**
+ * Starts every task at once. Settles once all have; `undefined` when none went
+ * async, so a fully synchronous run hands back no promise.
+ */
 export declare const runAtOnce: (tasks: Task[]) => void | Promise<void>;
+//# sourceMappingURL=task.d.ts.map

package/typings/utils/task.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task.d.ts","sourceRoot":"","sources":["../../lib/utils/task.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,MAAM,IAAI,GAAG,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAE9C;;;GAGG;AACH,eAAO,MAAM,UAAU,GAAI,OAAO,IAAI,EAAE,EAAE,aAAQ,KAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAOvE,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,SAAS,GAAI,OAAO,IAAI,EAAE,KAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAS5D,CAAC"}

package/typings/utils/throttle.d.ts

@@ -1 +1,3 @@
+/** Method decorator: ignores calls within `ms` of the last accepted one (per instance). */
 export declare const throttle: (ms: number) => MethodDecorator;
+//# sourceMappingURL=throttle.d.ts.map

package/typings/utils/throttle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"throttle.d.ts","sourceRoot":"","sources":["../../lib/utils/throttle.ts"],"names":[],"mappings":"AAAA,2FAA2F;AAC3F,eAAO,MAAM,QAAQ,GAClB,IAAI,MAAM,KAAG,eAcb,CAAC"}