@typed/fx 1.32.0 → 2.0.0-beta.0

package/dist/cjs/internal/core.js

@@ -1,1783 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.acquireUseRelease = acquireUseRelease;
-exports.all = all;
-exports.annotateLogs = annotateLogs;
-exports.annotateSpans = annotateSpans;
-exports.append = append;
-exports.appendAll = appendAll;
-exports.concatMap = concatMap;
-exports.continueWith = continueWith;
-exports.debounce = debounce;
-exports.drop = exports.drain = exports.die = exports.deepEquals = void 0;
-exports.dropAfter = dropAfter;
-exports.dropAfterEffect = dropAfterEffect;
-exports.dropUntil = dropUntil;
-exports.dropUntilEffect = dropUntilEffect;
-exports.dropWhile = dropWhile;
-exports.dropWhileEffect = dropWhileEffect;
-exports.during = during;
-exports.either = either;
-exports.empty = void 0;
-exports.exhaustFilterMapLatestEffect = exhaustFilterMapLatestEffect;
-exports.exhaustMap = exhaustMap;
-exports.exhaustMapCause = exhaustMapCause;
-exports.exhaustMapEffect = exhaustMapEffect;
-exports.exhaustMapError = exhaustMapError;
-exports.exhaustMapLatest = exhaustMapLatest;
-exports.exhaustMapLatestCause = exhaustMapLatestCause;
-exports.exhaustMapLatestEffect = exhaustMapLatestEffect;
-exports.exhaustMapLatestError = exhaustMapLatestError;
-exports.exhaustMatchCause = exhaustMatchCause;
-exports.exhaustMatchError = exhaustMatchError;
-exports.exhaustMatchLatestCause = exhaustMatchLatestCause;
-exports.exhaustMatchLatestError = exhaustMatchLatestError;
-exports.exit = exit;
-exports.filter = exports.failCause = exports.fail = void 0;
-exports.filterCause = filterCause;
-exports.filterCauseEffect = filterCauseEffect;
-exports.filterEffect = void 0;
-exports.filterError = filterError;
-exports.filterErrorEffect = filterErrorEffect;
-exports.filterMap = void 0;
-exports.filterMapCause = filterMapCause;
-exports.filterMapCauseEffect = filterMapCauseEffect;
-exports.filterMapEffect = void 0;
-exports.filterMapError = filterMapError;
-exports.filterMapErrorEffect = filterMapErrorEffect;
-exports.filterMapLoop = void 0;
-exports.filterMapLoopCause = filterMapLoopCause;
-exports.filterMapLoopCauseEffect = filterMapLoopCauseEffect;
-exports.filterMapLoopEffect = void 0;
-exports.filterMapLoopError = filterMapLoopError;
-exports.filterMapLoopErrorEffect = filterMapLoopErrorEffect;
-exports.findFirst = findFirst;
-exports.first = first;
-exports.flatMap = flatMap;
-exports.flatMapCause = flatMapCause;
-exports.flatMapCauseConcurrently = flatMapCauseConcurrently;
-exports.flatMapCauseWithStrategy = flatMapCauseWithStrategy;
-exports.flatMapConcurrently = flatMapConcurrently;
-exports.flatMapConcurrentlyEffect = flatMapConcurrentlyEffect;
-exports.flatMapEffect = flatMapEffect;
-exports.flatMapError = flatMapError;
-exports.flatMapErrorConcurrently = flatMapErrorConcurrently;
-exports.flatMapErrorWithStrategy = flatMapErrorWithStrategy;
-exports.flatMapWithStrategy = flatMapWithStrategy;
-exports.fromArray = void 0;
-exports.fromAsyncIterable = fromAsyncIterable;
-exports.fromEffect = void 0;
-exports.fromFxEffect = fromFxEffect;
-exports.fromSync = exports.fromScheduled = exports.fromIterable = void 0;
-exports.gen = gen;
-exports.genScoped = genScoped;
-exports.if = if_;
-exports.interruptible = void 0;
-exports.isEmpty = isEmpty;
-exports.isFailCause = isFailCause;
-exports.isNever = isNever;
-exports.isPadWith = isPadWith;
-exports.isProducer = isProducer;
-exports.isProducerEffect = isProducerEffect;
-exports.isProducerEffectTransformer = isProducerEffectTransformer;
-exports.isProducerSyncTransformer = isProducerSyncTransformer;
-exports.isSlice = isSlice;
-exports.isTransformer = isTransformer;
-exports.locally = locally;
-exports.locallyWith = locallyWith;
-exports.loop = void 0;
-exports.loopCause = loopCause;
-exports.loopCauseEffect = loopCauseEffect;
-exports.loopEffect = void 0;
-exports.loopError = loopError;
-exports.loopErrorEffect = loopErrorEffect;
-exports.make = make;
-exports.map = void 0;
-exports.mapBoth = mapBoth;
-exports.mapCause = mapCause;
-exports.mapCauseEffect = mapCauseEffect;
-exports.mapEffect = void 0;
-exports.mapError = mapError;
-exports.mapErrorEffect = mapErrorEffect;
-exports.matchCause = matchCause;
-exports.matchCauseConcurrently = matchCauseConcurrently;
-exports.matchCauseWithStrategy = matchCauseWithStrategy;
-exports.matchError = matchError;
-exports.matchErrorConcurrently = matchErrorConcurrently;
-exports.matchErrorWithStrategy = matchErrorWithStrategy;
-exports.merge = merge;
-exports.mergeAll = mergeAll;
-exports.mergeFirst = mergeFirst;
-exports.mergeOrdered = mergeOrdered;
-exports.mergeOrderedConcurrently = mergeOrderedConcurrently;
-exports.mergeRace = mergeRace;
-exports.mergeSwitch = mergeSwitch;
-exports.mergeWithStrategy = mergeWithStrategy;
-exports.middleware = middleware;
-exports.observe = exports.never = void 0;
-exports.onError = onError;
-exports.onExit = onExit;
-exports.onInterrupt = onInterrupt;
-exports.orElse = orElse;
-exports.orElseCause = orElseCause;
-exports.padWith = padWith;
-exports.prepend = prepend;
-exports.prependAll = prependAll;
-exports.provide = provide;
-exports.provideContext = provideContext;
-exports.provideLayer = provideLayer;
-exports.provideRuntime = provideRuntime;
-exports.provideService = provideService;
-exports.provideServiceEffect = provideServiceEffect;
-exports.race = race;
-exports.raceAll = raceAll;
-exports.reduce = void 0;
-exports.sample = sample;
-exports.scan = scan;
-exports.scoped = exports.schedule = void 0;
-exports.since = since;
-exports.skipRepeats = skipRepeats;
-exports.skipRepeatsWith = skipRepeatsWith;
-exports.slice = void 0;
-exports.snapshot = snapshot;
-exports.snapshotEffect = snapshotEffect;
-exports.struct = struct;
-exports.succeed = void 0;
-exports.suspend = suspend;
-exports.switchMap = switchMap;
-exports.switchMapCause = switchMapCause;
-exports.switchMapEffect = switchMapEffect;
-exports.switchMapError = switchMapError;
-exports.switchMatchCause = switchMatchCause;
-exports.switchMatchError = switchMatchError;
-exports.take = void 0;
-exports.takeUntil = takeUntil;
-exports.takeUntilEffect = takeUntilEffect;
-exports.takeWhile = takeWhile;
-exports.takeWhileEffect = takeWhileEffect;
-exports.tapEffect = void 0;
-exports.throttle = throttle;
-exports.throttleLatest = throttleLatest;
-exports.toEnqueue = toEnqueue;
-exports.toReadonlyArray = void 0;
-exports.tuple = tuple;
-exports.uninterruptible = void 0;
-exports.until = until;
-exports.when = when;
-exports.withConcurrency = withConcurrency;
-exports.withConfigProvider = withConfigProvider;
-exports.withLogSpan = withLogSpan;
-exports.withMaxOpsBeforeYield = withMaxOpsBeforeYield;
-exports.withParentSpan = withParentSpan;
-exports.withPrevious = void 0;
-exports.withRequestBatching = withRequestBatching;
-exports.withRequestCache = withRequestCache;
-exports.withRequestCaching = withRequestCaching;
-exports.withScheduler = withScheduler;
-exports.withSpan = withSpan;
-exports.withTracer = withTracer;
-exports.withTracerTiming = withTracerTiming;
-var Context = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("@typed/context"));
-var _effect = /*#__PURE__*/require("effect");
-var Boolean = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("effect/Boolean"));
-var Cause = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("effect/Cause"));
-var Clock = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("effect/Clock"));
-var Deferred = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("effect/Deferred"));
-var Effect = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("effect/Effect"));
-var Either = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("effect/Either"));
-var Equal = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("effect/Equal"));
-var _Equivalence = /*#__PURE__*/require("effect/Equivalence");
-var ExecutionStrategy = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("effect/ExecutionStrategy"));
-var Exit = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("effect/Exit"));
-var Fiber = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("effect/Fiber"));
-var _Function = /*#__PURE__*/require("effect/Function");
-var Layer = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("effect/Layer"));
-var Option = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("effect/Option"));
-var Predicate = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("effect/Predicate"));
-var Ref = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("effect/Ref"));
-var Scope = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("effect/Scope"));
-var Tracer = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("effect/Tracer"));
-var Unify = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("effect/Unify"));
-var Sink = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("../Sink.js"));
-var _bounds = /*#__PURE__*/require("./bounds.js");
-var EffectLoopOp = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("./effect-loop-operator.js"));
-var EffectOp = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("./effect-operator.js"));
-var EffectProducer = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("./effect-producer.js"));
-var _helpers = /*#__PURE__*/require("./helpers.js");
-var SyncLoopOp = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("./loop-operator.js"));
-var Op = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("./operator.js"));
-var _protos = /*#__PURE__*/require("./protos.js");
-var Provide = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("./provide.js"));
-var _strategies = /*#__PURE__*/require("./strategies.js");
-var SyncOp = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("./sync-operator.js"));
-var SyncProducer = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("./sync-producer.js"));
-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 && {}.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; }
-const DISCARD = {
-  discard: true
-};
-const UNBOUNDED = {
-  concurrency: "unbounded"
-};
-function make(run) {
-  return new Make(run);
-}
-class Make extends _protos.FxBase {
-  _run;
-  constructor(_run) {
-    super();
-    this._run = _run;
-  }
-  run(sink) {
-    return Effect.contextWithEffect(ctx => this._run(Sink.provide(sink, ctx)));
-  }
-}
-/**
- * @internal
- */
-class Producer extends _protos.FxBase {
-  i0;
-  constructor(i0) {
-    super();
-    this.i0 = i0;
-  }
-  run(sink) {
-    return SyncProducer.runSink(this.i0, sink);
-  }
-}
-/**
- * @internal
- */
-function isProducer(fx) {
-  return fx.constructor === Producer;
-}
-const succeed = value => new Producer(SyncProducer.Success(value));
-exports.succeed = succeed;
-const fromSync = f => new Producer(SyncProducer.FromSync(f));
-exports.fromSync = fromSync;
-const fromArray = array => new Producer(SyncProducer.FromArray(array));
-exports.fromArray = fromArray;
-const fromIterable = iterable => new Producer(SyncProducer.FromIterable(iterable));
-exports.fromIterable = fromIterable;
-class ProducerEffect extends _protos.FxBase {
-  i0;
-  constructor(i0) {
-    super();
-    this.i0 = i0;
-  }
-  run(sink) {
-    return EffectProducer.runSink(this.i0, sink);
-  }
-}
-/**
- * @internal
- */
-function isProducerEffect(fx) {
-  return fx.constructor === ProducerEffect;
-}
-const fromEffect = effect => (0, _helpers.matchEffectPrimitive)(effect, {
-  // Match over Effect primitives and return Fx primitives to allow fusion to take place
-  Success: succeed,
-  Failure: failCause,
-  Sync: fromSync,
-  Left: fail,
-  Right: succeed,
-  Some: succeed,
-  None: fail,
-  Otherwise: effect => new ProducerEffect(EffectProducer.FromEffect(effect))
-});
-exports.fromEffect = fromEffect;
-const fromScheduled = (input, schedule) => new ProducerEffect(EffectProducer.FromScheduled(input, schedule));
-exports.fromScheduled = fromScheduled;
-const schedule = (input, schedule) => new ProducerEffect(EffectProducer.Scheduled(input, schedule));
-exports.schedule = schedule;
-class FailCause extends _protos.FxBase {
-  i0;
-  constructor(i0) {
-    super();
-    this.i0 = i0;
-  }
-  run(sink) {
-    return sink.onFailure(this.i0);
-  }
-}
-/**
- * @internal
- */
-function isFailCause(fx) {
-  return fx.constructor === FailCause;
-}
-const failCause = cause => new FailCause(cause);
-exports.failCause = failCause;
-const fail = error => failCause(Cause.fail(error));
-exports.fail = fail;
-const die = error => failCause(Cause.die(error));
-exports.die = die;
-class Transformer extends _protos.FxBase {
-  i0;
-  i1;
-  constructor(i0, i1) {
-    super();
-    this.i0 = i0;
-    this.i1 = i1;
-  }
-  run(sink) {
-    return this.i0.run(Op.compileOperatorSink(this.i1, sink));
-  }
-  static make(fx, operator) {
-    if (isEmpty(fx) || isNever(fx)) return fx;else if (isProducer(fx)) {
-      return new ProducerSyncTransformer(fx.i0, operator);
-    } else if (isTransformer(fx)) {
-      return new Transformer(fx.i0, Op.fuseOperators(fx.i1, operator));
-    } else if (isProducerSyncTransformer(fx)) {
-      return new ProducerSyncTransformer(fx.i0, Op.fuseOperators(fx.i1, operator));
-    } else if (isProducerEffect(fx)) {
-      return new ProducerEffectTransformer(fx.i0, operator);
-    } else if (isProducerEffectTransformer(fx)) {
-      return new ProducerEffectTransformer(fx.i0, Op.fuseOperators(fx.i1, operator));
-    } else if (isSuspend(fx)) {
-      return new SuspendedTransformer(fx.i0, operator);
-    } else if (isSuspendedTransformer(fx)) {
-      return new SuspendedTransformer(fx.i0, Op.fuseOperators(fx.i1, operator));
-    } else if (isFailCause(fx)) {
-      return fx;
-    } else {
-      return new Transformer(fx, operator);
-    }
-  }
-}
-/**
- * @internal
- */
-function isTransformer(fx) {
-  return fx.constructor === Transformer;
-}
-class ProducerSyncTransformer extends _protos.FxBase {
-  i0;
-  i1;
-  constructor(i0, i1) {
-    super();
-    this.i0 = i0;
-    this.i1 = i1;
-  }
-  run(sink) {
-    return SyncProducer.runSink(this.i0, Op.compileOperatorSink(this.i1, sink));
-  }
-}
-/**
- * @internal
- */
-function isProducerSyncTransformer(fx) {
-  return fx.constructor === ProducerSyncTransformer;
-}
-const map = (fx, f) => Transformer.make(fx, SyncOp.Map(f));
-exports.map = map;
-const filter = (fx, f) => Transformer.make(fx, SyncOp.Filter(f));
-exports.filter = filter;
-const filterMap = (fx, f) => Transformer.make(fx, SyncOp.FilterMap(f));
-exports.filterMap = filterMap;
-const mapEffect = (fx, f) => Transformer.make(fx, EffectOp.MapEffect(f));
-exports.mapEffect = mapEffect;
-const filterMapEffect = (fx, f) => Transformer.make(fx, EffectOp.FilterMapEffect(f));
-exports.filterMapEffect = filterMapEffect;
-const filterEffect = (fx, f) => Transformer.make(fx, EffectOp.FilterEffect(f));
-exports.filterEffect = filterEffect;
-const tapEffect = (fx, f) => Transformer.make(fx, EffectOp.TapEffect(f));
-exports.tapEffect = tapEffect;
-const loop = (fx, seed, f) => Transformer.make(fx, SyncLoopOp.LoopOperator(seed, f));
-exports.loop = loop;
-const withPrevious = fx => loop(fx, Option.none(), (acc, a) => [[acc, a], Option.some(a)]);
-exports.withPrevious = withPrevious;
-const filterMapLoop = (fx, seed, f) => Transformer.make(fx, SyncLoopOp.FilterMapLoopOperator(seed, f));
-exports.filterMapLoop = filterMapLoop;
-const loopEffect = (fx, seed, f) => Transformer.make(fx, EffectLoopOp.LoopEffectOperator(seed, f));
-exports.loopEffect = loopEffect;
-const filterMapLoopEffect = (fx, seed, f) => Transformer.make(fx, EffectLoopOp.FilterMapLoopEffectOperator(seed, f));
-exports.filterMapLoopEffect = filterMapLoopEffect;
-const observe = (fx, f) => Observe.make(fx, f);
-exports.observe = observe;
-const constUnit = () => Effect.void;
-const drain = fx => Observe.make(fx, constUnit);
-exports.drain = drain;
-class Observe extends _protos.EffectBase {
-  i0;
-  i1;
-  constructor(i0, i1) {
-    super();
-    this.i0 = i0;
-    this.i1 = i1;
-  }
-  toEffect() {
-    return Effect.asyncEffect(resume => {
-      const {
-        i0: fx,
-        i1: f
-      } = this;
-      const onFailure = cause => Effect.sync(() => resume(Effect.failCause(cause)));
-      return Effect.zipRight(fx.run(Sink.make(onFailure, a => Effect.catchAllCause(f(a), onFailure))), Effect.sync(() => resume(Effect.void)));
-    });
-  }
-  static make(fx, f) {
-    if (isEmpty(fx)) {
-      return Effect.void;
-    } else if (isNever(fx)) {
-      return Effect.never;
-    } else if (isProducer(fx)) {
-      return SyncProducer.runEffect(fx.i0, f);
-    } else if (isProducerSyncTransformer(fx)) {
-      return Op.matchOperator(fx.i1, {
-        SyncOperator: op => SyncOp.matchSyncOperator(op, {
-          Map: op => SyncProducer.effectOnce(() => SyncProducer.runEffect(fx.i0, a => f(op.f(a)))),
-          Filter: op => SyncProducer.effectOnce(() => SyncProducer.runEffect(fx.i0, Unify.unify(a => op.f(a) ? f(a) : Effect.void))),
-          FilterMap: op => SyncProducer.effectOnce(() => SyncProducer.runEffect(fx.i0, Unify.unify(a => Option.match(op.f(a), {
-            onNone: () => Effect.void,
-            onSome: f
-          }))))
-        }),
-        EffectOperator: op => EffectOp.matchEffectOperator(op, {
-          MapEffect: op => SyncProducer.runEffect(fx.i0, a => Effect.flatMap(op.f(a), f)),
-          FilterMapEffect: op => SyncProducer.runEffect(fx.i0, a => Effect.flatMap(op.f(a), Unify.unify(Option.match({
-            onNone: () => Effect.void,
-            onSome: f
-          })))),
-          FilterEffect: op => SyncProducer.runEffect(fx.i0, Unify.unify(a => Effect.flatMap(op.f(a), Unify.unify(b => b ? f(a) : Effect.void)))),
-          TapEffect: op => SyncProducer.runEffect(fx.i0, a => Effect.flatMap(op.f(a), () => f(a)))
-        }),
-        SyncLoopOperator: op => SyncLoopOp.matchSyncLoopOperator(op, {
-          Loop: op => SyncProducer.effectOnce(() => SyncProducer.runReduceEffect(fx.i0, op.seed, (acc, a) => {
-            const [c, b] = op.f(acc, a);
-            return Effect.as(f(c), b);
-          })),
-          FilterMapLoop: op => SyncProducer.effectOnce(() => SyncProducer.runReduceEffect(fx.i0, op.seed, (acc, a) => {
-            const [c, b] = op.f(acc, a);
-            return Option.match(c, {
-              onNone: () => Effect.succeed(acc),
-              onSome: c => Effect.as(f(c), b)
-            });
-          }))
-        }),
-        EffectLoopOperator: op => EffectLoopOp.matchEffectLoopOperator(op, {
-          LoopEffect: op => SyncProducer.runReduceEffect(fx.i0, op.seed, (acc, a) => Effect.flatMap(op.f(acc, a), ([c, b]) => Effect.as(f(c), b))),
-          FilterMapLoopEffect: op => SyncProducer.runReduceEffect(fx.i0, op.seed, (acc, a) => Effect.flatMap(op.f(acc, a), ([c, b]) => Option.match(c, {
-            onNone: () => Effect.succeed(b),
-            onSome: c => Effect.as(f(c), b)
-          })))
-        })
-      });
-    } else if (isProducerEffect(fx)) {
-      return EffectProducer.runEffect(fx.i0, f);
-    } else if (isProducerEffectTransformer(fx)) {
-      return Op.matchOperator(fx.i1, {
-        SyncOperator: op => SyncOp.matchSyncOperator(op, {
-          Map: op => SyncProducer.effectOnce(() => EffectProducer.runEffect(fx.i0, a => f(op.f(a)))),
-          Filter: op => SyncProducer.effectOnce(() => EffectProducer.runEffect(fx.i0, Unify.unify(a => op.f(a) ? f(a) : Effect.void))),
-          FilterMap: op => SyncProducer.effectOnce(() => EffectProducer.runEffect(fx.i0, Unify.unify(a => Option.match(op.f(a), {
-            onNone: () => Effect.void,
-            onSome: f
-          }))))
-        }),
-        EffectOperator: op => EffectOp.matchEffectOperator(op, {
-          MapEffect: op => EffectProducer.runEffect(fx.i0, a => Effect.flatMap(op.f(a), f)),
-          FilterMapEffect: op => EffectProducer.runEffect(fx.i0, a => Effect.flatMap(op.f(a), Unify.unify(Option.match({
-            onNone: () => Effect.void,
-            onSome: f
-          })))),
-          FilterEffect: op => EffectProducer.runEffect(fx.i0, Unify.unify(a => Effect.flatMap(op.f(a), Unify.unify(b => b ? f(a) : Effect.void)))),
-          TapEffect: op => EffectProducer.runEffect(fx.i0, a => Effect.flatMap(op.f(a), () => f(a)))
-        }),
-        SyncLoopOperator: op => SyncLoopOp.matchSyncLoopOperator(op, {
-          Loop: op => SyncProducer.effectOnce(() => EffectProducer.runReduceEffect(fx.i0, op.seed, (acc, a) => {
-            const [c, b] = op.f(acc, a);
-            return Effect.as(f(c), b);
-          })),
-          FilterMapLoop: op => SyncProducer.effectOnce(() => EffectProducer.runReduceEffect(fx.i0, op.seed, (acc, a) => {
-            const [c, b] = op.f(acc, a);
-            return Option.match(c, {
-              onNone: () => Effect.succeed(acc),
-              onSome: c => Effect.as(f(c), b)
-            });
-          }))
-        }),
-        EffectLoopOperator: op => EffectLoopOp.matchEffectLoopOperator(op, {
-          LoopEffect: op => EffectProducer.runReduceEffect(fx.i0, op.seed, (acc, a) => Effect.flatMap(op.f(acc, a), ([c, b]) => Effect.as(f(c), b))),
-          FilterMapLoopEffect: op => EffectProducer.runReduceEffect(fx.i0, op.seed, (acc, a) => Effect.flatMap(op.f(acc, a), ([c, b]) => Option.match(c, {
-            onNone: () => Effect.succeed(b),
-            onSome: c => Effect.as(f(c), b)
-          })))
-        })
-      });
-    } else if (isFailCause(fx)) {
-      return Effect.failCause(fx.i0);
-    } else {
-      return new Observe(fx, f);
-    }
-  }
-}
-const reduce = (fx, seed, f) => Reduce.make(fx, seed, f);
-exports.reduce = reduce;
-class Reduce extends _protos.EffectBase {
-  i0;
-  i1;
-  i2;
-  constructor(i0, i1, i2) {
-    super();
-    this.i0 = i0;
-    this.i1 = i1;
-    this.i2 = i2;
-  }
-  toEffect() {
-    return Effect.suspend(() => {
-      let acc = this.i1;
-      return Effect.map(observe(this.i0, a => Effect.sync(() => acc = this.i2(acc, a))), () => acc);
-    });
-  }
-  static make(fx, seed, f) {
-    // TODO: optimize Effect trasformers
-    if (isEmpty(fx)) return Effect.succeed(seed);else if (isProducer(fx)) {
-      return SyncProducer.runReduce(fx.i0, seed, f);
-    } else if (isProducerSyncTransformer(fx)) {
-      return Op.matchOperator(fx.i1, {
-        SyncOperator: op => SyncProducer.syncOnce(() => SyncOp.runSyncReduce(fx.i0, op, seed, f)),
-        EffectOperator: op => EffectOp.runSyncReduce(fx.i0, op, seed, f),
-        SyncLoopOperator: op => SyncLoopOp.matchSyncLoopOperator(op, {
-          Loop: op => Effect.map(SyncProducer.runReduce(fx.i0, [op.seed, seed], ([opAcc, acc], a) => {
-            const [c, b] = op.f(opAcc, a);
-            const newAcc = f(acc, c);
-            return [b, newAcc];
-          }), x => x[1]),
-          FilterMapLoop: op => Effect.map(SyncProducer.runReduce(fx.i0, [op.seed, seed], ([opAcc, acc], a) => {
-            const [c, b] = op.f(opAcc, a);
-            const newAcc = Option.match(c, {
-              onNone: () => acc,
-              onSome: c => f(acc, c)
-            });
-            return [b, newAcc];
-          }), x => x[1])
-        }),
-        EffectLoopOperator: op => EffectLoopOp.matchEffectLoopOperator(op, {
-          LoopEffect: op => Effect.map(SyncProducer.runReduceEffect(fx.i0, [op.seed, seed], ([opAcc, acc], a) => {
-            return Effect.flatMap(op.f(opAcc, a), ([c, b]) => {
-              const newAcc = f(acc, c);
-              return Effect.succeed([b, newAcc]);
-            });
-          }), x => x[1]),
-          FilterMapLoopEffect: op => Effect.map(SyncProducer.runReduceEffect(fx.i0, [op.seed, seed], ([opAcc, acc], a) => {
-            return Effect.map(op.f(opAcc, a), ([c, b]) => {
-              const newAcc = Option.match(c, {
-                onNone: () => acc,
-                onSome: () => f(acc, b)
-              });
-              return [b, newAcc];
-            });
-          }), x => x[1])
-        })
-      });
-    } else if (isProducerEffect(fx)) {
-      return EffectProducer.runReduceEffect(fx.i0, seed, (b, a) => Effect.succeed(f(b, a)));
-    } else if (isFailCause(fx)) {
-      return Effect.failCause(fx.i0);
-    } else {
-      return new Reduce(fx, seed, f);
-    }
-  }
-}
-const toReadonlyArray = fx => Effect.suspend(() => {
-  const init = [];
-  return Reduce.make(fx, init, (acc, a) => {
-    acc.push(a);
-    return acc;
-  });
-});
-exports.toReadonlyArray = toReadonlyArray;
-const slice = (fx, drop, take) => Slice.make(fx, (0, _bounds.boundsFrom)(drop, take));
-exports.slice = slice;
-const take = (fx, n) => slice(fx, 0, n);
-exports.take = take;
-const drop = (fx, n) => slice(fx, n, Infinity);
-exports.drop = drop;
-class Slice extends _protos.FxBase {
-  i0;
-  i1;
-  constructor(i0, i1) {
-    super();
-    this.i0 = i0;
-    this.i1 = i1;
-  }
-  run(sink) {
-    return Sink.slice(sink, this.i1, s => this.i0.run(s));
-  }
-  static make(fx, bounds) {
-    if ((0, _bounds.isNilBounds)(bounds)) return empty;
-    if ((0, _bounds.isInfiniteBounds)(bounds)) return fx;
-    if (isSlice(fx)) {
-      return Slice.make(fx.i0, (0, _bounds.mergeBounds)(fx.i1, bounds));
-    } else if (isTransformer(fx) && fx.i1._tag === "Map") {
-      // Commute map and slice
-      return map(Slice.make(fx.i0, bounds), fx.i1.f);
-    } else {
-      return new Slice(fx, bounds);
-    }
-  }
-}
-/**
- * @internal
- */
-function isSlice(fx) {
-  return fx.constructor === Slice;
-}
-function skipRepeatsWith(fx, eq) {
-  return filterMapLoop(fx, Option.none(), (previous, a) => {
-    if (Option.isSome(previous) && eq(a, previous.value)) {
-      return [Option.none(), Option.some(a)];
-    } else {
-      return [Option.some(a), Option.some(a)];
-    }
-  });
-}
-const toDeepEquals = u => {
-  switch (typeof u) {
-    case "object":
-      {
-        if (Predicate.isNullable(u)) {
-          return u;
-        } else if (Equal.symbol in u) {
-          return u;
-        } else if (Array.isArray(u)) {
-          return _effect.Data.tuple(u.map(toDeepEquals));
-        } else if (u instanceof Set) {
-          return _effect.Data.tuple(Array.from(u, toDeepEquals));
-        } else if (u instanceof Map) {
-          return _effect.Data.tuple(Array.from(u, ([k, v]) => _effect.Data.tuple([toDeepEquals(k), toDeepEquals(v)])));
-        } else if (u instanceof URLSearchParams) {
-          return _effect.Data.tuple(Array.from(u.keys()).map(key => _effect.Data.tuple([key, toDeepEquals(u.getAll(key))])));
-        } else if (Symbol.iterator in u) {
-          return _effect.Data.tuple(Array.from(u, toDeepEquals));
-        } else {
-          return _effect.Data.struct(_effect.Record.map(u, toDeepEquals));
-        }
-      }
-    default:
-      return u;
-  }
-};
-/**
- * @internal
- */
-const deepEquals = (a, b) => {
-  // Attempt reference equality first for performance
-  if (Object.is(a, b)) return true;
-  return Equal.equals(toDeepEquals(a), toDeepEquals(b));
-};
-exports.deepEquals = deepEquals;
-function skipRepeats(fx) {
-  return skipRepeatsWith(fx, deepEquals);
-}
-class ProducerEffectTransformer extends _protos.FxBase {
-  i0;
-  i1;
-  constructor(i0, i1) {
-    super();
-    this.i0 = i0;
-    this.i1 = i1;
-  }
-  run(sink) {
-    return EffectProducer.runSink(this.i0, Op.compileOperatorSink(this.i1, sink));
-  }
-}
-/**
- * @internal
- */
-function isProducerEffectTransformer(fx) {
-  return fx.constructor === ProducerEffectTransformer;
-}
-class Empty extends _protos.FxBase {
-  run() {
-    return Effect.void;
-  }
-}
-/**
- * @internal
- */
-function isEmpty(fx) {
-  return fx.constructor === Empty;
-}
-const empty = exports.empty = /*#__PURE__*/new Empty();
-class Never extends _protos.FxBase {
-  run() {
-    return Effect.never;
-  }
-}
-/**
- * @internal
- */
-function isNever(fx) {
-  return fx.constructor === Never;
-}
-const never = exports.never = /*#__PURE__*/new Never();
-function padWith(fx, start, end) {
-  return new PadWith(fx, start, end);
-}
-function prependAll(fx, start) {
-  return new PadWith(fx, start, []);
-}
-function appendAll(fx, end) {
-  return new PadWith(fx, [], end);
-}
-function prepend(fx, start) {
-  return new PadWith(fx, [start], []);
-}
-function append(fx, end) {
-  return new PadWith(fx, [], [end]);
-}
-function scan(fx, seed, f) {
-  return prepend(loop(fx, seed, (b, a) => {
-    const b2 = f(b, a);
-    return [b2, b2];
-  }), seed);
-}
-class PadWith extends _protos.FxBase {
-  i0;
-  i1;
-  i2;
-  constructor(i0, i1, i2) {
-    super();
-    this.i0 = i0;
-    this.i1 = i1;
-    this.i2 = i2;
-  }
-  run(sink) {
-    const onSuccess = a => sink.onSuccess(a);
-    return Effect.forEach(this.i1, onSuccess, DISCARD).pipe(Effect.zipRight(this.i0.run(sink)), Effect.zipRight(Effect.forEach(this.i2, onSuccess, DISCARD)));
-  }
-  static make(fx, start, end) {
-    if (isEmpty(fx) || isNever(fx)) return fx;else if (isPadWith(fx)) {
-      return new PadWith(fx.i0, concat(start, fx.i1), concat(fx.i2, end));
-    } else {
-      return new PadWith(fx, start, end);
-    }
-  }
-}
-function concat(a, b) {
-  return {
-    *[Symbol.iterator]() {
-      yield* a;
-      yield* b;
-    }
-  };
-}
-/**
- * @internal
- */
-function isPadWith(fx) {
-  return fx.constructor === PadWith;
-}
-function flatMapWithStrategy(fx, f, strategy, executionStrategy = ExecutionStrategy.sequential) {
-  return FlatMapWithStrategy.make(fx, f, strategy, executionStrategy);
-}
-function switchMap(fx, f, executionStrategy) {
-  return flatMapWithStrategy(fx, f, _strategies.Switch, executionStrategy);
-}
-function switchMapEffect(fx, f, executionStrategy) {
-  return switchMap(fx, a => fromEffect(f(a)), executionStrategy);
-}
-function exhaustMap(fx, f, executionStrategy) {
-  return flatMapWithStrategy(fx, f, _strategies.Exhaust, executionStrategy);
-}
-function exhaustMapEffect(fx, f, executionStrategy) {
-  return exhaustMap(fx, a => fromEffect(f(a)), executionStrategy);
-}
-function exhaustMapLatest(fx, f, executionStrategy) {
-  return flatMapWithStrategy(fx, f, _strategies.ExhaustLatest, executionStrategy);
-}
-function exhaustMapLatestEffect(fx, f, executionStrategy) {
-  return exhaustMapLatest(fx, a => fromEffect(f(a)), executionStrategy);
-}
-function exhaustFilterMapLatestEffect(fx, f, executionStrategy) {
-  return exhaustMapLatest(fx, a => fromFxEffect(Effect.map(f(a), Option.match({
-    onNone: () => empty,
-    onSome: succeed
-  }))), executionStrategy);
-}
-function flatMapConcurrently(fx, f, capacity, executionStrategy) {
-  return flatMapWithStrategy(fx, f, (0, _strategies.Bounded)(capacity), executionStrategy);
-}
-function concatMap(fx, f, executionStrategy) {
-  return flatMapConcurrently(fx, f, 1, executionStrategy);
-}
-function flatMapConcurrentlyEffect(fx, f, capacity, executionStrategy) {
-  return flatMapConcurrently(fx, a => fromEffect(f(a)), capacity, executionStrategy);
-}
-function flatMap(fx, f, executionStrategy) {
-  return flatMapWithStrategy(fx, f, _strategies.Unbounded, executionStrategy);
-}
-function flatMapEffect(fx, f, executionStrategy) {
-  return flatMap(fx, a => fromEffect(f(a)), executionStrategy);
-}
-class FlatMapWithStrategy extends _protos.FxBase {
-  i0;
-  i1;
-  i2;
-  i3;
-  withFork;
-  constructor(i0, i1, i2, i3) {
-    super();
-    this.i0 = i0;
-    this.i1 = i1;
-    this.i2 = i2;
-    this.i3 = i3;
-    this.withFork = (0, _helpers.withFlattenStrategy)(i2);
-  }
-  run(sink) {
-    return this.withFork(fork => Sink.withEarlyExit(sink, sink => this.i0.run(Sink.make(cause => Cause.isInterruptedOnly(cause) ? sink.earlyExit : sink.onFailure(cause), a => fork(this.i1(a).run(sink))))), this.i3);
-  }
-  static make(fx, f, strategy, executionStrategy) {
-    if (isEmpty(fx) || isNever(fx)) return fx;else if (isProducer(fx)) {
-      if (fx.i0._tag === "Success") return f(fx.i0.source);
-      if (fx.i0._tag === "FromSync") {
-        const producer = fx.i0;
-        return suspend(() => f(producer.source()));
-      }
-      const arr = Array.isArray(fx.i0.source) ? fx.i0.source : Array.from(fx.i0.source);
-      if (arr.length === 0) return empty;
-      if (arr.length === 1) return f(arr[0]);
-      switch (strategy._tag) {
-        case "Switch":
-          return f(arr[arr.length - 1]);
-        case "Exhaust":
-          return f(arr[0]);
-        case "ExhaustLatest":
-          return arr.length > 1 ? continueWith(f(arr[0]), () => f(arr[arr.length - 1])) : f(arr[0]);
-        default:
-          return new FlatMapWithStrategy(fx, f, strategy, executionStrategy);
-      }
-    } else if (isProducerEffect(fx) && fx.i0._tag === "FromEffect") {
-      return fromFxEffect(Effect.map(fx.i0.source, f));
-    } else if (isTransformer(fx) && fx.i1._tag === "Map") {
-      const {
-        f: op
-      } = fx.i1;
-      return new FlatMapWithStrategy(fx.i0, a => f(op(a)), strategy, executionStrategy);
-    } else {
-      return new FlatMapWithStrategy(fx, f, strategy, executionStrategy);
-    }
-  }
-}
-function fromFxEffect(effect) {
-  return new FromFxEffect(effect);
-}
-class FromFxEffect extends _protos.FxBase {
-  i0;
-  constructor(i0) {
-    super();
-    this.i0 = i0;
-  }
-  run(sink) {
-    return Effect.matchCauseEffect(this.i0, {
-      onFailure: cause => sink.onFailure(cause),
-      onSuccess: fx => fx.run(sink)
-    });
-  }
-}
-function gen(f) {
-  return fromFxEffect(Effect.gen(f));
-}
-function genScoped(f) {
-  return scoped(fromFxEffect(Effect.gen(f)));
-}
-function continueWith(fx, f) {
-  return ContinueWith.make(fx, f);
-}
-class ContinueWith extends _protos.FxBase {
-  i0;
-  i1;
-  constructor(i0, i1) {
-    super();
-    this.i0 = i0;
-    this.i1 = i1;
-  }
-  run(sink) {
-    return Effect.flatMap(this.i0.run(sink), () => this.i1().run(sink));
-  }
-  static make(fx, f) {
-    if (isEmpty(fx)) return f();else if (isNever(fx)) return fx;else if (isProducer(fx)) {
-      return SyncProducer.matchSyncProducer(fx.i0, {
-        Success: source => prependAll(f(), [source]),
-        FromSync: source => suspend(() => prependAll(f(), [source()])),
-        FromArray: source => prependAll(f(), source),
-        FromIterable: source => prependAll(f(), source)
-      });
-    } else {
-      return new ContinueWith(fx, f);
-    }
-  }
-}
-function orElseCause(fx, f) {
-  return OrElseCause.make(fx, f);
-}
-class OrElseCause extends _protos.FxBase {
-  i0;
-  i1;
-  constructor(i0, i1) {
-    super();
-    this.i0 = i0;
-    this.i1 = i1;
-  }
-  run(sink) {
-    return Effect.catchAllCause(observe(this.i0, sink.onSuccess), cause => this.i1(cause).run(sink));
-  }
-  static make(fx, f) {
-    if (isEmpty(fx)) return fx;else if (isNever(fx)) return fx;else {
-      return new OrElseCause(fx, f);
-    }
-  }
-}
-function orElse(fx, f) {
-  return OrElse.make(fx, f);
-}
-class OrElse extends _protos.FxBase {
-  i0;
-  i1;
-  constructor(i0, i1) {
-    super();
-    this.i0 = i0;
-    this.i1 = i1;
-  }
-  run(sink) {
-    return Effect.catchAll(Effect.asyncEffect(resume => Effect.asVoid(Effect.zipRight(this.i0.run(Sink.make(cause => Either.match(Cause.failureOrCause(cause), {
-      onLeft: e => Effect.succeed(resume(Effect.fail(e))),
-      onRight: cause => sink.onFailure(cause)
-    }), sink.onSuccess)), Effect.sync(() => resume(Effect.void))))), error => this.i1(error).run(sink));
-  }
-  static make(fx, f) {
-    if (isEmpty(fx)) return fx;else if (isNever(fx)) return fx;else {
-      return new OrElse(fx, f);
-    }
-  }
-}
-function suspend(f) {
-  return new Suspend(f);
-}
-class Suspend extends _protos.FxBase {
-  i0;
-  constructor(i0) {
-    super();
-    this.i0 = i0;
-  }
-  run(sink) {
-    return this.i0().run(sink);
-  }
-}
-function isSuspend(fx) {
-  return fx.constructor === Suspend;
-}
-class SuspendedTransformer extends _protos.FxBase {
-  i0;
-  i1;
-  constructor(i0, i1) {
-    super();
-    this.i0 = i0;
-    this.i1 = i1;
-  }
-  run(sink) {
-    return this.i0().run(Op.compileOperatorSink(this.i1, sink));
-  }
-}
-function isSuspendedTransformer(fx) {
-  return fx.constructor === SuspendedTransformer;
-}
-function mergeWithStrategy(fx, stategy) {
-  return MergeWithStrategy.make(fx, stategy);
-}
-function merge(fx, other) {
-  return mergeWithStrategy([fx, other], (0, _strategies.Unordered)(2));
-}
-function mergeAll(fx) {
-  return mergeWithStrategy(fx, (0, _strategies.Unordered)(Infinity));
-}
-function mergeOrdered(fx) {
-  return mergeOrderedConcurrently(fx, Infinity);
-}
-function mergeOrderedConcurrently(fx, concurrency) {
-  return mergeWithStrategy(fx, (0, _strategies.Ordered)(concurrency));
-}
-function mergeSwitch(fx) {
-  return mergeWithStrategy(fx, _strategies.Switch);
-}
-class MergeWithStrategy extends _protos.FxBase {
-  i0;
-  i1;
-  constructor(i0, i1) {
-    super();
-    this.i0 = i0;
-    this.i1 = i1;
-  }
-  run(sink) {
-    switch (this.i1._tag) {
-      case "Unordered":
-        return runUnordered(this.i0, sink, this.i1.concurrency === Infinity ? "unbounded" : this.i1.concurrency);
-      case "Ordered":
-        return runOrdered(this.i0, sink, this.i1.concurrency === Infinity ? "unbounded" : this.i1.concurrency);
-      case "Switch":
-        return runSwitch(this.i0, sink);
-    }
-  }
-  static make(fx, strategy) {
-    if (fx.length === 0) return empty;else if (fx.length === 1) return fx[0];else {
-      return new MergeWithStrategy(fx.filter(Predicate.not(isEmpty)), strategy);
-    }
-  }
-}
-function runUnordered(fx, sink, concurrency) {
-  return Effect.forEach(fx, fx => fx.run(sink), {
-    concurrency,
-    discard: true
-  });
-}
-function runOrdered(fx, sink, concurrency) {
-  return Effect.fiberIdWith(id => {
-    const buffers = (0, _helpers.withBuffers)(fx.length, sink, id);
-    return Effect.forEach(fx, (fx, i) => Effect.flatMap(fx.run(Sink.make(cause => Cause.isInterruptedOnly(cause) ? buffers.onEnd(i) : sink.onFailure(cause), a => buffers.onSuccess(i, a))), () => buffers.onEnd(i)), {
-      concurrency,
-      discard: true
-    });
-  });
-}
-function runSwitch(fx, sink) {
-  return Effect.forEach(fx, fx => fx.run(sink), {
-    concurrency: 1,
-    discard: true
-  });
-}
-function takeWhile(fx, f) {
-  return TakeWhile.make(fx, f);
-}
-function takeUntil(fx, f) {
-  return TakeWhile.make(fx, Predicate.not(f));
-}
-class TakeWhile extends _protos.FxBase {
-  i0;
-  i1;
-  constructor(i0, i1) {
-    super();
-    this.i0 = i0;
-    this.i1 = i1;
-  }
-  run(sink) {
-    return Sink.takeWhile(sink, this.i1, s => this.i0.run(s));
-  }
-  static make(fx, predicate) {
-    if (isEmpty(fx) || isNever(fx)) return fx;else {
-      return new TakeWhile(fx, predicate);
-    }
-  }
-}
-function dropWhile(fx, f) {
-  return DropUntil.make(fx, f);
-}
-function dropUntil(fx, f) {
-  return DropUntil.make(fx, Predicate.not(f));
-}
-class DropUntil extends _protos.FxBase {
-  i0;
-  i1;
-  constructor(i0, i1) {
-    super();
-    this.i0 = i0;
-    this.i1 = i1;
-  }
-  run(sink) {
-    return this.i0.run(Sink.dropWhile(sink, this.i1));
-  }
-  static make(fx, predicate) {
-    if (isEmpty(fx) || isNever(fx)) return fx;else {
-      return new DropUntil(fx, predicate);
-    }
-  }
-}
-function dropAfter(fx, f) {
-  return DropAfter.make(fx, f);
-}
-class DropAfter extends _protos.FxBase {
-  i0;
-  i1;
-  constructor(i0, i1) {
-    super();
-    this.i0 = i0;
-    this.i1 = i1;
-  }
-  run(sink) {
-    return Sink.dropAfter(sink, this.i1, s => this.i0.run(s));
-  }
-  static make(fx, predicate) {
-    if (isEmpty(fx) || isNever(fx)) return fx;else {
-      return new DropAfter(fx, predicate);
-    }
-  }
-}
-function takeWhileEffect(fx, f) {
-  return TakeWhileEffect.make(fx, f);
-}
-function takeUntilEffect(fx, f) {
-  return TakeWhileEffect.make(fx, a => Effect.map(f(a), Boolean.not));
-}
-class TakeWhileEffect extends _protos.FxBase {
-  i0;
-  i1;
-  constructor(i0, i1) {
-    super();
-    this.i0 = i0;
-    this.i1 = i1;
-  }
-  run(sink) {
-    return Sink.takeWhileEffect(sink, this.i1, s => this.i0.run(s));
-  }
-  static make(fx, f) {
-    if (isEmpty(fx) || isNever(fx)) return fx;else {
-      return new TakeWhileEffect(fx, f);
-    }
-  }
-}
-function dropWhileEffect(fx, f) {
-  return DropWhileEffect.make(fx, f);
-}
-function dropUntilEffect(fx, f) {
-  return DropWhileEffect.make(fx, a => Effect.map(f(a), Boolean.not));
-}
-class DropWhileEffect extends _protos.FxBase {
-  i0;
-  i1;
-  constructor(i0, i1) {
-    super();
-    this.i0 = i0;
-    this.i1 = i1;
-  }
-  run(sink) {
-    return this.i0.run(Sink.dropWhileEffect(sink, this.i1));
-  }
-  static make(fx, f) {
-    if (isEmpty(fx) || isNever(fx)) return fx;else {
-      return new DropWhileEffect(fx, f);
-    }
-  }
-}
-function dropAfterEffect(fx, f) {
-  return DropAfterEffect.make(fx, f);
-}
-class DropAfterEffect extends _protos.FxBase {
-  i0;
-  i1;
-  constructor(i0, i1) {
-    super();
-    this.i0 = i0;
-    this.i1 = i1;
-  }
-  run(sink) {
-    return this.i0.run(Sink.dropAfterEffect(sink, this.i1));
-  }
-  static make(fx, f) {
-    if (isEmpty(fx) || isNever(fx)) return fx;else {
-      return new DropAfterEffect(fx, f);
-    }
-  }
-}
-function during(fx, window) {
-  return During.make(fx, window);
-}
-function since(fx, window) {
-  return During.make(fx, map(window, () => never));
-}
-function until(fx, window) {
-  return During.make(fx, succeed(window));
-}
-class During extends _protos.FxBase {
-  i0;
-  i1;
-  constructor(i0, i1) {
-    super();
-    this.i0 = i0;
-    this.i1 = i1;
-  }
-  run(sink) {
-    return (0, _helpers.withScopedFork)(fork => Sink.withEarlyExit(sink, s => {
-      let taking = false;
-      const onFailure = cause => s.onFailure(cause);
-      return Effect.flatMap(fork(take(this.i1, 1).run(Sink.make(onFailure, nested => {
-        taking = true;
-        return take(nested, 1).run(Sink.make(onFailure, () => s.earlyExit));
-      }))), () => Effect.zipRight(
-      // Allow fibers to start
-      (0, _helpers.adjustTime)(1), this.i0.run(Sink.make(onFailure, a => taking ? s.onSuccess(a) : Effect.void))));
-    }), ExecutionStrategy.sequential);
-  }
-  static make(fx, window) {
-    if (isEmpty(fx) || isNever(fx)) return fx;else {
-      return new During(fx, window);
-    }
-  }
-}
-function middleware(fx, effect, sink) {
-  return new Middleware(fx, effect, sink);
-}
-function onExit(fx, f) {
-  return middleware(fx, Effect.onExit(f));
-}
-function onInterrupt(fx, f) {
-  return middleware(fx, Effect.onInterrupt(f));
-}
-function onError(fx, f) {
-  return middleware(fx, Effect.onError(f));
-}
-const scoped = fx => middleware(fx, Effect.scoped);
-exports.scoped = scoped;
-function annotateLogs(fx, key, value) {
-  return middleware(fx, effect => Effect.annotateLogs(effect, key, value));
-}
-function annotateSpans(fx, key, value) {
-  return middleware(fx, effect => Effect.annotateSpans(effect, key, value));
-}
-const interruptible = fx => middleware(fx, Effect.interruptible);
-exports.interruptible = interruptible;
-const uninterruptible = fx => middleware(fx, Effect.uninterruptible);
-exports.uninterruptible = uninterruptible;
-function locally(use, self, value) {
-  return middleware(use, effect => Effect.locally(effect, self, value));
-}
-function locallyWith(use, self, f) {
-  return middleware(use, effect => Effect.locallyWith(effect, self, f));
-}
-function withTracerTiming(fx, enabled) {
-  return middleware(fx, effect => Effect.withTracerTiming(effect, enabled));
-}
-function withConcurrency(fx, concurrency) {
-  return middleware(fx, effect => Effect.withConcurrency(effect, concurrency));
-}
-function withConfigProvider(fx, configProvider) {
-  return middleware(fx, effect => Effect.withConfigProvider(effect, configProvider));
-}
-function withLogSpan(fx, span) {
-  return middleware(fx, effect => Effect.withLogSpan(effect, span));
-}
-function withMaxOpsBeforeYield(fx, maxOps) {
-  return middleware(fx, effect => Effect.withMaxOpsBeforeYield(effect, maxOps));
-}
-function withParentSpan(fx, parentSpan) {
-  return middleware(fx, effect => Effect.withParentSpan(effect, parentSpan));
-}
-function withRequestBatching(fx, requestBatching) {
-  return middleware(fx, effect => Effect.withRequestBatching(effect, requestBatching));
-}
-function withRequestCache(fx, cache) {
-  return middleware(fx, effect => Effect.withRequestCache(effect, cache));
-}
-function withRequestCaching(fx, requestCaching) {
-  return middleware(fx, effect => Effect.withRequestCaching(effect, requestCaching));
-}
-function withScheduler(fx, scheduler) {
-  return middleware(fx, effect => Effect.withScheduler(effect, scheduler));
-}
-function withTracer(fx, tracer) {
-  return middleware(fx, effect => Effect.withTracer(effect, tracer));
-}
-class Middleware extends _protos.FxBase {
-  i0;
-  i1;
-  i2;
-  constructor(i0, i1, i2) {
-    super();
-    this.i0 = i0;
-    this.i1 = i1;
-    this.i2 = i2;
-  }
-  run(sink) {
-    return Effect.contextWithEffect(ctx => {
-      const s = Sink.provide(sink, ctx);
-      return this.i1(this.i0.run(this.i2 ? this.i2(s) : s));
-    });
-  }
-}
-function acquireUseRelease(acquire, use, release) {
-  return new AcquireUseRelease(acquire, use, release);
-}
-class AcquireUseRelease extends _protos.FxBase {
-  acquire;
-  use;
-  release;
-  constructor(acquire, use, release) {
-    super();
-    this.acquire = acquire;
-    this.use = use;
-    this.release = release;
-  }
-  run(sink) {
-    return Effect.catchAllCause(Effect.acquireUseRelease(this.acquire, a => this.use(a).run(sink), (a, exit) => Effect.catchAllCause(this.release(a, exit), cause => sink.onFailure(cause))), cause => sink.onFailure(cause));
-  }
-}
-function withSpan(self, name, options = {}) {
-  return acquireUseRelease(Effect.flatMap(Effect.optionFromOptional(Effect.currentSpan), parent => Effect.makeSpan(name, {
-    ...options,
-    parent: options?.parent || Option.getOrUndefined(parent)
-  })), span => middleware(self, effect => Effect.provideService(effect, Tracer.ParentSpan, span), s => Sink.setSpan(s, span)), (span, exit) => Effect.flatMap(Clock.currentTimeNanos, time => Effect.sync(() => span.end(time, exit))));
-}
-function provideContext(fx, context) {
-  return ProvideFx.make(fx, Provide.ProvideContext(context));
-}
-function provideLayer(fx, layer) {
-  return ProvideFx.make(fx, Provide.ProvideLayer(layer));
-}
-function provideRuntime(fx, runtime) {
-  return ProvideFx.make(fx, Provide.ProvideRuntime(runtime));
-}
-function provideService(fx, service, instance) {
-  return ProvideFx.make(fx, Provide.ProvideService(service, instance));
-}
-function provideServiceEffect(fx, service, instance) {
-  return ProvideFx.make(fx, Provide.ProvideServiceEffect(service, instance));
-}
-function provide(fx, provide) {
-  if (Layer.isLayer(provide)) {
-    return provideLayer(fx, provide);
-  } else if (Context.isContext(provide)) {
-    return provideContext(fx, provide);
-  } else return provideRuntime(fx, provide);
-}
-class ProvideFx extends _protos.FxBase {
-  i0;
-  i1;
-  constructor(i0, i1) {
-    super();
-    this.i0 = i0;
-    this.i1 = i1;
-  }
-  run(sink) {
-    return Effect.acquireUseRelease(Scope.make(), scope => Effect.matchEffect(Provide.buildWithScope(this.i1, scope), {
-      onFailure: error => sink.onFailure(Cause.fail(error)),
-      onSuccess: ctx => Effect.provide(this.i0.run(sink), ctx)
-    }), (scope, exit) => Scope.close(scope, exit));
-  }
-  static make(fx, provide) {
-    if (isEmpty(fx) || isNever(fx)) return fx;else if (isProvideFx(fx)) {
-      return new ProvideFx(fx.i0, Provide.merge(fx.i1, provide));
-    } else {
-      return new ProvideFx(fx, provide);
-    }
-  }
-}
-function isProvideFx(u) {
-  return u.constructor === ProvideFx;
-}
-function mapCause(fx, f) {
-  return new TransformerCause(fx, SyncOp.Map(f));
-}
-function mapError(fx, f) {
-  return mapCause(fx, Cause.map(f));
-}
-function filterCause(fx, f) {
-  return new TransformerCause(fx, SyncOp.Filter(f));
-}
-function filterError(fx, f) {
-  return filterCause(fx, cause => Option.match(Cause.failureOption(cause), {
-    onNone: _Function.constTrue,
-    onSome: f
-  }));
-}
-function filterMapCause(fx, f) {
-  return new TransformerCause(fx, SyncOp.FilterMap(f));
-}
-function filterMapError(fx, f) {
-  return filterMapCause(fx, cause => Either.match(Cause.failureOrCause(cause), {
-    onLeft: e => Option.map(f(e), Cause.fail),
-    onRight: Option.some
-  }));
-}
-function mapCauseEffect(fx, f) {
-  return new TransformerCause(fx, EffectOp.MapEffect(f));
-}
-function mapErrorEffect(fx, f) {
-  return mapCauseEffect(fx, cause => Either.match(Cause.failureOrCause(cause), {
-    onLeft: e => Effect.map(f(e), Cause.fail),
-    onRight: cause => Effect.succeed(cause)
-  }));
-}
-function filterCauseEffect(fx, f) {
-  return new TransformerCause(fx, EffectOp.FilterEffect(f));
-}
-function filterErrorEffect(fx, f) {
-  return filterCauseEffect(fx, cause => Either.match(Cause.failureOrCause(cause), {
-    onLeft: f,
-    onRight: () => Effect.succeed(true)
-  }));
-}
-function filterMapCauseEffect(fx, f) {
-  return new TransformerCause(fx, EffectOp.FilterMapEffect(f));
-}
-function filterMapErrorEffect(fx, f) {
-  return filterMapCauseEffect(fx, cause => Either.match(Cause.failureOrCause(cause), {
-    onLeft: e => Effect.map(f(e), Option.map(Cause.fail)),
-    onRight: cause => Effect.succeed(Option.some(cause))
-  }));
-}
-function loopCause(fx, seed, f) {
-  return new TransformerCause(fx, SyncLoopOp.LoopOperator(seed, f));
-}
-function loopError(fx, seed, f) {
-  return loopCause(fx, seed, (b, cause) => Either.match(Cause.failureOrCause(cause), {
-    onLeft: e => {
-      const [c, b2] = f(b, e);
-      return [Cause.fail(c), b2];
-    },
-    onRight: cause => [cause, b]
-  }));
-}
-function loopCauseEffect(fx, seed, f) {
-  return new TransformerCause(fx, EffectLoopOp.LoopEffectOperator(seed, f));
-}
-function loopErrorEffect(fx, seed, f) {
-  return loopCauseEffect(fx, seed, (b, cause) => Either.match(Cause.failureOrCause(cause), {
-    onLeft: e => Effect.map(f(b, e), ([c, b2]) => [Cause.fail(c), b2]),
-    onRight: cause => Effect.succeed([cause, b])
-  }));
-}
-function filterMapLoopCause(fx, seed, f) {
-  return new TransformerCause(fx, SyncLoopOp.FilterMapLoopOperator(seed, f));
-}
-function filterMapLoopError(fx, seed, f) {
-  return filterMapLoopCause(fx, seed, (b, cause) => Either.match(Cause.failureOrCause(cause), {
-    onLeft: e => {
-      const [c, b2] = f(b, e);
-      return [Option.map(Cause.fail)(c), b2];
-    },
-    onRight: cause => [Option.some(cause), b]
-  }));
-}
-function filterMapLoopCauseEffect(fx, seed, f) {
-  return new TransformerCause(fx, EffectLoopOp.FilterMapLoopEffectOperator(seed, f));
-}
-function filterMapLoopErrorEffect(fx, seed, f) {
-  return filterMapLoopCauseEffect(fx, seed, (b, cause) => Either.match(Cause.failureOrCause(cause), {
-    onLeft: e => Effect.map(f(b, e), ([c, b2]) => [Option.map(c, Cause.fail), b2]),
-    onRight: cause => Effect.succeed([Option.some(cause), b])
-  }));
-}
-class TransformerCause extends _protos.FxBase {
-  i0;
-  i1;
-  constructor(i0, i1) {
-    super();
-    this.i0 = i0;
-    this.i1 = i1;
-  }
-  run(sink) {
-    return this.i0.run(Op.compileOperatorSinkCause(this.i1, sink));
-  }
-}
-function flatMapCauseWithStrategy(fx, f, flattenStrategy, executionStrategy = ExecutionStrategy.sequential) {
-  return new FlatMapCauseWithStrategy(fx, f, flattenStrategy, executionStrategy);
-}
-function flatMapErrorWithStrategy(fx, f, flattenStrategy, executionStrategy = ExecutionStrategy.sequential) {
-  return flatMapCauseWithStrategy(fx, cause => Either.match(Cause.failureOrCause(cause), {
-    onLeft: f,
-    onRight: cause => failCause(cause)
-  }), flattenStrategy, executionStrategy);
-}
-function switchMapCause(fx, f, executionStrategy) {
-  return flatMapCauseWithStrategy(fx, f, _strategies.Switch, executionStrategy);
-}
-function switchMapError(fx, f, executionStrategy) {
-  return flatMapErrorWithStrategy(fx, f, _strategies.Switch, executionStrategy);
-}
-function flatMapCause(fx, f, executionStrategy) {
-  return flatMapCauseWithStrategy(fx, f, _strategies.Unbounded, executionStrategy);
-}
-function flatMapError(fx, f, executionStrategy) {
-  return flatMapErrorWithStrategy(fx, f, _strategies.Unbounded, executionStrategy);
-}
-function flatMapCauseConcurrently(fx, f, concurrency, executionStrategy) {
-  return flatMapCauseWithStrategy(fx, f, (0, _strategies.Bounded)(concurrency), executionStrategy);
-}
-function flatMapErrorConcurrently(fx, f, concurrency, executionStrategy) {
-  return flatMapErrorWithStrategy(fx, f, (0, _strategies.Bounded)(concurrency), executionStrategy);
-}
-function exhaustMapCause(fx, f, executionStrategy) {
-  return flatMapCauseWithStrategy(fx, f, _strategies.Exhaust, executionStrategy);
-}
-function exhaustMapError(fx, f, executionStrategy) {
-  return flatMapErrorWithStrategy(fx, f, _strategies.Exhaust, executionStrategy);
-}
-function exhaustMapLatestCause(fx, f, executionStrategy) {
-  return flatMapCauseWithStrategy(fx, f, _strategies.ExhaustLatest, executionStrategy);
-}
-function exhaustMapLatestError(fx, f, executionStrategy) {
-  return flatMapErrorWithStrategy(fx, f, _strategies.ExhaustLatest, executionStrategy);
-}
-class FlatMapCauseWithStrategy extends _protos.FxBase {
-  i0;
-  i1;
-  i2;
-  i3;
-  withFork;
-  constructor(i0, i1, i2, i3) {
-    super();
-    this.i0 = i0;
-    this.i1 = i1;
-    this.i2 = i2;
-    this.i3 = i3;
-    this.withFork = (0, _helpers.withFlattenStrategy)(this.i2);
-  }
-  run(sink) {
-    return this.withFork(fork => this.i0.run(Sink.make(cause => fork(this.i1(cause).run(sink)), a => sink.onSuccess(a))), this.i3);
-  }
-}
-class MatchWithStrategy extends _protos.FxBase {
-  i0;
-  i1;
-  i2;
-  i3;
-  i4;
-  withFork;
-  constructor(i0, i1, i2, i3, i4) {
-    super();
-    this.i0 = i0;
-    this.i1 = i1;
-    this.i2 = i2;
-    this.i3 = i3;
-    this.i4 = i4;
-    this.withFork = (0, _helpers.withFlattenStrategy)(this.i3);
-  }
-  run(sink) {
-    return this.withFork(fork => this.i0.run(Sink.make(cause => fork(this.i1(cause).run(sink)), a => fork(this.i2(a).run(sink)))), this.i4);
-  }
-}
-function matchCauseWithStrategy(fx, flattenStrategy, opts) {
-  return new MatchWithStrategy(fx, opts.onFailure, opts.onSuccess, flattenStrategy, opts.executionStrategy || ExecutionStrategy.sequential);
-}
-function matchErrorWithStrategy(fx, flattenStrategy, {
-  executionStrategy,
-  onFailure,
-  onSuccess
-}) {
-  return new MatchWithStrategy(fx, cause => Either.match(Cause.failureOrCause(cause), {
-    onLeft: onFailure,
-    onRight: cause => failCause(cause)
-  }), onSuccess, flattenStrategy, executionStrategy || ExecutionStrategy.sequential);
-}
-function matchCause(fx, opts) {
-  return matchCauseWithStrategy(fx, _strategies.Unbounded, opts);
-}
-function matchError(fx, opts) {
-  return matchErrorWithStrategy(fx, _strategies.Unbounded, opts);
-}
-function matchCauseConcurrently(fx, concurrency, opts) {
-  return matchCauseWithStrategy(fx, (0, _strategies.Bounded)(concurrency), opts);
-}
-function matchErrorConcurrently(fx, concurrency, opts) {
-  return matchErrorWithStrategy(fx, (0, _strategies.Bounded)(concurrency), opts);
-}
-function switchMatchCause(fx, opts) {
-  return matchCauseWithStrategy(fx, _strategies.Switch, opts);
-}
-function switchMatchError(fx, opts) {
-  return matchErrorWithStrategy(fx, _strategies.Switch, opts);
-}
-function exhaustMatchCause(fx, opts) {
-  return matchCauseWithStrategy(fx, _strategies.Exhaust, opts);
-}
-function exhaustMatchError(fx, opts) {
-  return matchErrorWithStrategy(fx, _strategies.Exhaust, opts);
-}
-function exhaustMatchLatestCause(fx, opts) {
-  return matchCauseWithStrategy(fx, _strategies.ExhaustLatest, opts);
-}
-function exhaustMatchLatestError(fx, opts) {
-  return matchErrorWithStrategy(fx, _strategies.ExhaustLatest, opts);
-}
-function tuple(fx) {
-  return new Tuple(fx);
-}
-class Tuple extends _protos.FxBase {
-  i0;
-  constructor(i0) {
-    super();
-    this.i0 = i0;
-  }
-  run(sink) {
-    return (0, _helpers.tupleSink)(sink, onSuccess => Effect.forEach(this.i0, (fx, i) => fx.run(Sink.make(sink.onFailure, a => onSuccess(i, a))), UNBOUNDED), this.i0.length);
-  }
-}
-function struct(fx) {
-  const entries = Object.entries(fx);
-  return map(tuple(entries.map(([key, fx]) => map(fx, a => [key, a]))), Object.fromEntries);
-}
-function all(fx) {
-  if (Array.isArray(fx)) return tuple(fx);else return struct(fx);
-}
-function exit(fx) {
-  return new ExitFx(fx);
-}
-class ExitFx extends _protos.FxBase {
-  i0;
-  constructor(i0) {
-    super();
-    this.i0 = i0;
-  }
-  run(sink) {
-    return this.i0.run(Sink.make(cause => sink.onSuccess(Exit.failCause(cause)), a => sink.onSuccess(Exit.succeed(a))));
-  }
-}
-function toEnqueue(fx, queue) {
-  return observe(fx, a => queue.offer(a));
-}
-function debounce(fx, delay) {
-  return switchMapEffect(fx, a => Effect.as(Effect.sleep(delay), a));
-}
-function emitAndSleep(value, delay) {
-  return make(sink => Effect.zipRight(sink.onSuccess(value), Effect.sleep(delay)));
-}
-function throttle(fx, delay) {
-  return exhaustMap(fx, a => emitAndSleep(a, delay));
-}
-function throttleLatest(fx, delay) {
-  return exhaustMapLatest(fx, a => emitAndSleep(a, delay));
-}
-function fromAsyncIterable(iterable) {
-  return new FromAsyncIterable(iterable);
-}
-class FromAsyncIterable extends _protos.FxBase {
-  i0;
-  constructor(i0) {
-    super();
-    this.i0 = i0;
-  }
-  run(sink) {
-    return Effect.asyncEffect(cb => {
-      const iterator = this.i0[Symbol.asyncIterator]();
-      const loop = result => result.done ? Effect.sync(() => cb(Effect.void)) : Effect.zipRight(sink.onSuccess(result.value), Effect.flatMap(Effect.promise(() => iterator.next()), loop));
-      return Effect.asVoid(Effect.flatMap(Effect.promise(() => iterator.next()), loop));
-    });
-  }
-}
-function findFirst(fx, predicate) {
-  return Effect.asyncEffect(cb => observe(fx, a => predicate(a) ? Effect.sync(() => cb(Effect.succeed(a))) : Effect.void));
-}
-function first(fx) {
-  return findFirst(fx, _Function.constTrue);
-}
-function either(fx) {
-  return new EitherFx(fx);
-}
-class EitherFx extends _protos.FxBase {
-  i0;
-  constructor(i0) {
-    super();
-    this.i0 = i0;
-  }
-  run(sink) {
-    return this.i0.run(Sink.make(cause => Either.match(Cause.failureOrCause(cause), {
-      onLeft: e => sink.onSuccess(Either.left(e)),
-      onRight: cause => sink.onFailure(cause)
-    }), a => sink.onSuccess(Either.right(a))));
-  }
-}
-function mergeFirst(fx, that) {
-  return merge(fx, filter(that, _Function.constFalse));
-}
-function mergeRace(fx, that) {
-  return new MergeRace(fx, that);
-}
-class MergeRace extends _protos.FxBase {
-  i0;
-  i1;
-  constructor(i0, i1) {
-    super();
-    this.i0 = i0;
-    this.i1 = i1;
-  }
-  run(sink) {
-    return Effect.gen(this, function* (_) {
-      const fiber1 = yield* Effect.fork(this.i0.run(Sink.make(sink.onFailure, a => Effect.flatMap(sink.onSuccess(a), () => Fiber.interrupt(fiber2)))));
-      const fiber2 = yield* Effect.fork(this.i1.run(sink));
-      return yield* Fiber.joinAll([fiber1, fiber2]);
-    });
-  }
-}
-function raceAll(fx) {
-  return new RaceAll(fx);
-}
-function race(fx, that) {
-  return raceAll([fx, that]);
-}
-class RaceAll extends _protos.FxBase {
-  i0;
-  constructor(i0) {
-    super();
-    this.i0 = i0;
-  }
-  run(sink) {
-    return Effect.gen(this, function* (_) {
-      const winner = yield* Deferred.make();
-      const fibers = [];
-      for (const fx of this.i0) {
-        const fiber = yield* Effect.fork(fx.run(Sink.make(sink.onFailure, a => Effect.flatMap(Deferred.succeed(winner, fiber), () => sink.onSuccess(a)))));
-        fibers.push(fiber);
-      }
-      const winningFiber = yield* Deferred.await(winner);
-      yield* Fiber.interruptAll(fibers.filter(x => x !== winningFiber));
-      return yield* Fiber.join(winningFiber);
-    });
-  }
-}
-function snapshot(fx, sampled, f) {
-  return new Snapshot(fx, sampled, f);
-}
-function sample(fx, sampled) {
-  return snapshot(fx, sampled, (_, b) => b);
-}
-class Snapshot extends _protos.FxBase {
-  i0;
-  i1;
-  i2;
-  constructor(i0, i1, i2) {
-    super();
-    this.i0 = i0;
-    this.i1 = i1;
-    this.i2 = i2;
-  }
-  run(sink) {
-    return Effect.flatMap(Ref.make(Option.none()), ref => Effect.all([this.i1.run(Sink.make(sink.onFailure, b => Ref.set(ref, Option.some(b)))), this.i0.run(Sink.make(sink.onFailure, a => Effect.flatMap(Ref.get(ref), Option.match({
-      onNone: () => Effect.void,
-      onSome: b => sink.onSuccess(this.i2(a, b))
-    }))))], UNBOUNDED));
-  }
-}
-function snapshotEffect(fx, sampled, f) {
-  return new SnapshotEffect(fx, sampled, f);
-}
-class SnapshotEffect extends _protos.FxBase {
-  i0;
-  i1;
-  i2;
-  constructor(i0, i1, i2) {
-    super();
-    this.i0 = i0;
-    this.i1 = i1;
-    this.i2 = i2;
-  }
-  run(sink) {
-    return Effect.flatMap(Ref.make(Option.none()), ref => Effect.flatMap(Effect.tap(Effect.fork(this.i1.run(Sink.make(sink.onFailure, b => Ref.set(ref, Option.some(b))))), () => this.i0.run(Sink.make(sink.onFailure, a => Effect.flatMap(Ref.get(ref), Option.match({
-      onNone: () => Effect.void,
-      onSome: b => Effect.matchCauseEffect(this.i2(a, b), sink)
-    }))))), Fiber.interrupt));
-  }
-}
-function if_(bool, options) {
-  return switchMap(skipRepeatsWith(bool, _Equivalence.boolean), b => b ? options.onTrue : options.onFalse);
-}
-function when(bool, options) {
-  return map(skipRepeatsWith(bool, _Equivalence.boolean), b => b ? options.onTrue : options.onFalse);
-}
-function mapBoth(fx, f, g) {
-  return map(mapError(fx, f), g);
-}
-//# sourceMappingURL=core.js.map