@typed/fx 2.0.0-beta.1 → 2.0.0-beta.10

package/dist/Fx/internal/diff.js

@@ -1,23 +1,111 @@
 import * as Equal from "effect/Equal";
 import { identity } from "effect/Function";
+/** Constructs an immutable `Add` change record.
+ *
+ * @remarks
+ * ## Why
+ *
+ * Central construction keeps the discriminant and index meaning consistent for diff consumers.
+ *
+ * ## Ownership and lifetime
+ *
+ * Allocates one plain object and acquires no services or Scope.
+ *
+ * @example
+ * ```ts
+ * import { add } from "@typed/fx/Fx/internal/diff"
+ *
+ * const patch = add({ id: "a" }, 0, "a")
+ * ```
+ *
+ * @since 1.0.0
+ * @category constructors
+ * @stability internal-but-published
+ */
 export const add = (value, index, key) => ({
     _tag: "Add",
     index,
     value,
     key,
 });
+/** Constructs an immutable `Remove` change record.
+ *
+ * @remarks
+ * ## Why
+ *
+ * Central construction preserves the old-index convention expected by keyed consumers.
+ *
+ * ## Ownership and lifetime
+ *
+ * Allocates one plain object and acquires no services or Scope.
+ *
+ * @example
+ * ```ts
+ * import { remove } from "@typed/fx/Fx/internal/diff"
+ *
+ * const patch = remove({ id: "a" }, 0, "a")
+ * ```
+ *
+ * @since 1.0.0
+ * @category constructors
+ * @stability internal-but-published
+ */
 export const remove = (value, index, key) => ({
     _tag: "Remove",
     index,
     value,
     key,
 });
+/** Constructs an immutable `Update` change record.
+ *
+ * @remarks
+ * ## Why
+ *
+ * Central construction preserves the shared-index convention expected by keyed consumers.
+ *
+ * ## Ownership and lifetime
+ *
+ * Allocates one plain object and acquires no services or Scope.
+ *
+ * @example
+ * ```ts
+ * import { update } from "@typed/fx/Fx/internal/diff"
+ *
+ * const patch = update({ id: "a", value: 2 }, 0, "a")
+ * ```
+ *
+ * @since 1.0.0
+ * @category constructors
+ * @stability internal-but-published
+ */
 export const update = (value, index, key) => ({
     _tag: "Update",
     index,
     value,
     key,
 });
+/** Constructs an immutable `Moved` change record.
+ *
+ * @remarks
+ * ## Why
+ *
+ * Central construction keeps source and destination index meanings explicit.
+ *
+ * ## Ownership and lifetime
+ *
+ * Allocates one plain object and acquires no services or Scope.
+ *
+ * @example
+ * ```ts
+ * import { moved } from "@typed/fx/Fx/internal/diff"
+ *
+ * const patch = moved({ id: "a" }, 0, 1, "a")
+ * ```
+ *
+ * @since 1.0.0
+ * @category constructors
+ * @stability internal-but-published
+ */
 export const moved = (value, from, to, key) => ({
     _tag: "Moved",
     index: from,
@@ -91,16 +179,39 @@ export function* diffIterator(a, b, options = {}) {
         }
     }
 }
-const keysMaps = new WeakMap();
+/** Builds a map from each extracted key to its current array index.
+ *
+ * @remarks
+ * ## Why
+ *
+ * Exposing map construction lets repeated diff callers cache the previous array's index and avoid
+ * re-extracting those keys on the next transition.
+ *
+ * ## Ownership and lifetime
+ *
+ * The returned map is newly allocated and retains each key until released. The input array is read
+ * once and not retained by the map. Duplicate keys are not rejected: the last occurrence wins, so
+ * callers that require an unambiguous diff must validate uniqueness separately.
+ *
+ * The operation is O(n) time and O(n) space, plus the cost of `getKey` and Map hashing.
+ *
+ * @example
+ * ```ts
+ * import { getKeyMap } from "@typed/fx/Fx/internal/diff"
+ *
+ * const map = getKeyMap([{ id: "a" }, { id: "b" }], ({ id }) => id)
+ * map.get("b") // 1
+ * ```
+ *
+ * @since 1.0.0
+ * @category advanced
+ * @stability internal-but-published
+ */
 export function getKeyMap(a, getKey) {
-    let keyMap = keysMaps.get(a);
-    if (keyMap === undefined) {
-        keyMap = new Map();
-        keysMaps.set(a, keyMap);
-        const len = a.length;
-        for (let i = 0; i < len; ++i) {
-            keyMap.set(getKey(a[i]), i);
-        }
+    const keyMap = new Map();
+    const len = a.length;
+    for (let i = 0; i < len; ++i) {
+        keyMap.set(getKey(a[i]), i);
     }
     return keyMap;
 }

package/dist/Fx/internal/effectableEvaluateKey.d.ts

@@ -0,0 +1,30 @@
+/** The Effect runtime property key used to evaluate an Effectable value.
+ *
+ * @remarks
+ * ## Why
+ *
+ * Effect's generator interpreter steps yielded Effectable objects through this property. Typed
+ * must use the exact runtime key so its Effect-compatible Fx and state objects evaluate their
+ * underlying work rather than returning themselves.
+ *
+ * ## Ownership and lifetime
+ *
+ * This is immutable protocol metadata. Reading it acquires no services and retains no resources.
+ *
+ * The value must remain byte-for-byte aligned with Effect's internal
+ * `` `${EffectTypeId}/evaluate` `` key. It is therefore published for advanced implementors but is
+ * coupled to Effect runtime internals and may change between prereleases.
+ *
+ * @example
+ * ```ts
+ * import { EFFECT_EVALUATE_KEY } from "@typed/fx/Fx/internal/effectableEvaluateKey"
+ *
+ * EFFECT_EVALUATE_KEY // "~effect/Effect/evaluate"
+ * ```
+ *
+ * @since 1.0.0
+ * @category advanced
+ * @stability internal-but-published
+ */
+export declare const EFFECT_EVALUATE_KEY: "~effect/Effect/evaluate";
+//# sourceMappingURL=effectableEvaluateKey.d.ts.map

package/dist/Fx/internal/effectableEvaluateKey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effectableEvaluateKey.d.ts","sourceRoot":"","sources":["../../../src/Fx/internal/effectableEvaluateKey.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,mBAAmB,EAAG,yBAAkC,CAAC"}

package/dist/Fx/internal/effectableEvaluateKey.js

@@ -0,0 +1,29 @@
+/** The Effect runtime property key used to evaluate an Effectable value.
+ *
+ * @remarks
+ * ## Why
+ *
+ * Effect's generator interpreter steps yielded Effectable objects through this property. Typed
+ * must use the exact runtime key so its Effect-compatible Fx and state objects evaluate their
+ * underlying work rather than returning themselves.
+ *
+ * ## Ownership and lifetime
+ *
+ * This is immutable protocol metadata. Reading it acquires no services and retains no resources.
+ *
+ * The value must remain byte-for-byte aligned with Effect's internal
+ * `` `${EffectTypeId}/evaluate` `` key. It is therefore published for advanced implementors but is
+ * coupled to Effect runtime internals and may change between prereleases.
+ *
+ * @example
+ * ```ts
+ * import { EFFECT_EVALUATE_KEY } from "@typed/fx/Fx/internal/effectableEvaluateKey"
+ *
+ * EFFECT_EVALUATE_KEY // "~effect/Effect/evaluate"
+ * ```
+ *
+ * @since 1.0.0
+ * @category advanced
+ * @stability internal-but-published
+ */
+export const EFFECT_EVALUATE_KEY = "~effect/Effect/evaluate";

package/dist/Fx/internal/effectableWithOverride.d.ts

@@ -0,0 +1,55 @@
+import { Effectable } from "effect";
+import type * as Effect from "effect/Effect";
+/** Effectable base class whose generator evaluation delegates to an explicit Effect.
+ *
+ * @remarks
+ * ## Why
+ *
+ * Effect 4's `Effectable.Class` evaluates to the object itself. Typed's yieldable objects instead
+ * need `Effect.gen` to execute their `override` Effect. The prototype protocol installed below
+ * returns that Effect and avoids recursively yielding the same object.
+ *
+ * ## Ownership and lifetime
+ *
+ * The base class owns no fiber or Scope. Subclasses own the Effect assigned to `override` and all
+ * resources that Effect acquires. Execution preserves its value, typed error, service, interruption,
+ * and finalization channels.
+ *
+ * This class is a published extension point, but it is coupled to Effect's evaluator protocol and
+ * may change between prereleases.
+ *
+ * @example
+ * ```ts
+ * import { EffectableWithOverride } from "@typed/fx/Fx/internal/effectableWithOverride"
+ * import * as Effect from "effect/Effect"
+ *
+ * class Answer extends EffectableWithOverride<number> {
+ *   readonly override = Effect.succeed(42)
+ * }
+ *
+ * const value = Effect.runSync(new Answer()) // 42
+ * ```
+ *
+ * @since 1.0.0
+ * @category advanced
+ * @stability internal-but-published
+ */
+export declare abstract class EffectableWithOverride<A, E = never, R = never> extends Effectable.Class<A, E, R> {
+    /** The real Effect executed when this object is yielded or otherwise evaluated by Effect.
+     *
+     * @remarks
+     * ## Why
+     *
+     * Subclasses must return stable work for the lifetime semantics they advertise; the base class
+     * neither memoizes nor scopes it.
+     *
+     * ## Ownership and lifetime
+     *
+     * The subclass owns this Effect and every resource it acquires; the evaluator only delegates.
+     *
+     * @since 1.0.0
+     * @category effects
+     */
+    abstract override: Effect.Effect<A, E, R>;
+}
+//# sourceMappingURL=effectableWithOverride.d.ts.map

package/dist/Fx/internal/effectableWithOverride.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effectableWithOverride.d.ts","sourceRoot":"","sources":["../../../src/Fx/internal/effectableWithOverride.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AACpC,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAC;AAG7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,8BAAsB,sBAAsB,CAAC,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,KAAK,CAAE,SAAQ,UAAU,CAAC,KAAK,CAC5F,CAAC,EACD,CAAC,EACD,CAAC,CACF;IACC;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;CAC3C"}

package/dist/Fx/internal/effectableWithOverride.js

@@ -0,0 +1,46 @@
+import { Effectable } from "effect";
+import { EFFECT_EVALUATE_KEY } from "./effectableEvaluateKey.js";
+/** Effectable base class whose generator evaluation delegates to an explicit Effect.
+ *
+ * @remarks
+ * ## Why
+ *
+ * Effect 4's `Effectable.Class` evaluates to the object itself. Typed's yieldable objects instead
+ * need `Effect.gen` to execute their `override` Effect. The prototype protocol installed below
+ * returns that Effect and avoids recursively yielding the same object.
+ *
+ * ## Ownership and lifetime
+ *
+ * The base class owns no fiber or Scope. Subclasses own the Effect assigned to `override` and all
+ * resources that Effect acquires. Execution preserves its value, typed error, service, interruption,
+ * and finalization channels.
+ *
+ * This class is a published extension point, but it is coupled to Effect's evaluator protocol and
+ * may change between prereleases.
+ *
+ * @example
+ * ```ts
+ * import { EffectableWithOverride } from "@typed/fx/Fx/internal/effectableWithOverride"
+ * import * as Effect from "effect/Effect"
+ *
+ * class Answer extends EffectableWithOverride<number> {
+ *   readonly override = Effect.succeed(42)
+ * }
+ *
+ * const value = Effect.runSync(new Answer()) // 42
+ * ```
+ *
+ * @since 1.0.0
+ * @category advanced
+ * @stability internal-but-published
+ */
+export class EffectableWithOverride extends Effectable.Class {
+}
+// @effect-diagnostics-next-line floatingEffect:off
+Object.defineProperty(EffectableWithOverride.prototype, EFFECT_EVALUATE_KEY, {
+    value: function () {
+        return this.override;
+    },
+    configurable: true,
+    writable: true,
+});

package/dist/Fx/internal/equivalence.d.ts

@@ -1,4 +1,33 @@
 import * as Equivalence from "effect/Equivalence";
 import type * as Exit from "effect/Exit";
+/** Lifts value equivalence to successes while comparing failure Causes structurally.
+ *
+ * @remarks
+ * ## Why
+ *
+ * State cells store full `Exit` values. Successful values should follow the caller's domain
+ * equivalence, while failures must retain Effect's Cause structure so repeated equivalent failures
+ * can be suppressed without collapsing distinct defects, interruptions, or compositions.
+ *
+ * ## Ownership and lifetime
+ *
+ * The returned function closes over `A` and acquires no services or Scope. Each comparison is pure;
+ * its cost is the cost of `A` for two successes or Effect's structural Cause equality for two
+ * failures. A success and failure are always different.
+ *
+ * @example
+ * ```ts
+ * import { getExitEquivalence } from "@typed/fx/Fx/internal/equivalence"
+ * import * as Equivalence from "effect/Equivalence"
+ * import * as Exit from "effect/Exit"
+ *
+ * const equivalent = getExitEquivalence(Equivalence.Number)
+ * equivalent(Exit.succeed(1), Exit.succeed(1)) // true
+ * ```
+ *
+ * @since 1.0.0
+ * @category advanced
+ * @stability internal-but-published
+ */
 export declare const getExitEquivalence: <E, A>(A: Equivalence.Equivalence<A>) => Equivalence.Equivalence<Exit.Exit<A, E>>;
 //# sourceMappingURL=equivalence.d.ts.map

package/dist/Fx/internal/equivalence.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"equivalence.d.ts","sourceRoot":"","sources":["../../../src/Fx/internal/equivalence.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,WAAW,MAAM,oBAAoB,CAAC;AAClD,OAAO,KAAK,KAAK,IAAI,MAAM,aAAa,CAAC;AAEzC,eAAO,MAAM,kBAAkB,GAAI,CAAC,EAAE,CAAC,EAAE,GAAG,WAAW,CAAC,WAAW,CAAC,CAAC,CAAC,6CAOlE,CAAC"}
+{"version":3,"file":"equivalence.d.ts","sourceRoot":"","sources":["../../../src/Fx/internal/equivalence.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,WAAW,MAAM,oBAAoB,CAAC;AAClD,OAAO,KAAK,KAAK,IAAI,MAAM,aAAa,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,kBAAkB,GAAI,CAAC,EAAE,CAAC,KAAK,WAAW,CAAC,WAAW,CAAC,CAAC,CAAC,6CAOlE,CAAC"}

package/dist/Fx/internal/equivalence.js

@@ -1,5 +1,34 @@
 import { equals } from "effect/Equal";
 import * as Equivalence from "effect/Equivalence";
+/** Lifts value equivalence to successes while comparing failure Causes structurally.
+ *
+ * @remarks
+ * ## Why
+ *
+ * State cells store full `Exit` values. Successful values should follow the caller's domain
+ * equivalence, while failures must retain Effect's Cause structure so repeated equivalent failures
+ * can be suppressed without collapsing distinct defects, interruptions, or compositions.
+ *
+ * ## Ownership and lifetime
+ *
+ * The returned function closes over `A` and acquires no services or Scope. Each comparison is pure;
+ * its cost is the cost of `A` for two successes or Effect's structural Cause equality for two
+ * failures. A success and failure are always different.
+ *
+ * @example
+ * ```ts
+ * import { getExitEquivalence } from "@typed/fx/Fx/internal/equivalence"
+ * import * as Equivalence from "effect/Equivalence"
+ * import * as Exit from "effect/Exit"
+ *
+ * const equivalent = getExitEquivalence(Equivalence.Number)
+ * equivalent(Exit.succeed(1), Exit.succeed(1)) // true
+ * ```
+ *
+ * @since 1.0.0
+ * @category advanced
+ * @stability internal-but-published
+ */
 export const getExitEquivalence = (A) => Equivalence.make((a, b) => {
     if (a._tag === "Failure") {
         return b._tag === "Failure" && equals(a.cause, b.cause);

package/dist/Fx/internal/multicast.d.ts

@@ -1,10 +1,153 @@
 import * as Effect from "effect/Effect";
-export declare class MulticastEffect<A, E, R> extends Effect.YieldableClass<A, E, R> {
+import { EffectableWithOverride } from "./effectableWithOverride.js";
+/** An Effect-compatible wrapper that joins the currently recorded detached execution.
+ *
+ * @remarks
+ * ## Why
+ *
+ * Some sampled state computations are expensive but may be requested concurrently. The wrapper
+ * lets later callers join the same in-flight fiber, preserving one result, typed failure, and Cause
+ * for that run. After completion the recorded fiber is cleared and a later call starts fresh work.
+ *
+ * ## Ownership and lifetime
+ *
+ * The first caller starts `effect` in a detached fiber using that caller's services. Interrupting a
+ * joining caller stops only its wait; the detached computation continues until completion or an
+ * explicit `interrupt`. A directly constructed instance has no automatic finalizer. Prefer
+ * `makeMulticastEffect` when a Scope should interrupt remaining work.
+ *
+ * ## Concurrency and interruption
+ *
+ * Calls made after `_fiber` is recorded join that fiber. Recording uses mutable instance state
+ * rather than a semaphore, so this is a low-level primitive whose callers must not assume a stronger
+ * atomic-start guarantee than the implementation provides. Completion or explicit interruption
+ * clears the matching record; all joiners observe the fiber's exact success, typed error, defect,
+ * or interruption.
+ *
+ * This path is published for advanced state implementations and may change between prereleases.
+ *
+ * @example
+ * ```ts
+ * import { MulticastEffect } from "@typed/fx/Fx/internal/multicast"
+ * import * as Effect from "effect/Effect"
+ *
+ * const sharedWhileRunning = new MulticastEffect(Effect.succeed("ready"))
+ * const value = Effect.runSync(sharedWhileRunning)
+ * ```
+ *
+ * @since 1.0.0
+ * @category advanced
+ * @stability internal-but-published
+ */
+export declare class MulticastEffect<A, E, R> extends EffectableWithOverride<A, E, R> {
     private _fiber;
+    /** Underlying computation started when no recorded fiber is running.
+     *
+     * @remarks
+     * ## Why
+     *
+     * Keeping the source Effect visible lets advanced implementations inspect or compose the exact
+     * work whose in-flight execution is shared.
+     *
+     * ## Ownership and lifetime
+     *
+     * The wrapper retains this immutable Effect description; resources begin only when it is run.
+     *
+     * @since 1.0.0
+     * @category effects
+     */
     readonly effect: Effect.Effect<A, E, R>;
+    /** Creates a wrapper without attaching its future detached fiber to a Scope.
+     *
+     * @remarks
+     * ## Why
+     *
+     * Direct construction supports owners such as Versioned that already expose an explicit
+     * interruption boundary and do not need acquisition itself to require Scope.
+     *
+     * ## Ownership and lifetime
+     *
+     * Construction retains only the Effect description and starts no work. The first evaluation may
+     * start a detached fiber, which remains this instance's responsibility until it completes or
+     * `interrupt` is run. Use `makeMulticastEffect` when Scope closure should provide that cleanup.
+     *
+     * @example
+     * ```ts
+     * import { MulticastEffect } from "@typed/fx/Fx/internal/multicast"
+     * import * as Effect from "effect/Effect"
+     *
+     * const shared = new MulticastEffect(Effect.succeed("ready"))
+     * const result = Effect.runSync(shared)
+     * ```
+     *
+     * @since 1.0.0
+     * @category constructors
+     */
     constructor(effect: Effect.Effect<A, E, R>);
-    asEffect(): Effect.Effect<A, E, R>;
+    /** Effect view that joins the recorded fiber or starts and records a detached one.
+     *
+     * @remarks
+     * ## Why
+     *
+     * Effect evaluation is the common entry point through which concurrent callers share work.
+     *
+     * ## Ownership and lifetime
+     *
+     * A newly started fiber is detached from the joining caller and remains recorded until completion
+     * or explicit interruption.
+     *
+     * @since 1.0.0
+     * @category effects
+     */
+    readonly override: Effect.Effect<A, E, R>;
+    /** Interrupts the currently recorded fiber as the calling fiber and clears the record.
+     *
+     * @remarks
+     * ## Why
+     *
+     * If no fiber is recorded, the Effect succeeds immediately. Interruption of the child is awaited,
+     * and cleanup clears the field even when interruption observation itself is interrupted.
+     *
+     * ## Ownership and lifetime
+     *
+     * The Effect owns only this interruption action; it does not prevent a later execution from
+     * starting a fresh fiber.
+     *
+     * @since 1.0.0
+     * @category lifecycle
+     */
     interrupt(): Effect.Effect<void, never, never>;
 }
+/** Acquires a scoped `MulticastEffect` whose finalizer interrupts recorded work.
+ *
+ * @remarks
+ * ## Why
+ *
+ * The scoped constructor makes the detached-fiber lifetime explicit and prevents a computation
+ * from surviving the application lifetime that requested sharing.
+ *
+ * ## Ownership and lifetime
+ *
+ * Acquisition allocates the wrapper but does not start `effect`. The first execution starts work;
+ * closing the required Scope calls `interrupt` and waits for the recorded fiber to terminate. The
+ * original effect's `E` and `R` channels are preserved when the wrapper is executed.
+ *
+ * @example
+ * ```ts
+ * import { makeMulticastEffect } from "@typed/fx/Fx/internal/multicast"
+ * import * as Effect from "effect/Effect"
+ *
+ * const program = Effect.gen(function* () {
+ *   const shared = yield* makeMulticastEffect(Effect.succeed("ready"))
+ *   return yield* shared
+ * })
+ *
+ * Effect.runSync(Effect.scoped(program))
+ * ```
+ *
+ * @since 1.0.0
+ * @category constructors
+ * @stability internal-but-published
+ */
 export declare const makeMulticastEffect: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<MulticastEffect<A, E, R>, never, import("effect/Scope").Scope>;
 //# sourceMappingURL=multicast.d.ts.map

package/dist/Fx/internal/multicast.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"multicast.d.ts","sourceRoot":"","sources":["../../../src/Fx/internal/multicast.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAGxC,qBAAa,eAAe,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAE,SAAQ,MAAM,CAAC,cAAc,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;IAC1E,OAAO,CAAC,MAAM,CAAkC;IAEhD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;gBAE5B,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;IAK1C,QAAQ;IAkBR,SAAS;CAaV;AAED,eAAO,MAAM,mBAAmB,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,QAAQ,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,iFAIxE,CAAC"}
+{"version":3,"file":"multicast.d.ts","sourceRoot":"","sources":["../../../src/Fx/internal/multicast.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAErE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,qBAAa,eAAe,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAE,SAAQ,sBAAsB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;IAC3E,OAAO,CAAC,MAAM,CAAkC;IAEhD;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAExC;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,YAAY,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAmBzC;IAED;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAE1C;;;;;;;;;;;;;;;OAeG;IACH,SAAS,sCAYR;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,mBAAmB,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,UAAU,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,iFAIxE,CAAC"}