@typed/fx 2.0.0-beta.4 → 2.0.0-beta.5

package/dist/Fx/constructors/succeed.js

@@ -2,6 +2,24 @@ import { make } from "./make.js";
 /**
  * Creates an Fx that emits a single value and then completes.
  *
+ * @remarks
+ * ## Why
+ *
+ * A known value can enter `Fx` composition without adding failure or service
+ * requirements.
+ *
+ * ## Ownership and lifetime
+ *
+ * Construction stores the value. Each run offers it exactly once, waits for the sink
+ * handler, and completes without acquiring resources.
+ *
+ * @example
+ * ```ts
+ * import { collectAll, succeed } from "@typed/fx/Fx"
+ *
+ * const program = collectAll(succeed({ status: "ready" }))
+ * ```
+ *
  * @param value - The value to emit.
  * @returns An `Fx` that emits the value.
  * @since 1.0.0
@@ -10,21 +28,75 @@ import { make } from "./make.js";
 export const succeed = (value) => 
 /*#__PURE__*/ make((sink) => sink.onSuccess(value));
 /**
- * An Fx that emits `null` and then completes.
+ * An Fx that emits `null` exactly once and then completes.
+ *
+ * @remarks
+ * ## Why
+ *
+ * The shared constant avoids repeatedly spelling `succeed(null)` in optional-value
+ * compositions. It is also exported as `null`.
+ *
+ * ## Ownership and lifetime
+ *
+ * Each run performs one sink delivery and acquires no resources.
+ *
+ * @example
+ * ```ts
+ * import { first, succeedNull } from "@typed/fx/Fx"
+ *
+ * const program = first(succeedNull)
+ * ```
+ *
  * @since 1.0.0
  * @category constructors
  */
 export const succeedNull = succeed(null);
 export { succeedNull as null };
 /**
- * An Fx that emits `undefined` and then completes.
+ * An Fx that emits `undefined` exactly once and then completes.
+ *
+ * @remarks
+ * ## Why
+ *
+ * The shared constant avoids repeatedly spelling `succeed(undefined)` in optional
+ * compositions. It is also exported as `undefined`.
+ *
+ * ## Ownership and lifetime
+ *
+ * Each run performs one sink delivery and acquires no resources.
+ *
+ * @example
+ * ```ts
+ * import { first, succeedUndefined } from "@typed/fx/Fx"
+ *
+ * const program = first(succeedUndefined)
+ * ```
+ *
  * @since 1.0.0
  * @category constructors
  */
 export const succeedUndefined = succeed(undefined);
 export { succeedUndefined as undefined };
 /**
- * An Fx that emits `void` and then completes.
+ * An Fx that emits `void` exactly once and then completes.
+ *
+ * @remarks
+ * ## Why
+ *
+ * The shared constant is a completion pulse for operations whose payload is
+ * irrelevant. It is also exported as `void`.
+ *
+ * ## Ownership and lifetime
+ *
+ * Each run performs one sink delivery and acquires no resources.
+ *
+ * @example
+ * ```ts
+ * import { drain, succeedVoid } from "@typed/fx/Fx"
+ *
+ * const program = drain(succeedVoid)
+ * ```
+ *
  * @since 1.0.0
  * @category constructors
  */

package/dist/Fx/constructors/suspend.d.ts

@@ -1,3 +1,31 @@
 import type { Fx } from "../Fx.js";
+/**
+ * Defers creation of an `Fx` until each run begins.
+ *
+ * @remarks
+ * ## Why
+ *
+ * Recursive producers and producers whose definition depends on fresh mutable state
+ * need laziness at the `Fx` boundary, not merely laziness of a value emission.
+ *
+ * ## Ownership and lifetime
+ *
+ * `fx` is not evaluated during construction. It is evaluated once per run inside
+ * `Effect.suspend`; thrown exceptions become Effect defects, and the returned
+ * producer is owned and interrupted as part of that same run.
+ *
+ * @example
+ * ```ts
+ * import { collectAll, succeed, suspend } from "@typed/fx/Fx"
+ *
+ * let next = 0
+ * const source = suspend(() => succeed(++next))
+ * const firstRun = collectAll(source)
+ * const secondRun = collectAll(source)
+ * ```
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
 export declare const suspend: <A, E, R>(fx: () => Fx<A, E, R>) => Fx<A, E, R>;
 //# sourceMappingURL=suspend.d.ts.map

package/dist/Fx/constructors/suspend.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"suspend.d.ts","sourceRoot":"","sources":["../../../src/Fx/constructors/suspend.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAGnC,eAAO,MAAM,OAAO,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,MAAM,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CACJ,CAAC"}
+{"version":3,"file":"suspend.d.ts","sourceRoot":"","sources":["../../../src/Fx/constructors/suspend.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAGnC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,OAAO,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,MAAM,MAAM,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CACJ,CAAC"}

package/dist/Fx/constructors/suspend.js

@@ -1,3 +1,31 @@
 import * as Effect from "effect/Effect";
 import { make } from "./make.js";
+/**
+ * Defers creation of an `Fx` until each run begins.
+ *
+ * @remarks
+ * ## Why
+ *
+ * Recursive producers and producers whose definition depends on fresh mutable state
+ * need laziness at the `Fx` boundary, not merely laziness of a value emission.
+ *
+ * ## Ownership and lifetime
+ *
+ * `fx` is not evaluated during construction. It is evaluated once per run inside
+ * `Effect.suspend`; thrown exceptions become Effect defects, and the returned
+ * producer is owned and interrupted as part of that same run.
+ *
+ * @example
+ * ```ts
+ * import { collectAll, succeed, suspend } from "@typed/fx/Fx"
+ *
+ * let next = 0
+ * const source = suspend(() => succeed(++next))
+ * const firstRun = collectAll(source)
+ * const secondRun = collectAll(source)
+ * ```
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
 export const suspend = (fx) => make((sink) => Effect.suspend(() => fx().run(sink)));

package/dist/Fx/constructors/sync.d.ts

@@ -0,0 +1,32 @@
+import type { Fx } from "../Fx.js";
+/**
+ * Lazily evaluates a synchronous function once for each Fx run.
+ *
+ * @remarks
+ * ## Why
+ *
+ * `sync` is the direct constructor for one value that must be computed at run time,
+ * such as a fresh DOM node or a snapshot read from an imperative API. Unlike
+ * `succeed`, it does not evaluate the function while the Fx is being assembled.
+ *
+ * ## Ownership and lifetime
+ *
+ * Construction performs no work. Each run evaluates `evaluate` exactly once in the
+ * run's fiber, emits its result, and completes after the Sink handles it. A thrown
+ * exception is an Effect defect; use `Fx.fromEffect(Effect.try(...))` when failure is
+ * expected and belongs in the typed error channel.
+ *
+ * @example
+ * ```ts
+ * import { Fx } from "@typed/fx"
+ *
+ * const element = Fx.sync(() => document.createElement("div"))
+ * ```
+ *
+ * @param evaluate - The synchronous function evaluated once per run.
+ * @returns An Fx that emits the freshly evaluated value.
+ * @since 2.0.0
+ * @category constructors
+ */
+export declare const sync: <A>(evaluate: () => A) => Fx<A>;
+//# sourceMappingURL=sync.d.ts.map

package/dist/Fx/constructors/sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync.d.ts","sourceRoot":"","sources":["../../../src/Fx/constructors/sync.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAGnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,YAAY,MAAM,CAAC,KAAG,EAAE,CAAC,CAAC,CAAsC,CAAC"}

package/dist/Fx/constructors/sync.js

@@ -0,0 +1,32 @@
+import * as Effect from "effect/Effect";
+import { fromEffect } from "./fromEffect.js";
+/**
+ * Lazily evaluates a synchronous function once for each Fx run.
+ *
+ * @remarks
+ * ## Why
+ *
+ * `sync` is the direct constructor for one value that must be computed at run time,
+ * such as a fresh DOM node or a snapshot read from an imperative API. Unlike
+ * `succeed`, it does not evaluate the function while the Fx is being assembled.
+ *
+ * ## Ownership and lifetime
+ *
+ * Construction performs no work. Each run evaluates `evaluate` exactly once in the
+ * run's fiber, emits its result, and completes after the Sink handles it. A thrown
+ * exception is an Effect defect; use `Fx.fromEffect(Effect.try(...))` when failure is
+ * expected and belongs in the typed error channel.
+ *
+ * @example
+ * ```ts
+ * import { Fx } from "@typed/fx"
+ *
+ * const element = Fx.sync(() => document.createElement("div"))
+ * ```
+ *
+ * @param evaluate - The synchronous function evaluated once per run.
+ * @returns An Fx that emits the freshly evaluated value.
+ * @since 2.0.0
+ * @category constructors
+ */
+export const sync = (evaluate) => fromEffect(Effect.sync(evaluate));

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

@@ -4,26 +4,278 @@ import type * as Equivalence from "effect/Equivalence";
 import * as Exit from "effect/Exit";
 import * as MutableRef from "effect/MutableRef";
 import * as Option from "effect/Option";
+import { EffectableWithOverride } from "./effectableWithOverride.js";
 /**
- * This is the core piece of state for {@link RefSubject}. It presents an Yieldable/Effect interface
- * which supports retrieving the latest Exit<A, E> or waiting for an initial Exit<A, E> to be set otherwise.
+ * A mutable, Effect-compatible cell that waits for its first `Exit` and samples the latest one
+ * thereafter.
  *
- * It utilizes a Equivalence to determine if the latest Exit<A, E> is the same as the current Exit<A, E> through the
- * done method.
+ * @remarks
+ * ## Why
  *
- * @internal
+ * RefSubject needs one object that can be yielded as an Effect before initialization and read
+ * synchronously from retained state after initialization. `DeferredRef` combines those two phases
+ * without starting a polling fiber or allocating a new Deferred for every update.
+ *
+ * ## Ownership and lifetime
+ *
+ * An instance owns its current Deferred and mutates the supplied `MutableRef`. It acquires no
+ * Scope. Callers must ensure that mutation is serialized when updates can race. `reset` interrupts
+ * waiters on the previous Deferred and replaces it; dropping the instance releases the retained
+ * `Exit` for garbage collection.
+ *
+ * ## Errors and interruption
+ *
+ * Executing the instance waits while `current` is `None`, then succeeds or fails exactly as the
+ * stored `Exit`. `reset` completes the old Deferred with interruption attributed to `fiberId`.
+ * The equality function controls version changes and the boolean returned by `done`; it does not
+ * erase or transform typed failures.
+ *
+ * This import path is published for advanced state implementations, but its shape follows
+ * RefSubject and Effect runtime details and may change between prereleases.
+ *
+ * @example
+ * ```ts
+ * import { DeferredRef } from "@typed/fx/Fx/internal/DeferredRef"
+ * import { getExitEquivalence } from "@typed/fx/Fx/internal/equivalence"
+ * import * as Effect from "effect/Effect"
+ * import * as Equivalence from "effect/Equivalence"
+ * import * as Exit from "effect/Exit"
+ * import * as MutableRef from "effect/MutableRef"
+ * import * as Option from "effect/Option"
+ *
+ * const current = MutableRef.make<Option.Option<Exit.Exit<number, never>>>(Option.none())
+ * const ref = new DeferredRef(undefined, getExitEquivalence(Equivalence.Number), current)
+ * ref.done(Exit.succeed(1))
+ * const value = Effect.runSync(ref) // 1
+ * ```
+ *
+ * @since 1.0.0
+ * @category advanced
+ * @stability internal-but-published
  */
-export declare class DeferredRef<E, A> extends Effect.YieldableClass<A, E, never> {
+export declare class DeferredRef<E, A> extends EffectableWithOverride<A, E, never> {
+    /** The zero-based version of the latest distinct `Exit` since the last reset.
+     *
+     * @remarks
+     * ## Why
+     *
+     * `reset` sets this to `-1`; the first distinct `done` call changes it to `0`, the next to `1`,
+     * and so on. It is an ordinal, not a count.
+     *
+     * ## Ownership and lifetime
+     *
+     * The instance mutates this counter; reading it acquires no resources.
+     *
+     * @since 1.0.0
+     * @category state
+     */
     version: number;
+    /** The one-shot gate used by Effects waiting for the first value after a reset.
+     *
+     * @remarks
+     * ## Why
+     *
+     * This field is replaced by `reset`. Mutating or completing it externally can violate the
+     * `current`/Deferred invariant.
+     *
+     * ## Ownership and lifetime
+     *
+     * The instance owns the gate until reset or collection; waiters borrow it through `override`.
+     *
+     * @since 1.0.0
+     * @category state
+     */
     deferred: Deferred.Deferred<A, E>;
+    /** Fiber identifier used to attribute interruption when `reset` closes the old gate.
+     *
+     * @remarks
+     * ## Why
+     *
+     * Retaining the creator's identifier makes reset interruption attributable in an Effect Cause.
+     *
+     * ## Ownership and lifetime
+     *
+     * Immutable scalar metadata retained for the instance lifetime.
+     *
+     * @since 1.0.0
+     * @category state
+     */
     readonly fiberId: number | undefined;
+    /** Equivalence used to suppress version changes for repeated Exits.
+     *
+     * @remarks
+     * ## Why
+     *
+     * State implementations can define semantic equality independently from object identity.
+     *
+     * ## Ownership and lifetime
+     *
+     * The instance retains and invokes the pure function; it acquires no services.
+     *
+     * @since 1.0.0
+     * @category state
+     */
     readonly eq: Equivalence.Equivalence<Exit.Exit<A, E>>;
+    /** Shared mutable storage containing the latest success or failure, if initialized.
+     *
+     * @remarks
+     * ## Why
+     *
+     * Sharing one cell lets RefSubject publication and Effect sampling observe the same latest Exit.
+     *
+     * ## Ownership and lifetime
+     *
+     * The constructor borrows this cell and clears it; external owners must coordinate mutation.
+     *
+     * @since 1.0.0
+     * @category state
+     */
     readonly current: MutableRef.MutableRef<Option.Option<Exit.Exit<A, E>>>;
+    /** Constructs a cell over caller-supplied storage and immediately starts an empty version.
+     *
+     * @remarks
+     * ## Why
+     *
+     * Advanced state implementations can share their existing current-Exit cell with the yieldable
+     * Effect view while choosing the equality and interruption identity used by publication.
+     *
+     * ## Ownership and lifetime
+     *
+     * The constructor borrows and clears `current`, sets `version` to `-1`, and owns the newly created
+     * one-shot Deferred until reset or collection. It does not clone storage, acquire a Scope, or
+     * synchronize external mutation.
+     *
+     * @example
+     * ```ts
+     * import { DeferredRef } from "@typed/fx/Fx/internal/DeferredRef"
+     * import { getExitEquivalence } from "@typed/fx/Fx/internal/equivalence"
+     * import * as Equivalence from "effect/Equivalence"
+     * import type * as Exit from "effect/Exit"
+     * import * as MutableRef from "effect/MutableRef"
+     * import * as Option from "effect/Option"
+     *
+     * const current = MutableRef.make<Option.Option<Exit.Exit<number, never>>>(Option.none())
+     * const ref = new DeferredRef(undefined, getExitEquivalence(Equivalence.Number), current)
+     * ref.version // -1 until the first distinct Exit is published
+     * ```
+     *
+     * @since 1.0.0
+     * @category constructors
+     */
     constructor(fiberId: number | undefined, eq: Equivalence.Equivalence<Exit.Exit<A, E>>, current: MutableRef.MutableRef<Option.Option<Exit.Exit<A, E>>>);
-    asEffect(): Effect.Effect<A, E, never>;
+    /** Effect view that awaits initialization or evaluates the latest stored `Exit`.
+     *
+     * @remarks
+     * ## Why
+     *
+     * Each execution reads `current`. Once initialized, reads are O(1) and do not wait on the
+     * Deferred.
+     *
+     * ## Ownership and lifetime
+     *
+     * The Effect borrows instance state and retains no per-execution resource after it completes.
+     *
+     * @since 1.0.0
+     * @category effects
+     */
+    readonly override: Effect.Effect<A, E, never>;
+    /** Stores an `Exit` and reports whether it differs from the previously stored value.
+     *
+     * @remarks
+     * ## Why
+     *
+     * The current cell is updated even when `eq` reports equality. The first distinct value after a
+     * reset completes the one-shot Deferred, changes `version` from `-1` to `0`, and releases waiters.
+     * Later distinct values replace `current` and advance the zero-based version, but the already
+     * completed Deferred is not re-completed and existing executions sample `current` directly.
+     * An equivalent value leaves the version unchanged and returns `false`. The operation is O(1)
+     * plus the cost of `eq`.
+     *
+     * ## Ownership and lifetime
+     *
+     * Mutates only this cell's current value, Deferred, and version; it starts no fiber or Scope.
+     *
+     * @since 1.0.0
+     * @category mutations
+     */
     done(exit: Exit.Exit<A, E>): boolean;
+    /** Clears the sampled value and starts a fresh initialization phase.
+     *
+     * @remarks
+     * ## Why
+     *
+     * Existing waiters are interrupted before the replacement Deferred is installed. The method is
+     * synchronous and acquires no Scope.
+     *
+     * ## Ownership and lifetime
+     *
+     * Releases the old current Exit and gate from this instance after interrupting its waiters.
+     *
+     * @since 1.0.0
+     * @category mutations
+     */
     reset(): void;
 }
+/** Creates a fresh `DeferredRef` and records the creating fiber for reset interruption.
+ *
+ * @remarks
+ * ## Why
+ *
+ * Capturing the current fiber gives interruption of pre-reset waiters an attributable origin while
+ * keeping ordinary construction inside Effect.
+ *
+ * ## Ownership and lifetime
+ *
+ * The returned instance owns its Deferred and mutable cell but acquires no Scope. Its state remains
+ * reachable for exactly as long as callers retain the instance.
+ *
+ * @example
+ * ```ts
+ * import { make } from "@typed/fx/Fx/internal/DeferredRef"
+ * import { getExitEquivalence } from "@typed/fx/Fx/internal/equivalence"
+ * import * as Effect from "effect/Effect"
+ * import * as Equivalence from "effect/Equivalence"
+ *
+ * const program = Effect.gen(function* () {
+ *   const ref = yield* make(getExitEquivalence<never, number>(Equivalence.Number))
+ *   return ref
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category constructors
+ * @stability internal-but-published
+ */
 export declare function make<E, A>(eq: Equivalence.Equivalence<Exit.Exit<A, E>>): Effect.Effect<DeferredRef<E, A>, never, never>;
+/** Constructs a `DeferredRef` over existing mutable storage without entering Effect.
+ *
+ * @remarks
+ * ## Why
+ *
+ * State implementations that already own an `Exit` cell can share it with the Effect view instead
+ * of copying or synchronizing two stores.
+ *
+ * ## Ownership and lifetime
+ *
+ * The returned instance borrows `current` and immediately resets it to `None`. Callers own all
+ * synchronization and must not assume that the previous cell value survives construction.
+ *
+ * @example
+ * ```ts
+ * import { unsafeMake } from "@typed/fx/Fx/internal/DeferredRef"
+ * import { getExitEquivalence } from "@typed/fx/Fx/internal/equivalence"
+ * import * as Equivalence from "effect/Equivalence"
+ * import * as Exit from "effect/Exit"
+ * import * as MutableRef from "effect/MutableRef"
+ * import * as Option from "effect/Option"
+ *
+ * const current = MutableRef.make<Option.Option<Exit.Exit<number, never>>>(Option.none())
+ * const ref = unsafeMake(undefined, getExitEquivalence(Equivalence.Number), current)
+ * ```
+ *
+ * @since 1.0.0
+ * @category constructors
+ * @stability internal-but-published
+ */
 export declare function unsafeMake<E, A>(id: number | undefined, eq: Equivalence.Equivalence<Exit.Exit<A, E>>, current: MutableRef.MutableRef<Option.Option<Exit.Exit<A, E>>>): DeferredRef<E, A>;
 //# sourceMappingURL=DeferredRef.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"DeferredRef.d.ts","sourceRoot":"","sources":["../../../src/Fx/internal/DeferredRef.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAC;AAC5C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,KAAK,WAAW,MAAM,oBAAoB,CAAC;AACvD,OAAO,KAAK,IAAI,MAAM,aAAa,CAAC;AACpC,OAAO,KAAK,UAAU,MAAM,mBAAmB,CAAC;AAChD,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC;;;;;;;;GAQG;AACH,qBAAa,WAAW,CAAC,CAAC,EAAE,CAAC,CAAE,SAAQ,MAAM,CAAC,cAAc,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC;IAChE,OAAO,EAAG,MAAM,CAAC;IACjB,QAAQ,EAAG,QAAQ,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAE1C,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;IACrC,QAAQ,CAAC,EAAE,EAAE,WAAW,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IACtD,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;gBAGtE,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,EAAE,EAAE,WAAW,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAC5C,OAAO,EAAE,UAAU,CAAC,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAShE,QAAQ;IAWR,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,OAAO;IAepC,KAAK;CAUN;AAED,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,WAAW,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,kDAItE;AAED,wBAAgB,UAAU,CAAC,CAAC,EAAE,CAAC,EAC7B,EAAE,EAAE,MAAM,GAAG,SAAS,EACtB,EAAE,EAAE,WAAW,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAC5C,OAAO,EAAE,UAAU,CAAC,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,qBAG/D"}
+{"version":3,"file":"DeferredRef.d.ts","sourceRoot":"","sources":["../../../src/Fx/internal/DeferredRef.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAC;AAC5C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,KAAK,WAAW,MAAM,oBAAoB,CAAC;AACvD,OAAO,KAAK,IAAI,MAAM,aAAa,CAAC;AACpC,OAAO,KAAK,UAAU,MAAM,mBAAmB,CAAC;AAChD,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAErE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,qBAAa,WAAW,CAAC,CAAC,EAAE,CAAC,CAAE,SAAQ,sBAAsB,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC;IACxE;;;;;;;;;;;;;;OAcG;IACI,OAAO,EAAG,MAAM,CAAC;IAExB;;;;;;;;;;;;;;OAcG;IACI,QAAQ,EAAG,QAAQ,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAE1C;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;IAErC;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,EAAE,EAAE,WAAW,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAEtD;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IAExE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,YACE,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,EAAE,EAAE,WAAW,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAC5C,OAAO,EAAE,UAAU,CAAC,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAgB/D;IAED;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;IAE9C;;;;;;;;;;;;;;;;;;OAkBG;IACH,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,OAAO,CAanC;IAED;;;;;;;;;;;;;;OAcG;IACH,KAAK,SASJ;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,WAAW,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,kDAItE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,CAAC,EAC7B,EAAE,EAAE,MAAM,GAAG,SAAS,EACtB,EAAE,EAAE,WAAW,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAC5C,OAAO,EAAE,UAAU,CAAC,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,qBAG/D"}