@fnioc/di 1.0.0

package/dist/errors.js

@@ -0,0 +1,139 @@
+// Typed error classes for the runtime engine.
+//
+// Each failure mode the resolver can hit gets its own class so consumers can
+// branch on `instanceof` rather than string-matching messages. Messages are
+// written for a human reading a stack trace at the moment a graph fails to
+// resolve.
+/** Base class for every error the container raises. */
+export class DiError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = new.target.name;
+    }
+}
+/**
+ * A token was requested but no registration exists for it anywhere in the
+ * resolving scope's chain (nor on the builder's base map).
+ */
+export class UnregisteredTokenError extends DiError {
+    token;
+    constructor(token) {
+        super(`No registration found for token "${token}". Register it with ` +
+            `services.add(...)/.register(...) before resolving.`);
+        this.token = token;
+    }
+}
+/**
+ * A registration carries a lifetime tag, but no ancestor scope in the resolving
+ * chain has a matching name. This is the captive-dependency / misconfiguration
+ * detector — the engine never auto-creates a scope to satisfy the tag.
+ */
+export class MissingScopeError extends DiError {
+    token;
+    tag;
+    availableScopes;
+    constructor(token, tag, availableScopes) {
+        super(`Cannot resolve "${token}": its lifetime is tagged "${tag}", but no ` +
+            `ancestor scope with that name exists in the resolving chain ` +
+            `(available: ${availableScopes.length > 0
+                ? availableScopes.map((s) => `"${s}"`).join(" → ")
+                : "none"}). ` +
+            `This usually means a longer-lived service depends on a ` +
+            `shorter-lived one (e.g. a "singleton" needing a "request"). Never ` +
+            `auto-created — fix the registration's lifetime or create the scope.`);
+        this.token = token;
+        this.tag = tag;
+        this.availableScopes = availableScopes;
+    }
+}
+/**
+ * A constructor with parameters has no DepRecord in the WeakMap — the
+ * transformer never saw it and it was never hand-annotated.
+ */
+export class MissingMetadataError extends DiError {
+    token;
+    ctorName;
+    constructor(token, ctorName) {
+        super(`No dep metadata found for ${ctorName} (resolving "${token}"). The ` +
+            `constructor has parameters but no @signature, forCtor, or ` +
+            `transformer-generated defineDeps call was found. Use ` +
+            `forCtor(...).signature(...) or register it with useFactory to wire ` +
+            `it manually.`);
+        this.token = token;
+        this.ctorName = ctorName;
+    }
+}
+/**
+ * A constructor has DepRecord signatures, but none of them is directly
+ * satisfiable in the owning scope (every signature names at least one token
+ * that is not registered, or contains a hole this phase cannot fill).
+ */
+export class NoSatisfiableSignatureError extends DiError {
+    token;
+    ctorName;
+    unsatisfiable;
+    constructor(token, ctorName, unsatisfiable) {
+        super(`No satisfiable constructor signature for ${ctorName} (resolving ` +
+            `"${token}"). Every candidate signature names a dependency that is ` +
+            `not registered in the owning scope` +
+            (unsatisfiable.length > 0
+                ? `; unsatisfiable tokens: ${unsatisfiable
+                    .map((t) => `"${t}"`)
+                    .join(", ")}`
+                : "") +
+            `. Register the missing dependencies, or provide a useFactory ` +
+            `override.`);
+        this.token = token;
+        this.ctorName = ctorName;
+        this.unsatisfiable = unsatisfiable;
+    }
+}
+/**
+ * A token reappeared on the active resolution stack — the dependency graph has
+ * a cycle. The message includes the full path that closed the loop.
+ */
+export class CircularDependencyError extends DiError {
+    path;
+    constructor(path) {
+        super(`Circular dependency detected:\n  ${path.join(" → ")}`);
+        this.path = path;
+    }
+}
+/**
+ * A constructor parameter is typed as a factory of some token (a `FactoryRef`),
+ * but that token cannot be turned into a factory: either it is not registered,
+ * or it is registered as a `useValue` / `useFactory` override rather than a
+ * class. A factory injects a callable that constructs the target class on
+ * demand, so the target must be a class registration.
+ */
+export class FactoryTargetError extends DiError {
+    factoryToken;
+    reason;
+    constructor(factoryToken, reason) {
+        super(reason === "unregistered"
+            ? `Cannot inject a factory for "${factoryToken}": no registration ` +
+                `found for it. A factory parameter (typed \`() => IFoo\`) needs ` +
+                `the target registered as a class with ` +
+                `services.add(...) before it can build instances.`
+            : `Cannot inject a factory for "${factoryToken}": it is registered ` +
+                `as a useValue/useFactory override, not a class. A factory builds ` +
+                `its target with \`new\`, so the target must be a class ` +
+                `registration. Resolve it directly instead of as a factory, or ` +
+                `register the class with services.add(...).`);
+        this.factoryToken = factoryToken;
+        this.reason = reason;
+    }
+}
+/**
+ * Sync `dispose()` was called on a scope that owns a Promise-valued (thenable)
+ * cached instance. A pending Promise cannot be disposed synchronously — the
+ * caller must use `disposeAsync()`.
+ */
+export class AsyncDisposalRequiredError extends DiError {
+    constructor() {
+        super(`Cannot dispose synchronously: this scope owns a Promise-valued ` +
+            `instance (an async useFactory result). Awaiting it is required ` +
+            `before disposal — call disposeAsync() instead of dispose().`);
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,EAAE;AACF,6EAA6E;AAC7E,4EAA4E;AAC5E,2EAA2E;AAC3E,WAAW;AAIX,uDAAuD;AACvD,MAAM,OAAO,OAAQ,SAAQ,KAAK;IAChC,YAAmB,OAAe;QAChC,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC;IAC9B,CAAC;CACF;AAED;;;GAGG;AACH,MAAM,OAAO,sBAAuB,SAAQ,OAAO;IACd;IAAnC,YAAmC,KAAY;QAC7C,KAAK,CACH,oCAAoC,KAAK,sBAAsB;YAC7D,oDAAoD,CACvD,CAAC;QAJ+B,UAAK,GAAL,KAAK,CAAO;IAK/C,CAAC;CACF;AAED;;;;GAIG;AACH,MAAM,OAAO,iBAAkB,SAAQ,OAAO;IAE1B;IACA;IACA;IAHlB,YACkB,KAAY,EACZ,GAAW,EACX,eAAkC;QAElD,KAAK,CACH,mBAAmB,KAAK,8BAA8B,GAAG,YAAY;YACnE,8DAA8D;YAC9D,eACE,eAAe,CAAC,MAAM,GAAG,CAAC;gBACxB,CAAC,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC;gBAClD,CAAC,CAAC,MACN,KAAK;YACL,yDAAyD;YACzD,oEAAoE;YACpE,qEAAqE,CACxE,CAAC;QAfc,UAAK,GAAL,KAAK,CAAO;QACZ,QAAG,GAAH,GAAG,CAAQ;QACX,oBAAe,GAAf,eAAe,CAAmB;IAcpD,CAAC;CACF;AAED;;;GAGG;AACH,MAAM,OAAO,oBAAqB,SAAQ,OAAO;IAE7B;IACA;IAFlB,YACkB,KAAY,EACZ,QAAgB;QAEhC,KAAK,CACH,6BAA6B,QAAQ,gBAAgB,KAAK,UAAU;YAClE,4DAA4D;YAC5D,uDAAuD;YACvD,qEAAqE;YACrE,cAAc,CACjB,CAAC;QATc,UAAK,GAAL,KAAK,CAAO;QACZ,aAAQ,GAAR,QAAQ,CAAQ;IASlC,CAAC;CACF;AAED;;;;GAIG;AACH,MAAM,OAAO,2BAA4B,SAAQ,OAAO;IAEpC;IACA;IACA;IAHlB,YACkB,KAAY,EACZ,QAAgB,EAChB,aAA+B;QAE/C,KAAK,CACH,4CAA4C,QAAQ,cAAc;YAChE,IAAI,KAAK,2DAA2D;YACpE,oCAAoC;YACpC,CAAC,aAAa,CAAC,MAAM,GAAG,CAAC;gBACvB,CAAC,CAAC,2BAA2B,aAAa;qBACrC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC;qBACpB,IAAI,CAAC,IAAI,CAAC,EAAE;gBACjB,CAAC,CAAC,EAAE,CAAC;YACP,+DAA+D;YAC/D,WAAW,CACd,CAAC;QAfc,UAAK,GAAL,KAAK,CAAO;QACZ,aAAQ,GAAR,QAAQ,CAAQ;QAChB,kBAAa,GAAb,aAAa,CAAkB;IAcjD,CAAC;CACF;AAED;;;GAGG;AACH,MAAM,OAAO,uBAAwB,SAAQ,OAAO;IACf;IAAnC,YAAmC,IAAsB;QACvD,KAAK,CAAC,oCAAoC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;QAD7B,SAAI,GAAJ,IAAI,CAAkB;IAEzD,CAAC;CACF;AAED;;;;;;GAMG;AACH,MAAM,OAAO,kBAAmB,SAAQ,OAAO;IAE3B;IACA;IAFlB,YACkB,YAAmB,EACnB,MAAsC;QAEtD,KAAK,CACH,MAAM,KAAK,cAAc;YACvB,CAAC,CAAC,gCAAgC,YAAY,qBAAqB;gBAC/D,iEAAiE;gBACjE,wCAAwC;gBACxC,kDAAkD;YACtD,CAAC,CAAC,gCAAgC,YAAY,sBAAsB;gBAChE,mEAAmE;gBACnE,yDAAyD;gBACzD,gEAAgE;gBAChE,4CAA4C,CACnD,CAAC;QAdc,iBAAY,GAAZ,YAAY,CAAO;QACnB,WAAM,GAAN,MAAM,CAAgC;IAcxD,CAAC;CACF;AAED;;;;GAIG;AACH,MAAM,OAAO,0BAA2B,SAAQ,OAAO;IACrD;QACE,KAAK,CACH,iEAAiE;YAC/D,iEAAiE;YACjE,6DAA6D,CAChE,CAAC;IACJ,CAAC;CACF"}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { DiBuilder } from "./builder.js";
+export type { AddBuilder } from "./builder.js";
+export { Scope } from "./scope.js";
+export type { Ctor, Factory, OverrideSpec, Registration, ClassRegistration, FactoryRegistration, ValueRegistration, ResolveScope, } from "./types.js";
+export { DiError, UnregisteredTokenError, MissingScopeError, MissingMetadataError, NoSatisfiableSignatureError, FactoryTargetError, CircularDependencyError, AsyncDisposalRequiredError, } from "./errors.js";
+export { signature, forCtor, hole } from "@fnioc/core";
+export type { Token, DepRecord, ForCtorBuilder } from "@fnioc/core";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,YAAY,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE/C,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC,YAAY,EACV,IAAI,EACJ,OAAO,EACP,YAAY,EACZ,YAAY,EACZ,iBAAiB,EACjB,mBAAmB,EACnB,iBAAiB,EACjB,YAAY,GACb,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,OAAO,EACP,sBAAsB,EACtB,iBAAiB,EACjB,oBAAoB,EACpB,2BAA2B,EAC3B,kBAAkB,EAClB,uBAAuB,EACvB,0BAA0B,GAC3B,MAAM,aAAa,CAAC;AAMrB,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AACvD,YAAY,EAAE,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC"}

package/dist/index.js

@@ -0,0 +1,23 @@
+// @fnioc/di — the ioc runtime engine.
+//
+// Consumes the plain-data ABI emitted by @fnioc/transformer (or hand-fed via
+// @fnioc/core's authoring surfaces) and resolves the dependency graph. Never
+// touches a TypeScript type — works purely on string tokens and the positional
+// DepRecord signatures in the global WeakMap.
+//
+// Phase 2A scope: registration, the scope chain + tagged lifetimes, resolution
+// with the captive-dependency rule, greedy signature selection, cycle
+// detection, the useFactory/useValue overrides, and native disposal.
+//
+// Phase 2D.2 adds factory injection (a ctor param typed `() => IFoo` becomes an
+// injected callable) and hole-filling (a caller-supplied parameter filled
+// positionally at factory call time).
+export { DiBuilder } from "./builder.js";
+export { Scope } from "./scope.js";
+export { DiError, UnregisteredTokenError, MissingScopeError, MissingMetadataError, NoSatisfiableSignatureError, FactoryTargetError, CircularDependencyError, AsyncDisposalRequiredError, } from "./errors.js";
+// Re-exported from @fnioc/core for one-import authoring ergonomics. These are
+// pure metadata writers with zero resolution dependency; living in `core` keeps
+// the ABI self-contained, but consumers writing both registrations and manual
+// annotations get them from a single import here.
+export { signature, forCtor, hole } from "@fnioc/core";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,sCAAsC;AACtC,EAAE;AACF,6EAA6E;AAC7E,6EAA6E;AAC7E,+EAA+E;AAC/E,8CAA8C;AAC9C,EAAE;AACF,+EAA+E;AAC/E,sEAAsE;AACtE,qEAAqE;AACrE,EAAE;AACF,gFAAgF;AAChF,0EAA0E;AAC1E,sCAAsC;AAEtC,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAGzC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAanC,OAAO,EACL,OAAO,EACP,sBAAsB,EACtB,iBAAiB,EACjB,oBAAoB,EACpB,2BAA2B,EAC3B,kBAAkB,EAClB,uBAAuB,EACvB,0BAA0B,GAC3B,MAAM,aAAa,CAAC;AAErB,8EAA8E;AAC9E,gFAAgF;AAChF,8EAA8E;AAC9E,kDAAkD;AAClD,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC"}

package/dist/scope.d.ts

@@ -0,0 +1,180 @@
+import type { Token } from "@fnioc/core";
+import type { Registration, ResolveScope } from "./types.js";
+/**
+ * A node in the scope chain. Created from a `DiBuilder` (the root) or from a
+ * parent scope (`.createScope`). Holds the instances it owns and any local
+ * override registrations.
+ *
+ * The generic `Scopes` is the user's scope-name union, threaded so
+ * `.createScope` only accepts declared names.
+ */
+export declare class Scope<Scopes extends string = string> implements ResolveScope {
+    /** This scope's tag name. The root scope's name is its lifetime. */
+    readonly name: Scopes;
+    /** The parent scope, or `undefined` for the root. */
+    private readonly parent;
+    /** The builder's base registration map (shared, walked last). */
+    private readonly baseRegistrations;
+    /** Local override registrations held at this scope (shadow ancestors). */
+    private readonly localRegistrations;
+    /** Instances this scope owns and caches, keyed by token. */
+    private readonly instances;
+    /** Owned instances in construction order — disposed in reverse. */
+    private readonly ownedOrder;
+    private disposed;
+    constructor(
+    /** This scope's tag name. The root scope's name is its lifetime. */
+    name: Scopes, 
+    /** The parent scope, or `undefined` for the root. */
+    parent: Scope<Scopes> | undefined, 
+    /** The builder's base registration map (shared, walked last). */
+    baseRegistrations: ReadonlyMap<Token, Registration>);
+    /** Creates a parent-linked child scope with the given (declared) name. */
+    createScope(childName: Scopes): Scope<Scopes>;
+    /**
+     * Registers a scope-local override. Shadows any ancestor or base registration
+     * for the same token, for this scope and its descendants only. The override
+     * paths (`useFactory` / `useValue`) are also available here so a single scope
+     * (e.g. a test scope) can swap an implementation without rebuilding the
+     * builder.
+     */
+    registerFactory<T>(token: Token, useFactory: (scope: ResolveScope) => T, tag?: Scopes): this;
+    /** Registers a scope-local `useValue` override (see `registerFactory`). */
+    registerValue<T>(token: Token, useValue: T): this;
+    /**
+     * Resolves a token to an instance, walking the parent chain for both the
+     * registration and the owning scope. The public entry point starts a fresh
+     * cycle-detection stack.
+     */
+    resolve<T>(token: Token): T;
+    /**
+     * Walks UP the chain (this scope's locals → ancestors' locals → base map),
+     * returning the nearest registration for `token`. Child shadows parent.
+     */
+    private lookup;
+    /**
+     * Finds the nearest ancestor scope (inclusive of this one) whose name matches
+     * `tag`, walking UP the chain. Returns `undefined` when none matches.
+     */
+    private findOwner;
+    /** The chain of scope names from this scope up to the root, for diagnostics. */
+    private chainNames;
+    /**
+     * The internal resolver. `stack` is the active resolution path (for cycle
+     * detection); it is shared across the whole `resolve()` call but never across
+     * separate calls.
+     */
+    private resolveWith;
+    /**
+     * Builds an instance for `registration`. `owningScope` is the scope whose
+     * chain the dependencies are resolved against — THE critical rule. For a
+     * factory override that is the scope passed to the closure; for a class it is
+     * the scope its ctor deps resolve relative to.
+     */
+    private instantiate;
+    /**
+     * Constructs a class instance on a DIRECT resolve, resolving its constructor
+     * dependencies relative to THIS scope (the owning scope). Performs greedy
+     * signature selection over the ctor's DepRecord, then fills each slot:
+     *
+     *   - a string token → resolved through this scope's chain (selection
+     *     guarantees every string-token slot here is resolvable);
+     *   - a `FactoryRef` → injected as a callable (see `makeFactory`);
+     *   - a `null` hole → there is no caller on a direct resolve, so it lands as
+     *     `undefined`. Holes are meaningfully filled only when the class is a
+     *     factory target — see `constructPartitioned`.
+     */
+    private construct;
+    /**
+     * Builds the callable injected for a `FactoryRef` parameter.
+     *
+     * The target ctor's signature is partitioned at CALL time against the live
+     * registration map: each slot that is a registered token is resolved; each
+     * slot that is an unregistered token or a `null` hole takes the next
+     * caller-supplied argument, positionally. The injected callable therefore
+     * exposes only the target's unregistered parameters, in their relative order
+     * — no Ramda-style placeholders, no leaked constructor arity.
+     *
+     * Lifetime semantics:
+     *   - A ZERO-ARG factory (the target ctor has no holes / unregistered params)
+     *     routes the build through the normal `resolve` path, so it RESPECTS the
+     *     target's registered lifetime: a singleton target yields the same
+     *     instance on every call; a transient target yields a fresh one.
+     *   - A PARAMETERIZED factory (the target has holes / unregistered params
+     *     filled per call) constructs a FRESH instance on every call and BYPASSES
+     *     the instance cache. Caller args differ per call, so caching would be
+     *     wrong — two calls with different arguments must not collapse to one
+     *     cached instance.
+     *
+     * The closure captures `this` as the owning scope. §5.4 holds at call time:
+     * the target's deps resolve relative to the scope that owns the
+     * factory-holding instance, exactly as a direct resolve would — so a factory
+     * captured by a singleton that tries to build a request-scoped target still
+     * throws `MissingScopeError` when invoked.
+     */
+    private makeFactory;
+    /**
+     * Constructs a factory target, partitioning its already-selected signature
+     * against the live registration map: a registered token is resolved; an
+     * unregistered token or a `null` hole takes the next caller-supplied argument
+     * positionally. Always a fresh instance — a parameterized factory bypasses
+     * the instance cache (caller args differ per call). Runs on a fresh cycle
+     * stack since the factory is invoked outside the original resolve.
+     */
+    private constructPartitioned;
+    /**
+     * Greedy signature selection. Scans signatures longest → shortest and returns
+     * the first SATISFIABLE one. A slot is satisfiable when it is:
+     *
+     *   - a `null` hole — always satisfiable; filled by a caller arg (a direct
+     *     resolve supplies nothing, so it lands as `undefined`);
+     *   - a `FactoryRef` — always satisfiable; injected as a callable. The
+     *     factory's target need not be resolvable for the slot to count (an
+     *     unregistered target surfaces a `FactoryTargetError` when the factory is
+     *     built / called, not here); or
+     *   - a string token whose registration is resolvable in this (the owning)
+     *     scope's chain.
+     *
+     * Only string tokens can be UNsatisfiable. A signature is satisfiable iff
+     * every string-token slot is resolvable.
+     *
+     * - Equal-arity ties break by registration order (the order signatures appear
+     *   in the DepRecord), which `sort`'s stability preserves.
+     * - None satisfiable ⇒ throw naming the unsatisfiable tokens.
+     */
+    private selectSignature;
+    /**
+     * Greedy signature selection for a FACTORY TARGET. Unlike `selectSignature`,
+     * there is no resolvability gate: a target's unregistered tokens are not
+     * unsatisfiable — they are the factory's caller-supplied parameters. So the
+     * choice is purely the longest signature, equal-arity ties broken by
+     * registration order (`sort` stability). Always returns a signature (the
+     * caller has already checked `signatures.length > 0`).
+     */
+    private selectTargetSignature;
+    /** True when `token` has a registration somewhere in this scope's chain. */
+    private isResolvable;
+    /**
+     * Closes this scope synchronously, disposing the instances it owns in REVERSE
+     * construction order. Only native `Disposable` instances are disposed.
+     *
+     * Throws `AsyncDisposalRequiredError` if any owned instance is a Promise
+     * (thenable) — a pending Promise cannot be disposed synchronously; the caller
+     * must use `disposeAsync()`. Idempotent: a second call is a no-op.
+     */
+    dispose(): void;
+    /**
+     * Closes this scope asynchronously. Awaits each owned Promise-valued instance
+     * first (so an async factory's result settles before teardown), then disposes
+     * owned instances in REVERSE construction order — honoring both
+     * `Symbol.asyncDispose` and `Symbol.dispose`. Idempotent.
+     */
+    disposeAsync(): Promise<void>;
+    /** Drops owned references after disposal so they can be collected. */
+    private clear;
+    /** Native `using` support — delegates to `dispose()`. */
+    [Symbol.dispose](): void;
+    /** Native `await using` support — delegates to `disposeAsync()`. */
+    [Symbol.asyncDispose](): Promise<void>;
+}
+//# sourceMappingURL=scope.d.ts.map

package/dist/scope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scope.d.ts","sourceRoot":"","sources":["../src/scope.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAuB,KAAK,EAAE,MAAM,aAAa,CAAC;AAW9D,OAAO,KAAK,EAGV,YAAY,EACZ,YAAY,EACb,MAAM,YAAY,CAAC;AA4CpB;;;;;;;GAOG;AACH,qBAAa,KAAK,CAAC,MAAM,SAAS,MAAM,GAAG,MAAM,CAAE,YAAW,YAAY;IAatE,oEAAoE;aACpD,IAAI,EAAE,MAAM;IAC5B,qDAAqD;IACrD,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,iEAAiE;IACjE,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAjBpC,0EAA0E;IAC1E,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAkC;IAErE,4DAA4D;IAC5D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA6B;IAEvD,mEAAmE;IACnE,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAiB;IAE5C,OAAO,CAAC,QAAQ,CAAS;;IAGvB,oEAAoE;IACpD,IAAI,EAAE,MAAM;IAC5B,qDAAqD;IACpC,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,GAAG,SAAS;IAClD,iEAAiE;IAChD,iBAAiB,EAAE,WAAW,CAAC,KAAK,EAAE,YAAY,CAAC;IAGtE,0EAA0E;IACnE,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC;IAIpD;;;;;;OAMG;IACI,eAAe,CAAC,CAAC,EACtB,KAAK,EAAE,KAAK,EACZ,UAAU,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,CAAC,EACtC,GAAG,CAAC,EAAE,MAAM,GACX,IAAI;IASP,2EAA2E;IACpE,aAAa,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC,GAAG,IAAI;IAKxD;;;;OAIG;IACI,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,GAAG,CAAC;IAMlC;;;OAGG;IACH,OAAO,CAAC,MAAM;IAWd;;;OAGG;IACH,OAAO,CAAC,SAAS;IAUjB,gFAAgF;IAChF,OAAO,CAAC,UAAU;IAalB;;;;OAIG;IACH,OAAO,CAAC,WAAW;IAsDnB;;;;;OAKG;IACH,OAAO,CAAC,WAAW;IAmBnB;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,SAAS;IAgCjB;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,OAAO,CAAC,WAAW;IAgDnB;;;;;;;OAOG;IACH,OAAO,CAAC,oBAAoB;IAqB5B;;;;;;;;;;;;;;;;;;;OAmBG;IACH,OAAO,CAAC,eAAe;IAiCvB;;;;;;;OAOG;IACH,OAAO,CAAC,qBAAqB;IAY7B,4EAA4E;IAC5E,OAAO,CAAC,YAAY;IAMpB;;;;;;;OAOG;IACI,OAAO,IAAI,IAAI;IAmBtB;;;;;OAKG;IACU,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAsB1C,sEAAsE;IACtE,OAAO,CAAC,KAAK;IAKb,yDAAyD;IAClD,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,IAAI;IAI/B,oEAAoE;IAC7D,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC;CAG9C"}