@typed/fx 1.17.3 → 1.18.0

package/dist/cjs/Fx.js

@@ -1,35 +1,1307 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Sink = exports.isFx = exports.Fx = exports.make = exports.FxTypeId = void 0;
-const Function_1 = require("@effect/data/Function");
-const Pipeable_1 = require("@effect/data/Pipeable");
-exports.FxTypeId = Symbol.for('@typed/fx/Fx');
-const fxVariance = {
-    _R: Function_1.identity,
-    _E: Function_1.identity,
-    _A: Function_1.identity,
-};
-const proto = {
-    [exports.FxTypeId]: fxVariance,
-    pipe() {
-        // eslint-disable-next-line prefer-rest-params
-        return (0, Pipeable_1.pipeArguments)(this, arguments);
-    },
-};
-const make = function Fx(run) {
-    const fx = Object.create(proto);
-    fx.run = run;
-    return fx;
-};
-exports.make = make;
-function Fx(run) {
-    return (0, exports.make)(run);
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.fromStream = exports.fromSink = exports.fromScheduled = exports.fromPubSub = exports.fromNullable = exports.fromIterable = exports.fromFxEffect = exports.fromEmitter = exports.fromEffect = exports.fromDequeue = exports.from = exports.forkScoped = exports.forkIn = exports.forkDaemon = exports.fork = exports.flip = exports.flatten = exports.flatMapWithStrategy = exports.flatMapErrorWithStrategy = exports.flatMapErrorConcurrently = exports.flatMapError = exports.flatMapConcurrently = exports.flatMapCauseWithStrategy = exports.flatMapCauseConcurrently = exports.flatMapCause = exports.flatMap = exports.first = exports.findFirst = exports.filterMapErrorEffect = exports.filterMapError = exports.filterMapEffect = exports.filterMapCause = exports.filterMap = exports.filterErrorCause = exports.filterError = exports.filterEffect = exports.filter = exports.failCause = exports.fail = exports.exit = exports.exhaustMatchCause = exports.exhaustMatch = exports.exhaustMapLatestError = exports.exhaustMapLatestCause = exports.exhaustMapLatest = exports.exhaustMapError = exports.exhaustMapCause = exports.exhaustMap = exports.exhaustLatestMatchCause = exports.exhaustLatestMatch = exports.exhaustLatest = exports.exhaust = exports.ensuring = exports.endWith = exports.empty = exports.either = exports.during = exports.dropWhile = exports.dropUntil = exports.dropAfter = exports.drop = exports.drainLayer = exports.drain = exports.die = exports.delay = exports.debounce = exports.continueWith = exports.concatMap = exports.compact = exports.combine = exports.bindTo = exports.bind = exports.at = exports.annotateSpans = exports.annotateLogs = exports.acquireUseRelease = exports.Unordered = exports.Unbounded = exports.ToFx = exports.Switch = exports.Ordered = exports.ExhaustLatest = exports.Exhaust = exports.Do = exports.Bounded = void 0;
+exports.gen = gen;
+exports.genScoped = genScoped;
+exports.interruptible = exports.interrupt = exports.if = exports.hold = exports.getOrElse = void 0;
+exports.isFx = isFx;
+exports.map = exports.loopEffect = exports.loop = exports.locallyWith = exports.locally = exports.let = exports.keyed = void 0;
+exports.withTracerTiming = exports.withTracer = exports.withSpan = exports.withScopedFork = exports.withScheduler = exports.withRequestCaching = exports.withRequestCache = exports.withRequestBatching = exports.withPrevious = exports.withParentSpan = exports.withMaxOpsBeforeYield = exports.withLogSpan = exports.withKey = exports.withFlattenStrategy = exports.withEarlyExit = exports.withConcurrency = exports.when = exports.until = exports.uninterruptible = exports.toReadonlyArray = exports.toEnqueue = exports.toChunk = exports.toArray = exports.throttle = exports.tap = exports.takeWhile = exports.takeUntil = exports.take = exports.sync = exports.switchMatchCause = exports.switchMatch = exports.switchMapError = exports.switchMapCause = exports.switchMap = exports.switchLatest = exports.suspend = exports.succeedSome = exports.succeedNone = exports.succeed = exports.struct = exports.startWith = exports.snapshot = exports.slice = exports.skipRepeatsWith = exports.skipRepeats = exports.since = exports.share = exports.scoped = exports.scanEffect = exports.scan = exports.run = exports.replay = exports.reduce = exports.race = exports.provideServiceEffect = exports.provideService = exports.provide = exports.periodic = exports.partitionMap = exports.orElse = exports.onInterrupt = exports.onExit = exports.onError = exports.observe = exports.never = exports.multicast = exports.middleware = exports.mergeSwitch = exports.mergeRace = exports.mergeConcurrently = exports.mergeBufferConcurrently = exports.mergeBuffer = exports.merge = exports.matchTags = exports.matchOption = exports.matchErrorWithStrategy = exports.matchErrorConcurrently = exports.matchEither = exports.matchCauseWithStrategy = exports.matchCauseConcurrently = exports.matchCause = exports.match = exports.mapErrorCause = exports.mapError = exports.mapEffect = exports.mapBoth = void 0;
+var Cause = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/Cause"));
+var Effect = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/Effect"));
+var Either = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/Either"));
+var _Function = /*#__PURE__*/require("effect/Function");
+var Option = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/Option"));
+var core = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./internal/core"));
+var internal = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./internal/fx"));
+var primitive = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./internal/fx-primitive"));
+var internalKeyed = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./internal/keyed"));
+var internalRun = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./internal/run"));
+var Share = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./internal/share"));
+var strategies = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./internal/strategies"));
+var internalWithKey = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./internal/withKey"));
+var _RefSubject = /*#__PURE__*/require("./RefSubject");
+var _TypeId = /*#__PURE__*/require("./TypeId");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+/**
+ * Fx<R, E, A> is a representation of an `Effect`-ful workflow that exists over
+ * the time dimension. It operates within a context `R`, can fail with an `E`,
+ * and succeed with an `A`.
+ *
+ * Any `Fx`, shorthand for "Effects", can emit 0 or more errors or events over an
+ * indefinite period of time. This is in contrast to `Effect` which can only
+ * produce exactly 1 error or event.
+ *
+ * It is defined as a super-type of `Effect`, `Stream`, and `Cause`. This
+ * allows for all operators that accept an `Fx` to also capable of
+ * accepting an `Effect`, `Stream`, or `Cause`. An Effect or Cause represents a single
+ * event or error, while a Stream represents a series of events or errors that will
+ * be pulled from the producer as soon as possible.
+ *
+ * @since 1.18.0
+ */
+
+/**
+ * Singleton instance of Unbounded
+ * @since 1.18.0
+ * @category FlattenStrategy
+ */
+const Unbounded = exports.Unbounded = strategies.Unbounded;
+/**
+ * Construct a Bounded strategy
+ * @since 1.18.0
+ * @category FlattenStrategy
+ */
+const Bounded = exports.Bounded = strategies.Bounded;
+/**
+ * Singleton instance of Switch
+ * @since 1.18.0
+ * @category FlattenStrategy
+ */
+const Switch = exports.Switch = strategies.Switch;
+/**
+ * Singleton instance of Exhaust
+ * @since 1.18.0
+ * @category FlattenStrategy
+ */
+const Exhaust = exports.Exhaust = strategies.Exhaust;
+/**
+ * Singleton instance of ExhaustLatest
+ * @since 1.18.0
+ * @category FlattenStrategy
+ */
+const ExhaustLatest = exports.ExhaustLatest = strategies.ExhaustLatest;
+/**
+ * Construct an Unordered strategy
+ * @since 1.18.0
+ * @category MergeStrategy
+ */
+const Unordered = exports.Unordered = strategies.Unordered;
+/**
+ * Construct an Ordered strategy
+ * @since 1.18.0
+ * @category MergeStrategy
+ */
+const Ordered = exports.Ordered = strategies.Ordered;
+/* #endregion */
+/* #region Constructor */
+/* #region Core */
+/**
+ * An Fx which will immediately end producing 0 events and 0 errors.
+ * @since 1.18.0
+ * @category constructors
+ */
+const empty = exports.empty = core.empty;
+/**
+ * Construct an Fx<never, E, A> from a Cause<E>
+ * @since 1.18.0
+ * @category constructors
+ */
+const failCause = exports.failCause = core.failCause;
+/**
+ * Construct an Fx<never, never, never> from a defect
+ * @since 1.18.0
+ * @category constructors
+ */
+const die = defect => failCause(Cause.die(defect));
+/**
+ * Interrupt the current Fx with the specified FiberId
+ * @since 1.18.0
+ * @category constructors
+ */
+exports.die = die;
+const interrupt = id => failCause(Cause.interrupt(id));
+/**
+ * Construct an Fx which will fail with the specified error.
+ * @since 1.18.0
+ * @category constructors
+ */
+exports.interrupt = interrupt;
+const fail = exports.fail = core.fail;
+/**
+ * Construct an Fx<R, E, A> from an Effect<R, E, A>
+ * @since 1.18.0
+ * @category constructors
+ */
+const fromEffect = exports.fromEffect = core.fromEffect;
+/**
+ * Construct an Fx from an Iterable
+ * @since 1.18.0
+ * @category constructors
+ */
+const fromIterable = exports.fromIterable = core.fromIterable;
+/**
+ * Construct an Fx<R, E, A> from an Effect<R, E, A>
+ * @since 1.18.0
+ * @category constructors
+ */
+const fromStream = exports.fromStream = core.fromStream;
+/**
+ * Construct an Fx<R, E, A> from an Effect<R, E, A>
+ * @since 1.18.0
+ * @category constructors
+ */
+const from = exports.from = core.from;
+/**
+ * Construct an Fx by describing an Effectful workflow that has access to a Sink
+ * to emit events and errors.
+ * @since 1.18.0
+ * @category constructors
+ */
+const fromSink = exports.fromSink = core.fromSink;
+/**
+ * Construct an Fx by describing an Scoped Effect that has access to an Emitter
+ * to emit events and errors.
+ * @since 1.18.0
+ * @category constructors
+ */
+const fromEmitter = exports.fromEmitter = core.fromEmitter;
+/**
+ * An Fx which will never emit any errors or events, and will never end
+ * @since 1.18.0
+ * @category constructors
+ */
+const never = exports.never = core.never;
+/**
+ * Construct an Fx which will emit the specified value and then end.
+ * @since 1.18.0
+ * @category constructors
+ */
+const succeed = exports.succeed = core.succeed;
+/**
+ * Construct an Fx which will emit the return of a synchronous function and then end.
+ * @since 1.18.0
+ * @category constructors
+ */
+const sync = exports.sync = core.sync;
+/**
+ * Lazily construct an Fx.
+ * @since 1.18.0
+ * @category constructors
+ */
+const suspend = exports.suspend = core.suspend;
+/**
+ * Helper for constructing your own custom subtypes of an Fx
+ * @since 1.18.0
+ * @category Subtyping
+ */
+class ToFx extends primitive.ToFx {}
+/**
+ * Create an Fx which will emit a value after waiting for a specified duration.
+ * @since 1.18.0
+ * @category constructors
+ */
+exports.ToFx = ToFx;
+const at = exports.at = internal.at;
+/**
+ * Construct an Fx which can fork effects into a Scope.
+ * @since 1.18.0
+ * @category constructors
+ */
+const withScopedFork = exports.withScopedFork = core.withScopedFork;
+/**
+ * Construct an Fx which can exit early from a Scope.
+ * @since 1.18.0
+ * @category constructors
+ */
+const withEarlyExit = exports.withEarlyExit = core.withEarlyExit;
+/**
+ * Construct an Fx which can flatten nested Fx.
+ * @since 1.18.0
+ * @category constructors
+ */
+const withFlattenStrategy = exports.withFlattenStrategy = core.withFlattenStrategy;
+/* #endregion */
+/* #region Additions */
+/**
+ * Acquire a resource, use it to construct an Fx, and then release the resource
+ * after the Fx has exited.
+ *
+ * @since 1.18.0
+ * @category constructors
+ */
+const acquireUseRelease = exports.acquireUseRelease = core.acquireUseRelease;
+/**
+ * Combine multiple Fx into a single Fx that will emit the results of all Fx
+ * as a tuple of values.
+ *
+ * @since 1.18.0
+ * @category constructors
+ */
+const combine = exports.combine = core.combine;
+/**
+ * Combine a record of Fx into a single Fx that will emit the results of all Fx
+ * as a record of values.
+ *
+ * @since 1.18.0
+ * @category constructors
+ */
+const struct = fx => map(combine(Object.entries(fx).map(([k, fx]) => map(fx, v => [k, v]))), Object.fromEntries);
+/**
+ * Combine multiple Fx into a single Fx that will emit the results of all Fx
+ * as they occur.
+ * @since 1.18.0
+ * @category constructors
+ */
+exports.struct = struct;
+const merge = exports.merge = core.merge;
+/**
+ * Combine multiple Fx into a single Fx that will emit the results of all Fx
+ * as they occur, but only allowing `n` concurrent Fx to run at a time.
+ *
+ * @since 1.18.0
+ * @category constructors
+ */
+const mergeConcurrently = exports.mergeConcurrently = core.mergeConcurrently;
+/**
+ * Combine multiple Fx into a single Fx that will emit the results of all Fx
+ * in the order the Fx were provided. All Fx will be executed concurrently,
+ * and the results will be buffered if necessary to preserve ordering.
+ *
+ * @since 1.18.0
+ * @category constructors
+ */
+const mergeBuffer = exports.mergeBuffer = core.mergeBuffer;
+/**
+ * Combine multiple Fx into a single Fx that will emit the results of all Fx
+ * in the order the Fx were provided. All Fx will be executed concurrently, limited
+ * by the provided concurrency, and the results will be buffered if necessary to preserve ordering.
+ *
+ * @since 1.18.0
+ * @category constructors
+ */
+const mergeBufferConcurrently = exports.mergeBufferConcurrently = core.mergeBufferConcurrently;
+/**
+ * Merge together multiple Fx into a single Fx that will emit the results of all Fx
+ * allowing only 1 Fx to run at a time.
+ *
+ * @since 1.18.0
+ * @category constructors
+ */
+const mergeSwitch = fxs => core.mergeSwitch(fxs);
+/**
+ * Merge together multiple Fx into a single Fx that will emit the results of the
+ * first Fx to emit a value.
+ *
+ * @since 1.18.0
+ * @category constructors
+ */
+exports.mergeSwitch = mergeSwitch;
+const race = exports.race = core.race;
+/**
+ * Schedule an Effect to run using the provided Schedule, emitting its success of failure
+ * at the intervals specified by the Schedule.
+ *
+ * @since 1.18.0
+ * @category constructors
+ */
+const fromScheduled = exports.fromScheduled = core.fromScheduled;
+/**
+ * Schedule an Effect to run at the specified duration.
+ *
+ * @since 1.18.0
+ * @category constructors
+ */
+const periodic = exports.periodic = core.periodic;
+/**
+ * Consume a Dequeue as soon as values become available and emit them as a Fx.
+ * @since 1.18.0
+ * @category constructors
+ */
+const fromDequeue = exports.fromDequeue = internal.fromDequeue;
+/**
+ * Consume a PubSub as soon as values become available and emit them as a Fx.
+ * @since 1.18.0
+ * @category constructors
+ */
+const fromPubSub = exports.fromPubSub = internal.fromPubSub;
+/* #endregion */
+/* #region Running */
+/**
+ * Run an Fx to completion with the provided Sink. The
+ * Effect will resolve with the first Error of the Fx.
+ * @since 1.18.0
+ * @category running
+ */
+const run = exports.run = /*#__PURE__*/(0, _Function.dual)(2, internalRun.run);
+/**
+ * Observe an Fx with the provided success value handler. The
+ * Effect will resolve with the first Error of the Fx.
+ *
+ * @since 1.18.0
+ * @category running
+ */
+const observe = exports.observe = /*#__PURE__*/(0, _Function.dual)(2, core.observe);
+/**
+ * Run an Fx to completion. The Effect will resolve with the first Error of the Fx.
+ *
+ * @since 1.18.0
+ * @category running
+ */
+const drain = exports.drain = core.drain;
+/**
+ * Reduce an Fx to a single value.
+ * @since 1.18.0
+ * @category running
+ */
+const reduce = exports.reduce = core.reduce;
+/**
+ * Run an Fx to completion, collecting all emitted values into an Array.
+ * @since 1.18.0
+ * @category running
+ */
+const toArray = exports.toArray = core.toArray;
+/**
+ * Run an Fx to completion, collecting all emitted values into a ReadonlyArray.
+ * @since 1.18.0
+ * @category running
+ */
+const toReadonlyArray = exports.toReadonlyArray = core.toReadonlyArray;
+/**
+ * Run an Fx to completion, collecting all emitted values into a Chunk.
+ * @since 1.18.0
+ * @category running
+ */
+const toChunk = exports.toChunk = core.toChunk;
+/**
+ * Consume an Fx and place its values into an Enqueue.
+ * @since 1.18.0
+ * @category running
+ */
+const toEnqueue = exports.toEnqueue = internal.toEnqueue;
+/* #endregion */
+/* #region Combinators */
+/**
+ * Map over the success value of an Fx.
+ * @since 1.18.0
+ * @category combinators
+ */
+const map = exports.map = core.map;
+/**
+ * Map over both failure and success values of an Fx.
+ * @since 1.18.0
+ * @category combinators
+ */
+const mapBoth = exports.mapBoth = core.mapBoth;
+/**
+ * Filter the success value of an Fx.
+ * @since 1.18.0
+ * @category combinators
+ */
+const filter = exports.filter = core.filter;
+/**
+ * Filter and map the success value of an Fx.
+ * @since 1.18.0
+ * @category combinators
+ */
+const filterMap = exports.filterMap = core.filterMap;
+/**
+ * Unwrap Options by filtering any None values.
+ * @since 1.18.0
+ * @category combinators
+ */
+const compact = exports.compact = core.compact;
+/**
+ * Map over the Cause  of an Fx.
+ * @since 1.18.0
+ * @category errors
+ */
+const mapErrorCause = exports.mapErrorCause = core.mapErrorCause;
+/**
+ * Map over the Error of an Fx.
+ * @since 1.18.0
+ * @category errors
+ */
+const mapError = exports.mapError = core.mapError;
+/**
+ * Filter the Cause of an Fx.
+ * @since 1.18.0
+ * @category errors
+ */
+const filterErrorCause = exports.filterErrorCause = core.filterCause;
+/**
+ * Filter and map the Cause of an Fx.
+ * @since 1.18.0
+ * @category errors
+ */
+const filterMapCause = exports.filterMapCause = core.filterMapCause;
+/**
+ * Filter the Error of an Fx.
+ * @since 1.18.0
+ * @category errors
+ */
+const filterError = exports.filterError = core.filterError;
+/**
+ * Filter and map the error of an Fx.
+ * @since 1.18.0
+ * @category errors
+ */
+const filterMapError = exports.filterMapError = core.filterMapError;
+/**
+ * Filter and map the error of an Fx using an Effect.
+ * @since 1.18.0
+ * @category errors
+ */
+const filterMapErrorEffect = exports.filterMapErrorEffect = core.filterMapErrorEffect;
+/**
+ * Map the success value of an Fx to another Fx, flattening the result
+ * with the provided FlattenStrategy.
+ * @since 1.18.0
+ * @category flattening
+ */
+const flatMapWithStrategy = exports.flatMapWithStrategy = /*#__PURE__*/(0, _Function.dual)(3, core.flatMapWithStrategy);
+/**
+ * Map the success value of an Fx to another Fx, switching to the latest
+ * Fx emitted and interrupting the previous.
+ * @since 1.18.0
+ * @category flattening
+ */
+const switchMap = exports.switchMap = core.switchMap;
+/**
+ * Map the success value of an Fx to another Fx, switching to the latest
+ * Fx emitted and interrupting the previous.
+ * @since 1.18.0
+ * @category flattening
+ */
+const switchLatest = exports.switchLatest = /*#__PURE__*/core.switchMap(x => x);
+/**
+ * Map the success value of an Fx to another Fx, prefering the first
+ * Fx emitted and dropping any subsequent Fx until it has completed.
+ * @since 1.18.0
+ * @category flattening
+ */
+const exhaustMap = exports.exhaustMap = core.exhaustMap;
+/**
+ * Flatten a nested Fx, prefering the first
+ * Fx emitted and dropping any subsequent Fx until it has completed.
+ * @since 1.18.0
+ * @category flattening
+ */
+const exhaust = exports.exhaust = core.exhaust;
+/**
+ * Map the success value of an Fx to another Fx, prefering the first
+ * until completion, and then running the last emitted Fx if they are not
+ * the same Fx.
+ *
+ * @since 1.18.0
+ * @category flattening
+ */
+const exhaustMapLatest = exports.exhaustMapLatest = core.exhaustMapLatest;
+/**
+ * Flatten a nested Fx, prefering the first until completion, and then running the last emitted Fx if they are not
+ * the same Fx.
+ *
+ * @since 1.18.0
+ * @category flattening
+ */
+const exhaustLatest = exports.exhaustLatest = core.exhaustLatest;
+/**
+ * Map the success value of an Fx to another Fx with unbounded concurrency.
+ *
+ * @since 1.18.0
+ * @category flattening
+ */
+const flatMap = exports.flatMap = core.flatMap;
+/**
+ * Map the success value of an Fx to another Fx with unbounded concurrency.
+ *
+ * @since 1.18.0
+ * @category flattening
+ */
+const flatten = exports.flatten = core.flatten;
+/**
+ * Map the success value of an Fx to another Fx with the specified concurrency.
+ *
+ * @since 1.18.0
+ * @category flattening
+ */
+const flatMapConcurrently = exports.flatMapConcurrently = core.flatMapConcurrently;
+/**
+ * Map the success value of an Fx to another Fx one at a time.
+ *
+ * @since 1.18.0
+ * @category flattening
+ */
+const concatMap = exports.concatMap = core.concatMap;
+/**
+ * Skip and take a number of values from an Fx.
+ *
+ * @since 1.18.0
+ * @category slicing
+ */
+const slice = exports.slice = core.slice;
+/**
+ * Take a number of values from an Fx.
+ *
+ * @since 1.18.0
+ * @category slicing
+ */
+const take = exports.take = core.take;
+/**
+ * Drop a number of values from an Fx.
+ *
+ * @since 1.18.0
+ * @category slicing
+ */
+const drop = exports.drop = core.drop;
+/**
+ * Take values from an Fx while the predicate returns true.
+ *
+ * @since 1.18.0
+ * @category slicing
+ */
+const takeWhile = exports.takeWhile = core.takeWhile;
+/**
+ * Take values from an Fx until the predicate returns true.
+ *
+ * @since 1.18.0
+ * @category slicing
+ */
+const takeUntil = exports.takeUntil = core.takeUntil;
+/**
+ * Drop values from an Fx while the predicate returns true.
+ *
+ * @since 1.18.0
+ * @category slicing
+ */
+const dropWhile = exports.dropWhile = core.dropWhile;
+/**
+ * Drop values from an Fx until the predicate returns true.
+ *
+ * @since 1.18.0
+ * @category slicing
+ */
+const dropUntil = exports.dropUntil = core.dropUntil;
+/**
+ * Drop values from an Fx after the predicate returns true.
+ *
+ * @since 1.18.0
+ * @category slicing
+ */
+const dropAfter = exports.dropAfter = core.dropAfter;
+/**
+ * Concatenate an Fx after the successful completion of another Fx
+ *
+ * @since 1.18.0
+ * @category combinators
+ */
+const continueWith = exports.continueWith = core.continueWith;
+/**
+ * Concatenate an Fx after the failure of another Fx
+ *
+ * @since 1.18.0
+ * @category combinators
+ */
+const orElse = exports.orElse = core.recoverWith;
+/**
+ * Map the success value of an Fx to an Effect, doesn't fork any fibers like flatMap* etc.
+ *
+ * @since 1.18.0
+ * @category combinators
+ */
+const mapEffect = exports.mapEffect = core.mapEffect;
+/**
+ * Perform an Effect for each value emitted by an Fx, not affecting the output of the Fx.
+ *
+ * @since 1.18.0
+ * @category combinators
+ */
+const tap = exports.tap = core.tap;
+/**
+ * Filter the success value of an Fx with an Effect.
+ *
+ * @since 1.18.0
+ * @category combinators
+ */
+const filterEffect = exports.filterEffect = core.filterEffect;
+/**
+ * Filter and map the success value of an Fx with an Effect.
+ *
+ * @since 1.18.0
+ * @category combinators
+ */
+const filterMapEffect = exports.filterMapEffect = core.filterMapEffect;
+/**
+ * Apply a function to the constructed Effect that represents the running Fx.
+ *
+ * @since 1.18.0
+ * @category combinators
+ */
+const middleware = exports.middleware = core.middleware;
+/**
+ * Accumulate a value over the success values of an Fx and atomically produce derived value.
+ *
+ * @since 1.18.0
+ * @category combinators
+ */
+const loop = exports.loop = core.loop;
+/**
+ * Emit values with their previously emitted values when possible.
+ *
+ * @since 1.18.0
+ * @category combinators
+ */
+const withPrevious = fx => loop(fx, Option.none(), (previous, current) => [[previous, current], Option.some(current)]);
+/**
+ * Accumulate a value over the success values of an Fx and atomically produce derived value
+ * useing an Effect. A SynchronizedRef is utilized to ensure ordering of events.
+ *
+ * @since 1.18.0
+ * @category combinators
+ */
+exports.withPrevious = withPrevious;
+const loopEffect = exports.loopEffect = core.loopEffect;
+/**
+ * Prepends a value to the beginning of an Fx.
+ *
+ * @since 1.18.0
+ * @category combinators
+ */
+const startWith = exports.startWith = core.startWith;
+/**
+ * Appends a value to the end of an Fx.
+ *
+ * @since 1.18.0
+ * @category combinators
+ */
+const endWith = exports.endWith = core.endWith;
+/**
+ * Run a reducer over the success values of an Fx.
+ *
+ * @since 1.18.0
+ * @category combinators
+ */
+const scan = exports.scan = core.scan;
+/**
+ * Run an Effect-ful reducer over the success values of an Fx.
+ *
+ * @since 1.18.0
+ * @category combinators
+ */
+const scanEffect = exports.scanEffect = core.scanEffect;
+/**
+ * Map the failures of an Fx to another Fx, flattening the result
+ * with the provided FlattenStrategy.
+ * @since 1.18.0
+ * @category flattening
+ */
+const flatMapCauseWithStrategy = exports.flatMapCauseWithStrategy = core.flatMapCauseWithStrategy;
+/**
+ * Map the failures of an Fx to another Fx, flattening the result
+ * with the provided FlattenStrategy.
+ * @since 1.18.0
+ * @category flattening
+ */
+const flatMapErrorWithStrategy = exports.flatMapErrorWithStrategy = core.flatMapErrorWithStrategy;
+/**
+ * Map the failures of an Fx to another Fx, flattening the result with unbounded concurrency.
+ *
+ * @since 1.18.0
+ * @category flattening
+ */
+const flatMapCause = exports.flatMapCause = core.flatMapCause;
+/**
+ * Map the failures of an Fx to another Fx, flattening the result with unbounded concurrency.
+ *
+ * @since 1.18.0
+ * @category flattening
+ */
+const flatMapError = exports.flatMapError = core.flatMapError;
+/**
+ * Map the failures of an Fx to another Fx with the specified concurrency.
+ *
+ * @since 1.18.0
+ * @category flattening
+ */
+const flatMapCauseConcurrently = exports.flatMapCauseConcurrently = core.flatMapCauseConcurrently;
+/**
+ * Map the failures of an Fx to another Fx with the specified concurrency.
+ *
+ * @since 1.18.0
+ * @category flattening
+ */
+const flatMapErrorConcurrently = exports.flatMapErrorConcurrently = core.flatMapErrorConcurrently;
+/**
+ * Map the failures of an Fx to another Fx, switching to the latest
+ * Fx emitted and interrupting the previous.
+ *
+ * @since 1.18.0
+ * @category flattening
+ */
+const switchMapCause = exports.switchMapCause = core.switchMapCause;
+/**
+ * Map the failures of an Fx to another Fx, switching to the latest
+ * Fx emitted and interrupting the previous.
+ *
+ * @since 1.18.0
+ * @category flattening
+ */
+const switchMapError = exports.switchMapError = core.switchMapError;
+/**
+ * Map the failures of an Fx to another Fx, prefering the first
+ * Fx emitted and dropping any subsequent Fx until it has completed.
+ *
+ * @since 1.18.0
+ * @category flattening
+ */
+const exhaustMapCause = exports.exhaustMapCause = core.exhaustMapCause;
+/**
+ * Map the failures of an Fx to another Fx, prefering the first
+ * Fx emitted and dropping any subsequent Fx until it has completed.
+ *
+ * @since 1.18.0
+ * @category flattening
+ */
+const exhaustMapError = exports.exhaustMapError = core.exhaustMapError;
+/**
+ * Map the failures of an Fx to another Fx, prefering the first
+ * until completion, and then running the last emitted Fx if they are not
+ * the same Fx.
+ *
+ * @since 1.18.0
+ * @category flattening
+ */
+const exhaustMapLatestCause = exports.exhaustMapLatestCause = core.exhaustMapLatestCause;
+/**
+ * Map the failures of an Fx to another Fx,  prefering the first
+ * until completion, and then running the last emitted Fx if they are not
+ * the same Fx.
+ *
+ * @since 1.18.0
+ * @category flattening
+ */
+const exhaustMapLatestError = exports.exhaustMapLatestError = core.exhaustMapLatestError;
+/**
+ * Map over the failures and successes of an Fx, flattening both using the same strategy.
+ *
+ * @since 1.18.0
+ * @category flattening
+ */
+const matchCauseWithStrategy = exports.matchCauseWithStrategy = core.matchCauseWithStrategy;
+/**
+ * Map over the failures and successes of an Fx, flattening both using the same strategy.
+ *
+ * @since 1.18.0
+ * @category flattening
+ */
+const matchErrorWithStrategy = exports.matchErrorWithStrategy = core.matchErrorWithStrategy;
+/**
+ * Map over the failures and successes of an Fx, flattening both with unbounded concurrency.
+ *
+ * @since 1.18.0
+ * @category flattening
+ */
+const matchCause = exports.matchCause = core.matchCause;
+/**
+ * Map over the failures and successes of an Fx, flattening both with unbounded concurrency.
+ *
+ * @since 1.18.0
+ * @category flattening
+ */
+const match = exports.match = core.match;
+/**
+ * Map over the failures and successes of an Fx, flattening both with the specified concurrency.
+ *
+ * @since 1.18.0
+ * @category flattening
+ */
+const matchCauseConcurrently = exports.matchCauseConcurrently = core.matchCauseConcurrently;
+/**
+ * Map over the failures and successes of an Fx, flattening both with the specified concurrency.
+ *
+ * @since 1.18.0
+ * @category flattening
+ */
+const matchErrorConcurrently = exports.matchErrorConcurrently = core.matchErrorConcurrently;
+/**
+ * Map over the failures and successes of an Fx, switching to the latest
+ * Fx emitted and interrupting the previous.
+ *
+ * @since 1.18.0
+ * @category flattening
+ */
+const switchMatchCause = exports.switchMatchCause = core.switchMatchCause;
+/**
+ * Map over the failures and successes of an Fx, switching to the latest
+ * Fx emitted and interrupting the previous.
+ *
+ * @since 1.18.0
+ * @category flattening
+ */
+const switchMatch = exports.switchMatch = core.switchMatch;
+/**
+ * Map over the failures and successes of an Fx, prefering the first
+ * Fx emitted and dropping any subsequent Fx until it has completed.
+ *
+ * @since 1.18.0
+ * @category flattening
+ */
+const exhaustMatchCause = exports.exhaustMatchCause = core.exhaustMatchCause;
+/**
+ * Map over the failures and successes of an Fx, prefering the first
+ * Fx emitted and dropping any subsequent Fx until it has completed.
+ *
+ * @since 1.18.0
+ * @category flattening
+ */
+const exhaustMatch = exports.exhaustMatch = core.exhaustMatch;
+/**
+ * Map over the failures and successes of an Fx, prefering the first
+ * Fx emitted and starting the latest Fx when the first completes
+ * if they are not the same Fx.
+ *
+ * @since 1.18.0
+ * @category flattening
+ */
+const exhaustLatestMatchCause = exports.exhaustLatestMatchCause = core.exhaustLatestMatchCause;
+/**
+ * Map over the failures and successes of an Fx, prefering the first
+ * Fx emitted and starting the latest Fx when the first completes
+ * if they are not the same Fx.
+ *
+ * @since 1.18.0
+ * @category flattening
+ */
+const exhaustLatestMatch = exports.exhaustLatestMatch = core.exhaustLatestMatch;
+/**
+ * Listen to the events of an Fx within the provided window. When the window Fx
+ * emits the inner stream, the fx will begin allowing events to pass through,
+ * and when the inner stream emits, the fx will be interrupted.
+ *
+ * @since 1.18.0
+ * @category time slicing
+ */
+const during = exports.during = core.during;
+/**
+ * Listen to the events of an Fx after the provided window emits.
+ *
+ * @since 1.18.0
+ * @category time slicing
+ */
+const since = exports.since = core.since;
+/**
+ * Listen to the events of an Fx until the provided window emits.
+ *
+ * @since 1.18.0
+ * @category time slicing
+ */
+const until = exports.until = core.until;
+/**
+ * Provide the environment to an Fx.
+ *
+ * @since 1.18.0
+ * @category context
+ */
+const provide = exports.provide = core.provide;
+/**
+ * Provide a service to an Fx using a Tag.
+ * @since 1.18.0
+ * @category context
+ */
+const provideService = exports.provideService = core.provideService;
+/**
+ * Provide a service using an Effect to an Fx using a Tag.
+ *
+ * @since 1.18.0
+ * @category context
+ */
+const provideServiceEffect = exports.provideServiceEffect = core.provideServiceEffect;
+/**
+ * Skip repeated values, using the provided Equivalence to compare values.
+ *
+ * @since 1.18.0
+ * @category slicing
+ */
+const skipRepeatsWith = exports.skipRepeatsWith = core.skipRepeatsWith;
+/**
+ * Skip repeated values, using @effect/data/Equal for value comparison.
+ *
+ * @since 1.18.0
+ * @category slicing
+ */
+const skipRepeats = exports.skipRepeats = core.skipRepeats;
+/**
+ * Sample the values of an Fx, or Effect, during the events of another Fx.
+ *
+ * @since 1.18.0
+ * @category combinators
+ */
+const snapshot = exports.snapshot = core.snapshot;
+/**
+ * Share the output of an Fx, or Effect, with other Fx's using the behavior of the
+ * provided Subject.
+ *
+ * @since 1.18.0
+ * @category sharing
+ */
+const share = exports.share = Share.share;
+/**
+ * Effeciently share an underlying stream with multiple subscribers.
+ *
+ * @since 1.18.0
+ * @category sharing
+ */
+const multicast = exports.multicast = Share.multicast;
+/**
+ * Effeciently share an underlying stream with multiple subscribers, saving the most
+ * recent event and emitting it to new subscribers.
+ *
+ * @since 1.18.0
+ * @category sharing
+ */
+const hold = exports.hold = Share.hold;
+/**
+ * Effeciently share an underlying stream with multiple subscribers,
+ * saving up to the most recent `n` events and emitting them to new subscribers.
+ *
+ * @since 1.18.0
+ * @category sharing
+ */
+const replay = exports.replay = Share.replay;
+/**
+ * Create an Fx which will wait a specified duration of time where no
+ * events have occurred before emitting a value.
+ * @since 1.18.0
+ * @category time slicing
+ */
+const debounce = exports.debounce = internal.debounce;
+/**
+ * Create an Fx which will wait a specified duration of time before emitting
+ * an event after the last event.
+ * @since 1.18.0
+ * @category time slicing
+ */
+const throttle = exports.throttle = internal.throttle;
+/**
+ * Create an Fx which will wait a specified duration of time where no
+ * events have occurred before emitting a value.
+ * @since 1.18.0
+ * @category combinators
+ */
+const delay = exports.delay = internal.delay;
+/**
+ * Run an Effect to produce an Fx to run.
+ * @since 1.18.0
+ * @category constructors
+ */
+const fromFxEffect = exports.fromFxEffect = internal.fromFxEffect;
+/**
+ * Utilize Effect.gen to construct an Fx
+ * @since 1.18.0
+ * @category constructors
+ */
+function gen(f) {
+  return fromFxEffect(Effect.gen(f));
 }
-exports.Fx = Fx;
-function isFx(v) {
-    return v !== null && typeof v === 'object' && exports.FxTypeId in v;
+/**
+ * Utilize Effect.gen to construct an Fx
+ * @since 1.18.0
+ * @category constructors
+ */
+function genScoped(f) {
+  return scoped(fromFxEffect(Effect.gen(f)));
 }
-exports.isFx = isFx;
-var Sink_js_1 = require("./Sink.js");
-Object.defineProperty(exports, "Sink", { enumerable: true, get: function () { return Sink_js_1.Sink; } });
+/**
+ * Run an Effect when an Fx exits
+ * @since 1.18.0
+ * @category lifecycles
+ */
+const onExit = exports.onExit = internal.onExit;
+/**
+ * Run an Effect when an Fx is interrupted
+ * @since 1.18.0
+ * @category lifecycles
+ */
+const onInterrupt = exports.onInterrupt = internal.onInterrupt;
+/**
+ * Run an Effect when an Fx ends with an error
+ * @since 1.18.0
+ * @category lifecycles
+ */
+const onError = exports.onError = internal.onError;
+/**
+ * Provide a Scope to an Fx
+ * @since 1.18.0
+ * @category context
+ */
+const scoped = exports.scoped = internal.scoped;
+/**
+ * Annotate the logs of an Fx
+ * @since 1.18.0
+ * @category combinators
+ */
+const annotateLogs = exports.annotateLogs = internal.annotateLogs;
+/**
+ * Annotate the spans of an Fx
+ * @since 1.18.0
+ * @category combinators
+ */
+const annotateSpans = exports.annotateSpans = internal.annotateSpans;
+/**
+ * Create an Fx which will succeed with Option.None
+ * @since 1.18.0
+ * @category constructors
+ */
+const succeedNone = exports.succeedNone = internal.succeedNone;
+/**
+ * Create an Fx which will succeed with Option.Some
+ * @since 1.18.0
+ * @category constructors
+ */
+const succeedSome = exports.succeedSome = internal.succeedSome;
+/**
+ * Do simulation
+ * @since 1.18.0
+ * @category Do
+ */
+const Do = exports.Do = internal.Do;
+/**
+ * Do simulation
+ * @since 1.18.0
+ * @category Do
+ */
+const bind = exports.bind = internal.bind;
+/**
+ * Do simulation
+ * @since 1.18.0
+ * @category Do
+ */
+const bindTo = exports.bindTo = internal.bindTo;
+const let_ = exports.let = internal.let;
+/**
+ * Ensure a finalizer runs on Fx ext.
+ * @since 1.18.0
+ * @category combinators
+ */
+const ensuring = exports.ensuring = internal.ensuring;
+/**
+ * Capture the errors and success values as Exit
+ * @since 1.18.0
+ * @category combinators
+ */
+const exit = exports.exit = internal.exit;
+/**
+ * Capture the errors and success values as Either
+ * @since 1.18.0
+ * @category combinators
+ */
+const either = exports.either = internal.either;
+/**
+ * Run an Fx until finding a value which satisfies the predicate.
+ * @since 1.18.0
+ * @category running
+ */
+const findFirst = exports.findFirst = internal.findFirst;
+/**
+ * Grab the first value emitted by an Fx
+ * @since 1.18.0
+ * @category running
+ */
+const first = exports.first = /*#__PURE__*/findFirst( /*#__PURE__*/(0, _Function.constant)( /*#__PURE__*/Effect.succeed(true)));
+/**
+ * Transform success values into failures and failures into successes.
+ * @since 1.18.0
+ * @category combinators
+ */
+const flip = exports.flip = internal.flip;
+/**
+ * Lift a nullable value into an Fx
+ * @since 1.18.0
+ * @category constructors
+ */
+const fromNullable = exports.fromNullable = internal.fromNullable;
+const if_ = exports.if = internal.if;
+/**
+ * Logical if/else using static values.
+ * @since 1.18.0
+ * @category combinators
+ */
+const when = exports.when = internal.when;
+/**
+ * Mark an Fx as interruptible
+ * @since 1.18.0
+ * @category combinators
+ */
+const interruptible = exports.interruptible = internal.interruptible;
+/**
+ * Mark an Fx as uninterruptible
+ * @since 1.18.0
+ * @category combinators
+ */
+const uninterruptible = exports.uninterruptible = internal.uninterruptible;
+/**
+ * Locally set the value of a FiberRef
+ * @since 1.18.0
+ * @category FiberRef
+ */
+const locally = exports.locally = internal.locally;
+/**
+ * Locally set the value of a FiberRef by updating the current value
+ * @since 1.18.0
+ * @category FiberRef
+ */
+const locallyWith = exports.locallyWith = internal.locallyWith;
+/**
+ * Enable/disable tracer timing for an Fx
+ * @since 1.18.0
+ * @category tracing
+ */
+const withTracerTiming = exports.withTracerTiming = internal.withTracerTiming;
+/**
+ * Configure the concurreny limit of Fibers running within an Fx
+ * @since 1.18.0
+ * @category concurrency
+ */
+const withConcurrency = exports.withConcurrency = internal.withConcurrency;
+/**
+ * Add a span to your log messages
+ * @since 1.18.0
+ * @category logging
+ */
+const withLogSpan = exports.withLogSpan = internal.withLogSpan;
+/**
+ * Configure the maximum number of operations to run before yielding to the runtime
+ * @since 1.18.0
+ * @category concurrency
+ */
+const withMaxOpsBeforeYield = exports.withMaxOpsBeforeYield = internal.withMaxOpsBeforeYield;
+/**
+ * Set the parent Span of an Fx
+ * @since 1.18.0
+ * @category tracing
+ */
+const withParentSpan = exports.withParentSpan = internal.withParentSpan;
+/**
+ * Enable/disable request batching within an Fx
+ * @since 1.18.0
+ * @category batching
+ */
+const withRequestBatching = exports.withRequestBatching = internal.withRequestBatching;
+/**
+ * Set the request cache Effects running within an Fx
+ * @since 1.18.0
+ * @category batching
+ */
+const withRequestCache = exports.withRequestCache = internal.withRequestCache;
+/**
+ * Enable/disable request caching within an Fx
+ * @since 1.18.0
+ * @category batching
+ */
+const withRequestCaching = exports.withRequestCaching = internal.withRequestCaching;
+/**
+ * Configure the scheduler to use within an Fx
+ * @since 1.18.0
+ * @category concurrency
+ */
+const withScheduler = exports.withScheduler = internal.withScheduler;
+/**
+ * Set the span of an Fx
+ * @since 1.18.0
+ * @category tracing
+ */
+const withSpan = exports.withSpan = internal.withSpan;
+/**
+ * Set the tracer used within an Fx
+ * @since 1.18.0
+ * @category tracing
+ */
+const withTracer = exports.withTracer = internal.withTracer;
+/**
+ * Partition an Fx into two Fx's based on a either-returning function.
+ * @since 1.18.0
+ * @category combinators
+ */
+const partitionMap = exports.partitionMap = internal.partitionMap;
+/**
+ * Convert a list of keyed values into persistent workflows for given each key of the list
+ * even when the list has been re-ordered.
+ *
+ * @since 1.18.0
+ * @category combinators
+ */
+const keyed = exports.keyed = /*#__PURE__*/(0, _Function.dual)(3, internalKeyed.keyed);
+/**
+ * Map an Fx of values into workflows similar to Fx.switchMap, but
+ * instead of providing the value directly, it is exposed as a RefSubject to
+ * allow creating a persistent workflows similar to Fx.keyed but for a single value.
+ *
+ * @since 1.18.0
+ * @category combinators
+ */
+const withKey = exports.withKey = /*#__PURE__*/(0, _Function.dual)(3, internalWithKey.withKey);
+const getTag = a => a._tag;
+/**
+ * Match over a tagged union of values into a set of persistent workflows
+ * that allow listening to changes of values with the same tag using the same
+ * Fx.
+ *
+ * @since 1.18.0
+ * @category combinators
+ */
+const matchTags = exports.matchTags = /*#__PURE__*/(0, _Function.dual)(2, function matchTags(fx, matchers) {
+  return withKey(fx, getTag, (ref, tag) => matchers[tag](ref));
+});
+/**
+ * @since 1.18.0
+ */
+const drainLayer = exports.drainLayer = internal.drainLayer;
+/* #endregion */
+/**
+ * @since 1.18.0
+ */
+function isFx(u) {
+  return typeof u === "object" && u !== null && _TypeId.TypeId in u;
+}
+/**
+ * @since 1.18.0
+ */
+const matchOption = exports.matchOption = /*#__PURE__*/(0, _Function.dual)(3, function matchOption(fx, onNone, onSome) {
+  return matchTags(fx, {
+    None: onNone,
+    Some: some => onSome((0, _RefSubject.transform)(some, s => s.value, value => Option.some(value)))
+  });
+});
+/**
+ * @since 1.18.0
+ */
+const getOrElse = exports.getOrElse = /*#__PURE__*/(0, _Function.dual)(2, function getOrElse(fx, orElse) {
+  return matchOption(fx, orElse, _Function.identity);
+});
+/**
+ * @since 1.18.0
+ */
+const matchEither = exports.matchEither = /*#__PURE__*/(0, _Function.dual)(3, function matchEither(fx, onLeft, onRight) {
+  return matchTags(fx, {
+    Left: left => onLeft((0, _RefSubject.transform)(left, a => a.left, a => Either.left(a))),
+    Right: right => onRight((0, _RefSubject.transform)(right, s => s.right, value => Either.right(value)))
+  });
+});
+/**
+ * @since 1.18.0
+ */
+const fork = fx => Effect.fork(drain(fx));
+/**
+ * @since 1.18.0
+ */
+exports.fork = fork;
+const forkScoped = fx => Effect.forkScoped(drain(fx));
+/**
+ * @since 1.18.0
+ */
+exports.forkScoped = forkScoped;
+const forkDaemon = fx => Effect.forkDaemon(drain(fx));
+/**
+ * @since 1.18.0
+ */
+exports.forkDaemon = forkDaemon;
+const forkIn = exports.forkIn = /*#__PURE__*/(0, _Function.dual)(2, (fx, scope) => Effect.forkIn(drain(fx), scope));
+/**
+ * @since 1.18.0
+ */
+const mergeRace = exports.mergeRace = internal.mergeRace;
 //# sourceMappingURL=Fx.js.map