@typed/fx 1.17.3 → 1.18.0

package/dist/cjs/internal/core.js

@@ -0,0 +1,924 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.acquireUseRelease = void 0;
+exports.combine = combine;
+exports.continueWith = exports.concatMap = exports.compact = void 0;
+exports.drain = drain;
+exports.flatten = exports.flatMapWithStrategy = exports.flatMapErrorWithStrategy = exports.flatMapErrorConcurrently = exports.flatMapError = exports.flatMapConcurrently = exports.flatMapCauseWithStrategy = exports.flatMapCauseConcurrently = exports.flatMapCause = exports.flatMap = exports.filterMapErrorEffect = exports.filterMapError = exports.filterMapEffect = exports.filterMapCause = exports.filterMap = exports.filterError = exports.filterEffect = exports.filterCause = exports.filter = exports.failCause = exports.fail = 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.endWith = exports.empty = exports.during = exports.dropWhile = exports.dropUntil = exports.dropAfter = exports.drop = void 0;
+exports.from = from;
+exports.fromEffect = fromEffect;
+exports.fromEmitter = fromEmitter;
+exports.fromIterable = fromIterable;
+exports.fromSink = exports.fromScheduled = void 0;
+exports.fromStream = fromStream;
+exports.matchErrorWithStrategy = exports.matchErrorConcurrently = exports.matchCauseWithStrategy = exports.matchCauseConcurrently = exports.matchCause = exports.match = exports.mapErrorCause = exports.mapError = exports.mapEffect = exports.mapBoth = exports.map = exports.loopEffect = exports.loop = void 0;
+exports.merge = merge;
+exports.mergeBuffer = mergeBuffer;
+exports.never = exports.middleware = exports.mergeSwitch = exports.mergeConcurrently = exports.mergeBufferConcurrently = void 0;
+exports.observe = observe;
+exports.provideServiceEffect = exports.provideService = exports.provide = exports.periodic = void 0;
+exports.race = race;
+exports.startWith = exports.snapshot = exports.slice = exports.skipRepeatsWith = exports.skipRepeats = exports.since = exports.scanEffect = exports.scan = exports.reduce = exports.recoverWith = void 0;
+exports.struct = struct;
+exports.succeed = succeed;
+exports.takeUntil = exports.take = exports.sync = exports.switchMatchCause = exports.switchMatch = exports.switchMapError = exports.switchMapCause = exports.switchMap = exports.suspend = void 0;
+exports.tap = exports.takeWhile = void 0;
+exports.toArray = toArray;
+exports.toChunk = toChunk;
+exports.toReadonlyArray = toReadonlyArray;
+exports.withScopedFork = exports.withFlattenStrategy = exports.withEarlyExit = exports.until = void 0;
+var _effect = /*#__PURE__*/require("effect");
+var _Function = /*#__PURE__*/require("effect/Function");
+var _context = /*#__PURE__*/require("@typed/context");
+var Schedule = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/Schedule"));
+var _effectOperator = /*#__PURE__*/require("./effect-operator");
+var _helpers = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./helpers"));
+var helpers = _helpers;
+var Provide = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./provide"));
+var strategies = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./strategies"));
+var _syncOperator = /*#__PURE__*/require("./sync-operator");
+var Emitter = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("../Emitter"));
+var Sink = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("../Sink"));
+var _bounds = /*#__PURE__*/require("./bounds");
+var _effectPrimitive = /*#__PURE__*/require("./effect-primitive");
+var _fxPrimitive = /*#__PURE__*/require("./fx-primitive");
+var _matchers = /*#__PURE__*/require("./matchers");
+var _protos = /*#__PURE__*/require("./protos");
+var _run = /*#__PURE__*/require("./run");
+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; }
+const constUnit = () => _effect.Effect.unit;
+class Merge extends _fxPrimitive.ToFx {
+  i0;
+  i1;
+  constructor(i0, i1) {
+    super(i0, i1);
+    this.i0 = i0;
+    this.i1 = i1;
+  }
+  static make(fx, strategy) {
+    // TODO: Flatten nested Merges
+    if (fx.length === 0) return empty;
+    const nonEmptyFx = fx.filter(fx => !(fx instanceof _fxPrimitive.Empty));
+    if (nonEmptyFx.length === 0) return empty;
+    if (nonEmptyFx.length === 1) return nonEmptyFx[0];
+    const neverIndex = nonEmptyFx.findIndex(fx => fx instanceof _fxPrimitive.Never);
+    if (neverIndex === -1) return new Merge(nonEmptyFx, strategy);
+    switch (strategy._tag) {
+      case "Switch":
+      case "Ordered":
+        // Will only emit up to the first Never
+        return new Merge(nonEmptyFx.slice(0, neverIndex + 1), strategy);
+      // No use creating fibers for Fx that don't emit
+      case "Unordered":
+        return new Merge(nonEmptyFx, strategy);
+    }
+  }
+  toFx() {
+    const {
+      i0,
+      i1
+    } = this;
+    switch (i1._tag) {
+      case "Ordered":
+        {
+          const concurrency = i1.concurrency === Infinity ? "unbounded" : i1.concurrency;
+          return fromSink(sink => _effect.Effect.flatMap(helpers.withBuffers(i0.length, sink), buffers => _effect.Effect.all(i0.map((fx, i) => _effect.Effect.flatMap((0, _run.run)(fx, Sink.WithContext(cause => _effect.Cause.isInterruptedOnly(cause) ? _effect.Effect.unit : sink.onFailure(cause), a => buffers.onSuccess(i, a))), () => buffers.onEnd(i))), {
+            concurrency
+          })));
+        }
+      case "Switch":
+        return fromSink(sink => _effect.Effect.all(i0.map(fx => (0, _run.run)(fx, sink)), {
+          concurrency: 1
+        }));
+      case "Unordered":
+        return fromSink(sink => _effect.Effect.all(i0.map(fx => (0, _run.run)(fx, sink)), {
+          concurrency: i1.concurrency === Infinity ? "unbounded" : i1.concurrency
+        }));
+    }
+  }
+}
+class Slice extends _fxPrimitive.ToFx {
+  i0;
+  i1;
+  constructor(i0, i1) {
+    super(i0, i1);
+    this.i0 = i0;
+    this.i1 = i1;
+  }
+  static make(fx, bounds) {
+    if (fx instanceof Slice) {
+      return new Slice(fx.i0, (0, _bounds.mergeBounds)(fx.i1, bounds));
+    } else if (fx instanceof _fxPrimitive.Transformer && fx.i1._tag === "Map") {
+      return new _fxPrimitive.Transformer(Slice.make(fx.i0, bounds), fx.i1);
+    } else {
+      return new Slice(fx, bounds);
+    }
+  }
+  toFx() {
+    const fx = this.i0;
+    const {
+      max,
+      min
+    } = this.i1;
+    return withEarlyExit(({
+      sink
+    }) => _effect.Effect.suspend(() => {
+      let toSkip = min;
+      let toTake = max;
+      return (0, _run.run)(fx, Sink.WithContext(sink.onFailure, a => _effect.Effect.suspend(() => {
+        if (toSkip > 0) {
+          toSkip -= 1;
+          return _effect.Effect.unit;
+        } else if (toTake > 0) {
+          toTake -= 1;
+          return _effect.Effect.flatMap(sink.onSuccess(a), () => toTake <= 0 ? sink.earlyExit : _effect.Effect.unit);
+        } else {
+          return sink.earlyExit;
+        }
+      })));
+    }));
+  }
+}
+class Loop extends _fxPrimitive.ToFx {
+  i0;
+  i1;
+  i2;
+  constructor(i0, i1, i2) {
+    super(i0, i1, i2);
+    this.i0 = i0;
+    this.i1 = i1;
+    this.i2 = i2;
+  }
+  static make(fx, b, f) {
+    if (fx instanceof _fxPrimitive.Transformer) {
+      return FilterMapLoop.make(fx.i0, b, (0, _syncOperator.compileSyncReducer)(fx.i1, f));
+    } else if (fx instanceof _fxPrimitive.TransformerEffect) {
+      return new FilterMapLoopEffect(fx.i0, b, (0, _effectOperator.compileEffectLoop)(fx.i1, (b, a) => _effect.Effect.sync(() => f(b, a))));
+    } else {
+      return new Loop(fx, f, b);
+    }
+  }
+  toFx() {
+    return fromSink(sink => _effect.Effect.suspend(() => {
+      let acc = this.i2;
+      return (0, _run.run)(this.i0, Sink.WithContext(sink.onFailure, a => _effect.Effect.suspend(() => {
+        const [c, b] = this.i1(acc, a);
+        acc = b;
+        return sink.onSuccess(c);
+      })));
+    }));
+  }
+}
+class FilterMapLoop extends _fxPrimitive.ToFx {
+  i0;
+  i1;
+  i2;
+  constructor(i0, i1, i2) {
+    super(i0, i1, i2);
+    this.i0 = i0;
+    this.i1 = i1;
+    this.i2 = i2;
+  }
+  static make(fx, b, f) {
+    return new FilterMapLoop(fx, b, f);
+  }
+  toFx() {
+    return fromSink(sink => _effect.Effect.suspend(() => {
+      let acc = this.i1;
+      return (0, _run.run)(this.i0, Sink.WithContext(sink.onFailure, a => _effect.Effect.suspend(() => {
+        const optionCB = this.i2(acc, a);
+        if (_effect.Option.isNone(optionCB)) return _effect.Effect.unit;
+        const [c, b] = optionCB.value;
+        acc = b;
+        return sink.onSuccess(c);
+      })));
+    }));
+  }
+}
+class LoopEffect extends _fxPrimitive.ToFx {
+  i0;
+  i1;
+  i2;
+  constructor(i0, i1, i2) {
+    super(i0, i1, i2);
+    this.i0 = i0;
+    this.i1 = i1;
+    this.i2 = i2;
+  }
+  static make(fx, f, b) {
+    if (fx instanceof _fxPrimitive.TransformerEffect) {
+      return new FilterMapLoopEffect(fx.i0, b, (0, _effectOperator.compileEffectLoop)(fx.i1, f));
+    } else if (fx instanceof _fxPrimitive.Transformer) {
+      return new FilterMapLoopEffect(fx.i0, b, (0, _effectOperator.compileEffectLoop)((0, _effectOperator.liftSyncOperator)(fx.i1), f));
+    } else {
+      return new LoopEffect(fx, f, b);
+    }
+  }
+  toFx() {
+    const {
+      i0,
+      i1,
+      i2
+    } = this;
+    return fromSink(sink => _effect.Effect.flatMap(_effect.SynchronizedRef.make(i2), ref => (0, _run.run)(i0, Sink.WithContext(sink.onFailure, a => _effect.SynchronizedRef.updateEffect(ref, b => _effect.Effect.matchCauseEffect(i1(b, a), {
+      onFailure: cause => _effect.Effect.as(sink.onFailure(cause), b),
+      onSuccess: ([c, b2]) => _effect.Effect.as(sink.onSuccess(c), b2)
+    }))))));
+  }
+}
+class FilterMapLoopEffect extends _fxPrimitive.ToFx {
+  i0;
+  i1;
+  i2;
+  constructor(i0, i1, i2) {
+    super(i0, i1, i2);
+    this.i0 = i0;
+    this.i1 = i1;
+    this.i2 = i2;
+  }
+  toFx() {
+    return fromSink(sink => _effect.Effect.suspend(() => {
+      let acc = this.i1;
+      return (0, _run.run)(this.i0, Sink.WithContext(sink.onFailure, a => this.i2(acc, a).pipe(_effect.Effect.matchCauseEffect({
+        onFailure: sink.onFailure,
+        onSuccess: optionCB => _effect.Effect.suspend(() => {
+          if (_effect.Option.isNone(optionCB)) return _effect.Effect.unit;
+          const [c, b] = optionCB.value;
+          acc = b;
+          return sink.onSuccess(c);
+        })
+      }))));
+    }));
+  }
+}
+class FxProvide extends _fxPrimitive.ToFx {
+  i0;
+  i1;
+  constructor(i0, i1) {
+    super(i0, i1);
+    this.i0 = i0;
+    this.i1 = i1;
+  }
+  static make(fx, provide) {
+    if (fx instanceof FxProvide) {
+      return new FxProvide(fx.i0, Provide.merge(fx.i1, provide));
+    } else {
+      return new FxProvide(fx, provide);
+    }
+  }
+  toFx() {
+    return fromSink(sink => _effect.Effect.catchAllCause(Provide.provideToEffect((0, _run.run)(this.i0, sink), this.i1), sink.onFailure));
+  }
+}
+class Snapshot extends _fxPrimitive.ToFx {
+  i0;
+  i1;
+  i2;
+  constructor(i0, i1, i2) {
+    super(i0, i1, i2);
+    this.i0 = i0;
+    this.i1 = i1;
+    this.i2 = i2;
+  }
+  toFx() {
+    return (0, _matchers.matchFxInput)(this.i1, {
+      RefSubject: fx2 => this.runScoped(this.i0, fx2, this.i2),
+      Fx: fx2 => this.runScoped(this.i0, fx2, this.i2),
+      Effect: effect2 => mapEffect(this.i0, a => _effect.Effect.flatMap(effect2, b => this.i2(a, b))),
+      Cause: cause2 => matchCause(this.i0, {
+        onFailure: cause1 => _effect.Effect.failCause(_effect.Cause.sequential(cause1, cause2)),
+        onSuccess: () => _effect.Effect.failCause(cause2)
+      }),
+      Iterable: iterable => withEarlyExit(({
+        sink
+      }) => {
+        const iterator = iterable[Symbol.iterator]();
+        return (0, _run.run)(this.i0, Sink.WithContext(sink.onFailure, a => {
+          const result = iterator.next();
+          if (result.done) {
+            return sink.earlyExit;
+          } else {
+            return _effect.Effect.matchCauseEffect(this.i2(a, result.value), sink);
+          }
+        }));
+      }),
+      Otherwise: b => mapEffect(this.i0, a => this.i2(a, b))
+    });
+  }
+  runScoped(fx, fx2, f) {
+    return withScopedFork(({
+      fork,
+      sink
+    }) => _effect.Effect.flatMap(_effect.Ref.make(_effect.Option.none()), ref => _effect.Effect.flatMap(fork((0, _run.run)(fx2, Sink.WithContext(sink.onFailure, b => _effect.Ref.set(ref, _effect.Option.some(b))))), () => (0, _helpers.adjustTime)(1).pipe(_effect.Effect.zipRight((0, _run.run)(fx, Sink.WithContext(sink.onFailure, a => _effect.Effect.flatten(_effect.Ref.get(ref)).pipe(_effect.Effect.flatMap(b => _effect.Effect.matchCauseEffect(f(a, b), sink)), _effect.Effect.optionFromOptional, _effect.Effect.asUnit))))))));
+  }
+}
+class Middleware extends _fxPrimitive.ToFx {
+  i0;
+  i1;
+  i2;
+  constructor(i0, i1, i2) {
+    super(i0, i1);
+    this.i0 = i0;
+    this.i1 = i1;
+    this.i2 = i2;
+  }
+  static make(fx, middleware, mapSink) {
+    if (fx instanceof Middleware) {
+      return new Middleware(fx.i0, effect => middleware(fx.i1(effect)), s => fx.i2(mapSink(s)));
+    } else {
+      return new Middleware(fx, middleware, mapSink);
+    }
+  }
+  toFx() {
+    return fromSink(sink => this.i1((0, _run.run)(this.i0, this.i2(sink))));
+  }
+}
+function succeed(value) {
+  return new _fxPrimitive.Succeed(value);
+}
+function fromIterable(iterable) {
+  return new _fxPrimitive.FromIterable(iterable);
+}
+const map = exports.map = /*#__PURE__*/(0, _Function.dual)(2, function map(fx, f) {
+  return _fxPrimitive.Transformer.make(fx, (0, _syncOperator.Map)(f));
+});
+const mapBoth = exports.mapBoth = /*#__PURE__*/(0, _Function.dual)(2, function mapBoth(fx, options) {
+  return map(mapError(fx, options.onFailure), options.onSuccess);
+});
+const filter = exports.filter = /*#__PURE__*/(0, _Function.dual)(2, function map(fx, f) {
+  return _fxPrimitive.Transformer.make(fx, (0, _syncOperator.Filter)(f));
+});
+const filterMap = exports.filterMap = /*#__PURE__*/(0, _Function.dual)(2, function map(fx, f) {
+  return _fxPrimitive.Transformer.make(fx, (0, _syncOperator.FilterMap)(f));
+});
+const compact = fx => filterMap(fx, _Function.identity);
+exports.compact = compact;
+const mapErrorCause = exports.mapErrorCause = /*#__PURE__*/(0, _Function.dual)(2, function map(fx, f) {
+  return _fxPrimitive.TransformerCause.make(fx, (0, _syncOperator.Map)(f));
+});
+const mapError = exports.mapError = /*#__PURE__*/(0, _Function.dual)(2, function map(fx, f) {
+  return _fxPrimitive.TransformerCause.make(fx, (0, _syncOperator.Map)(_effect.Cause.map(f)));
+});
+const filterCause = exports.filterCause = /*#__PURE__*/(0, _Function.dual)(2, function map(fx, f) {
+  return _fxPrimitive.TransformerCause.make(fx, (0, _syncOperator.Filter)(f));
+});
+const filterMapCause = exports.filterMapCause = /*#__PURE__*/(0, _Function.dual)(2, function map(fx, f) {
+  return _fxPrimitive.TransformerCause.make(fx, (0, _syncOperator.FilterMap)(f));
+});
+const filterError = exports.filterError = /*#__PURE__*/(0, _Function.dual)(2, function map(fx, f) {
+  return filterMapCause(fx, cause => _effect.Cause.failureOrCause(cause).pipe(_effect.Either.match({
+    onLeft: e => f(e) ? _effect.Option.some(_effect.Cause.fail(e)) : _effect.Option.none(),
+    onRight: _effect.Option.some
+  })));
+});
+const filterMapError = exports.filterMapError = /*#__PURE__*/(0, _Function.dual)(2, function map(fx, f) {
+  return filterMapCause(fx, cause => _effect.Cause.failureOrCause(cause).pipe(_effect.Either.match({
+    onLeft: e => _effect.Option.map(f(e), _effect.Cause.fail),
+    onRight: _effect.Option.some
+  })));
+});
+const filterMapErrorEffect = exports.filterMapErrorEffect = /*#__PURE__*/(0, _Function.dual)(2, (fx, f) => {
+  return fromSink(sink => (0, _run.run)(fx, Sink.WithContext(cause => _effect.Either.match(_effect.Cause.failureOrCause(cause), {
+    onLeft: e => _effect.Effect.matchCauseEffect(f(e), {
+      onFailure: sink.onFailure,
+      onSuccess: _effect.Option.match({
+        onNone: () => _effect.Effect.unit,
+        onSome: b => sink.onFailure(_effect.Cause.fail(b))
+      })
+    }),
+    onRight: sink.onFailure
+  }), sink.onSuccess)));
+});
+function observe(fx, onSuccees) {
+  return helpers.withScopedFork(fork => _effect.Effect.flatMap(_effect.Deferred.make(), deferred => (0, _run.run)(fx, Sink.WithContext(cause => _effect.Deferred.failCause(deferred, cause), a => _effect.Effect.catchAllCause(onSuccees(a), cause => _effect.Deferred.failCause(deferred, cause)))).pipe(_effect.Effect.intoDeferred(deferred), fork, _effect.Effect.flatMap(() => _effect.Deferred.await(deferred)))));
+}
+function drain(fx) {
+  return observe(fx, constUnit);
+}
+function toArray(fx) {
+  return _effect.Effect.suspend(() => {
+    const array = [];
+    return _effect.Effect.as(observe(fx, a => _effect.Effect.sync(() => array.push(a))), array);
+  });
+}
+function toReadonlyArray(fx) {
+  return toArray(fx);
+}
+const flatMapWithStrategy = exports.flatMapWithStrategy = /*#__PURE__*/(0, _Function.dual)(3, function flatMapWithStrategy(fx, f, strategy) {
+  return new _fxPrimitive.WithFlattenStrategy(({
+    fork,
+    sink
+  }) => (0, _run.run)(fx, Sink.WithContext(sink.onFailure, a => fork((0, _run.run)(from(f(a)), sink)))), strategy);
+});
+const switchMap = exports.switchMap = /*#__PURE__*/(0, _Function.dual)(2, function switchMap(fx, f) {
+  return flatMapWithStrategy(fx, f, strategies.Switch);
+});
+const exhaustMap = exports.exhaustMap = /*#__PURE__*/(0, _Function.dual)(2, function exhaustmap(fx, f) {
+  return flatMapWithStrategy(fx, f, strategies.Exhaust);
+});
+const exhaust = fx => exhaustMap(fx, _Function.identity);
+exports.exhaust = exhaust;
+const exhaustMapLatest = exports.exhaustMapLatest = /*#__PURE__*/(0, _Function.dual)(2, function exhaustMapLatest(fx, f) {
+  return flatMapWithStrategy(fx, f, strategies.ExhaustLatest);
+});
+const exhaustLatest = fx => exhaustMapLatest(fx, _Function.identity);
+exports.exhaustLatest = exhaustLatest;
+const flatMap = exports.flatMap = /*#__PURE__*/(0, _Function.dual)(2, function flatMap(fx, f) {
+  return flatMapWithStrategy(fx, f, strategies.Unbounded);
+});
+const flatten = fx => flatMap(fx, _Function.identity);
+exports.flatten = flatten;
+const flatMapConcurrently = exports.flatMapConcurrently = /*#__PURE__*/(0, _Function.dual)(3, function flatMapConcurrently(fx, f, concurrency) {
+  return flatMapWithStrategy(fx, f, strategies.Bounded(concurrency));
+});
+const concatMap = exports.concatMap = /*#__PURE__*/(0, _Function.dual)(2, function concatMap(fx, f) {
+  return flatMapConcurrently(fx, f, 1);
+});
+const acquireUseRelease = exports.acquireUseRelease = /*#__PURE__*/(0, _Function.dual)(3, function acquireUseRelease(acquire, use, release) {
+  return fromSink(sink => _effect.Effect.catchAllCause(_effect.Effect.acquireUseRelease(acquire, a => (0, _run.run)(from(use(a)), sink), (a, exit) => _effect.Effect.catchAllCause(release(a, exit), sink.onFailure)), sink.onFailure));
+});
+function combine(fxs) {
+  return fromSink(sink => _effect.Effect.suspend(() => {
+    const total = fxs.length;
+    if (total === 0) return _effect.Effect.unit;
+    const values = new globalThis.Map();
+    const sample = () => Array.from({
+      length: total
+    }, (_, i) => values.get(i));
+    const emitIfReady = (value, index) => _effect.Effect.suspend(() => {
+      values.set(index, value);
+      if (values.size === total) {
+        return sink.onSuccess(sample());
+      } else {
+        return _effect.Effect.unit;
+      }
+    });
+    return _effect.Effect.all(fxs.map((fx, index) => (0, _run.run)(fx, Sink.WithContext(sink.onFailure, a => emitIfReady(a, index)))), {
+      concurrency: "unbounded"
+    });
+  }));
+}
+function struct(fxs) {
+  return map(combine(Reflect.ownKeys(fxs).map(k => map(fxs[k], a => [k, a]))), Object.fromEntries);
+}
+function merge(fxs) {
+  return Merge.make(fxs, strategies.Unordered(Infinity));
+}
+const mergeConcurrently = exports.mergeConcurrently = /*#__PURE__*/(0, _Function.dual)(2, function mergeConcurrently(fxs, concurrency) {
+  return Merge.make(fxs, strategies.Unordered(concurrency));
+});
+function mergeBuffer(fxs) {
+  return Merge.make(fxs, strategies.Ordered(Infinity));
+}
+const mergeBufferConcurrently = exports.mergeBufferConcurrently = /*#__PURE__*/(0, _Function.dual)(2, function mergeConcurrently(fxs, concurrency) {
+  return Merge.make(fxs, strategies.Ordered(concurrency));
+});
+const mergeSwitch = fxs => Merge.make(fxs, strategies.Switch);
+exports.mergeSwitch = mergeSwitch;
+function race(fxs) {
+  if (fxs.length === 0) return empty;
+  if (fxs.length === 1) return fxs[0];
+  return withScopedFork(({
+    fork,
+    sink
+  }) => _effect.Effect.asyncEffect(resume => _effect.Effect.gen(function* (_) {
+    let winningIndex = -1;
+    const fibers = yield* _(_effect.Effect.forEach(fxs, (fx, i) => fork((0, _run.run)(fx, Sink.Sink(cause => _effect.Effect.suspend(() => pickWinner(i) ? sink.onFailure(cause) : _effect.Effect.unit), a => _effect.Effect.suspend(() => pickWinner(i) ? sink.onSuccess(a) : _effect.Effect.unit))))));
+    function pickWinner(i) {
+      if (winningIndex === -1) {
+        winningIndex = i;
+        resume(_effect.Effect.succeed([i, fibers]));
+      }
+      return winningIndex === i;
+    }
+  })).pipe(_effect.Effect.flatMap(([winningIndex, fibers]) => _effect.Effect.suspend(() => {
+    const [winner] = fibers.splice(winningIndex, 1);
+    return _effect.Effect.flatMap(_effect.Fiber.interruptAll(fibers), () => _effect.Fiber.join(winner));
+  }))));
+}
+const empty = exports.empty = /*#__PURE__*/new _fxPrimitive.Empty();
+const never = exports.never = /*#__PURE__*/new _fxPrimitive.Never();
+const failCause = cause => new _fxPrimitive.Fail(cause);
+exports.failCause = failCause;
+const fail = e => failCause(_effect.Cause.fail(e));
+exports.fail = fail;
+const fromSink = f => new _fxPrimitive.FromSink(sink => _effect.Effect.catchAllCause(f(sink), sink.onFailure));
+exports.fromSink = fromSink;
+const suspend = f => new _fxPrimitive.Suspend(f);
+exports.suspend = suspend;
+const sync = f => new _fxPrimitive.Sync(f);
+exports.sync = sync;
+const slice = exports.slice = /*#__PURE__*/(0, _Function.dual)(3, function slice(fx, skip, take) {
+  return Slice.make(fx, (0, _bounds.boundsFrom)(skip, take));
+});
+const take = exports.take = /*#__PURE__*/(0, _Function.dual)(2, function take(fx, n) {
+  return slice(fx, 0, n);
+});
+const drop = exports.drop = /*#__PURE__*/(0, _Function.dual)(2, function drop(fx, n) {
+  return slice(fx, n, Infinity);
+});
+const takeWhile = exports.takeWhile = /*#__PURE__*/(0, _Function.dual)(2, function takeWhile(fx, predicate) {
+  return withEarlyExit(({
+    sink
+  }) => (0, _run.run)(fx, Sink.WithContext(sink.onFailure, a => _effect.Effect.matchCauseEffect(predicate(a), {
+    onFailure: sink.onFailure,
+    onSuccess: b => b ? sink.onSuccess(a) : sink.earlyExit
+  }))));
+});
+const takeUntil = exports.takeUntil = /*#__PURE__*/(0, _Function.dual)(2, function takeUntil(fx, predicate) {
+  return takeWhile(fx, a => _effect.Effect.map(predicate(a), x => !x));
+});
+const dropWhile = exports.dropWhile = /*#__PURE__*/(0, _Function.dual)(2, function dropWhile(fx, predicate) {
+  return withEarlyExit(({
+    sink
+  }) => _effect.Effect.suspend(() => {
+    let isDropping = true;
+    return (0, _run.run)(fx, Sink.WithContext(sink.onFailure, a => isDropping ? _effect.Effect.matchCauseEffect(predicate(a), {
+      onFailure: sink.onFailure,
+      onSuccess: b => {
+        if (b) {
+          return _effect.Effect.unit;
+        } else {
+          isDropping = false;
+          return sink.onSuccess(a);
+        }
+      }
+    }) : sink.onSuccess(a)));
+  }));
+});
+const dropUntil = exports.dropUntil = /*#__PURE__*/(0, _Function.dual)(2, function dropUntil(fx, predicate) {
+  return dropWhile(fx, a => _effect.Effect.map(predicate(a), x => !x));
+});
+const dropAfter = exports.dropAfter = /*#__PURE__*/(0, _Function.dual)(2, function dropAfter(fx, predicate) {
+  return fromSink(sink => _effect.Effect.suspend(() => {
+    let isDropping = false;
+    return (0, _run.run)(fx, Sink.WithContext(sink.onFailure, a => isDropping ? _effect.Effect.unit : _effect.Effect.matchCauseEffect(predicate(a), {
+      onFailure: sink.onFailure,
+      onSuccess: b => {
+        if (b) {
+          isDropping = true;
+          return _effect.Effect.unit;
+        } else {
+          return sink.onSuccess(a);
+        }
+      }
+    })));
+  }));
+});
+const continueWith = exports.continueWith = /*#__PURE__*/(0, _Function.dual)(2, function continueWith(fx, f) {
+  return fromSink(sink => _effect.Effect.flatMap((0, _run.run)(fx, sink), () => (0, _run.run)(f(), sink)));
+});
+const recoverWith = exports.recoverWith = /*#__PURE__*/(0, _Function.dual)(2, function recoverWith(fx, f) {
+  return fromSink(sink => _effect.Effect.catchAllCause(observe(fx, sink.onSuccess), cause => (0, _run.run)(from(f(cause)), sink)));
+});
+const mapEffect = exports.mapEffect = /*#__PURE__*/(0, _Function.dual)(2, function mapEffect(fx, f) {
+  return _fxPrimitive.TransformerEffect.make(fx, (0, _effectOperator.MapEffect)(f));
+});
+const tap = exports.tap = /*#__PURE__*/(0, _Function.dual)(2, function tap(fx, f) {
+  return _fxPrimitive.TransformerEffect.make(fx, (0, _effectOperator.TapEffect)(f));
+});
+const filterEffect = exports.filterEffect = /*#__PURE__*/(0, _Function.dual)(2, function filterEffect(fx, predicate) {
+  return _fxPrimitive.TransformerEffect.make(fx, (0, _effectOperator.FilterEffect)(predicate));
+});
+const filterMapEffect = exports.filterMapEffect = /*#__PURE__*/(0, _Function.dual)(2, function filterEffect(fx, f) {
+  return _fxPrimitive.TransformerEffect.make(fx, (0, _effectOperator.FilterMapEffect)(f));
+});
+const middleware = exports.middleware = /*#__PURE__*/(0, _Function.dual)(args => args.length === 3 || typeof args[0] !== "function", function middleware(fx, f, g) {
+  return Middleware.make(fx, f, g ?? _Function.identity);
+});
+const loop = exports.loop = /*#__PURE__*/(0, _Function.dual)(3, function loop(fx, seed, f) {
+  return Loop.make(fx, seed, f);
+});
+const loopEffect = exports.loopEffect = /*#__PURE__*/(0, _Function.dual)(3, function loopEffect(fx, seed, f) {
+  return LoopEffect.make(fx, f, seed);
+});
+const startWith = exports.startWith = /*#__PURE__*/(0, _Function.dual)(2, function startWith(fx, value) {
+  return fromSink(sink => _effect.Effect.flatMap(sink.onSuccess(value), () => (0, _run.run)(fx, sink)));
+});
+const endWith = exports.endWith = /*#__PURE__*/(0, _Function.dual)(2, function endWith(fx, value) {
+  return fromSink(sink => _effect.Effect.flatMap((0, _run.run)(fx, sink), () => sink.onSuccess(value)));
+});
+const scan = exports.scan = /*#__PURE__*/(0, _Function.dual)(3, function loop(fx, seed, f) {
+  return continueWith(new _fxPrimitive.Succeed(seed), () => Loop.make(fx, seed, (b, a) => {
+    const b2 = f(b, a);
+    return [b2, b2];
+  }));
+});
+const scanEffect = exports.scanEffect = /*#__PURE__*/(0, _Function.dual)(3, function loopEffect(fx, seed, f) {
+  return continueWith(new _fxPrimitive.Succeed(seed), () => LoopEffect.make(fx, (b, a) => _effect.Effect.map(f(b, a), b2 => [b2, b2]), seed));
+});
+const flatMapCauseWithStrategy = exports.flatMapCauseWithStrategy = /*#__PURE__*/(0, _Function.dual)(3, function flatMapCause(fx, f, strategy) {
+  return new _fxPrimitive.WithFlattenStrategy(({
+    fork,
+    sink
+  }) => (0, _run.run)(fx, Sink.WithContext(cause => fork((0, _run.run)(from(f(cause)), sink)), sink.onSuccess)), strategy);
+});
+const flatMapErrorWithStrategy = exports.flatMapErrorWithStrategy = /*#__PURE__*/(0, _Function.dual)(3, function flatMapCause(fx, f, strategy) {
+  return new _fxPrimitive.WithFlattenStrategy(({
+    fork,
+    sink
+  }) => (0, _run.run)(fx, Sink.WithContext(cause => fork((0, _run.run)(from(cause.pipe(_effect.Cause.failureOrCause, _effect.Either.match({
+    onLeft: f,
+    onRight: failCause
+  }))), sink)), sink.onSuccess)), strategy);
+});
+const flatMapCause = exports.flatMapCause = /*#__PURE__*/(0, _Function.dual)(2, function flatMapCause(fx, f) {
+  return flatMapCauseWithStrategy(fx, f, strategies.Unbounded);
+});
+const flatMapError = exports.flatMapError = /*#__PURE__*/(0, _Function.dual)(2, function flatMapError(fx, f) {
+  return flatMapErrorWithStrategy(fx, f, strategies.Unbounded);
+});
+const flatMapCauseConcurrently = exports.flatMapCauseConcurrently = /*#__PURE__*/(0, _Function.dual)(3, function flatMapCauseConcurrently(fx, f, concurrency) {
+  return flatMapCauseWithStrategy(fx, f, strategies.Bounded(concurrency));
+});
+const flatMapErrorConcurrently = exports.flatMapErrorConcurrently = /*#__PURE__*/(0, _Function.dual)(3, function flatMapCauseConcurrently(fx, f, concurrency) {
+  return flatMapErrorWithStrategy(fx, f, strategies.Bounded(concurrency));
+});
+const switchMapCause = exports.switchMapCause = /*#__PURE__*/(0, _Function.dual)(2, function switchMapCause(fx, f) {
+  return flatMapCauseWithStrategy(fx, f, strategies.Switch);
+});
+const switchMapError = exports.switchMapError = /*#__PURE__*/(0, _Function.dual)(2, function switchMapError(fx, f) {
+  return flatMapErrorWithStrategy(fx, f, strategies.Switch);
+});
+const exhaustMapCause = exports.exhaustMapCause = /*#__PURE__*/(0, _Function.dual)(2, function exhaustMapCause(fx, f) {
+  return flatMapCauseWithStrategy(fx, f, strategies.Exhaust);
+});
+const exhaustMapError = exports.exhaustMapError = /*#__PURE__*/(0, _Function.dual)(2, function switchMapError(fx, f) {
+  return flatMapErrorWithStrategy(fx, f, strategies.Exhaust);
+});
+const exhaustMapLatestCause = exports.exhaustMapLatestCause = /*#__PURE__*/(0, _Function.dual)(2, function exhaustMapLatestCause(fx, f) {
+  return flatMapCauseWithStrategy(fx, f, strategies.ExhaustLatest);
+});
+const exhaustMapLatestError = exports.exhaustMapLatestError = /*#__PURE__*/(0, _Function.dual)(2, function switchMapError(fx, f) {
+  return flatMapErrorWithStrategy(fx, f, strategies.ExhaustLatest);
+});
+const matchCauseWithStrategy = exports.matchCauseWithStrategy = /*#__PURE__*/(0, _Function.dual)(2, function flatMapCause(fx, options) {
+  return new _fxPrimitive.WithFlattenStrategy(({
+    fork,
+    sink
+  }) => (0, _run.run)(fx, Sink.WithContext(cause => fork((0, _run.run)(from(options.onFailure(cause)), sink)), a => fork((0, _run.run)(from(options.onSuccess(a)), sink)))), options.strategy);
+});
+const matchErrorWithStrategy = exports.matchErrorWithStrategy = /*#__PURE__*/(0, _Function.dual)(2, function flatMapCause(fx, options) {
+  return new _fxPrimitive.WithFlattenStrategy(({
+    fork,
+    sink
+  }) => (0, _run.run)(fx, Sink.WithContext(cause => fork((0, _run.run)(from(cause.pipe(_effect.Cause.failureOrCause, _effect.Either.match({
+    onLeft: options.onFailure,
+    onRight: failCause
+  }))), sink)), a => fork((0, _run.run)(from(options.onSuccess(a)), sink)))), options.strategy);
+});
+const matchCause = exports.matchCause = /*#__PURE__*/(0, _Function.dual)(2, function matchCause(fx, options) {
+  return matchCauseWithStrategy(fx, {
+    ...options,
+    strategy: strategies.Unbounded
+  });
+});
+const match = exports.match = /*#__PURE__*/(0, _Function.dual)(2, function matchCause(fx, options) {
+  return matchErrorWithStrategy(fx, {
+    ...options,
+    strategy: strategies.Unbounded
+  });
+});
+const matchCauseConcurrently = exports.matchCauseConcurrently = /*#__PURE__*/(0, _Function.dual)(2, function matchCause(fx, options) {
+  return matchCauseWithStrategy(fx, {
+    onFailure: options.onFailure,
+    onSuccess: options.onSuccess,
+    strategy: strategies.Bounded(options.concurrency)
+  });
+});
+const matchErrorConcurrently = exports.matchErrorConcurrently = /*#__PURE__*/(0, _Function.dual)(2, function matchErrorConcurrently(fx, options) {
+  return matchErrorWithStrategy(fx, {
+    ...options,
+    strategy: strategies.Bounded(options.concurrency)
+  });
+});
+const switchMatchCause = exports.switchMatchCause = /*#__PURE__*/(0, _Function.dual)(2, function matchCause(fx, options) {
+  return matchCauseWithStrategy(fx, {
+    ...options,
+    strategy: strategies.Switch
+  });
+});
+const switchMatch = exports.switchMatch = /*#__PURE__*/(0, _Function.dual)(2, function matchCause(fx, options) {
+  return matchErrorWithStrategy(fx, {
+    ...options,
+    strategy: strategies.Switch
+  });
+});
+const exhaustMatchCause = exports.exhaustMatchCause = /*#__PURE__*/(0, _Function.dual)(2, function matchCause(fx, options) {
+  return matchCauseWithStrategy(fx, {
+    ...options,
+    strategy: strategies.Exhaust
+  });
+});
+const exhaustMatch = exports.exhaustMatch = /*#__PURE__*/(0, _Function.dual)(2, function matchCause(fx, options) {
+  return matchErrorWithStrategy(fx, {
+    ...options,
+    strategy: strategies.Exhaust
+  });
+});
+const exhaustLatestMatchCause = exports.exhaustLatestMatchCause = /*#__PURE__*/(0, _Function.dual)(2, function matchCause(fx, options) {
+  return matchCauseWithStrategy(fx, {
+    ...options,
+    strategy: strategies.ExhaustLatest
+  });
+});
+const exhaustLatestMatch = exports.exhaustLatestMatch = /*#__PURE__*/(0, _Function.dual)(2, function matchCause(fx, options) {
+  return matchErrorWithStrategy(fx, {
+    ...options,
+    strategy: strategies.ExhaustLatest
+  });
+});
+const withEarlyExit = f => new _fxPrimitive.WithEarlyExit(f);
+exports.withEarlyExit = withEarlyExit;
+const withScopedFork = f => new _fxPrimitive.WithScopedFork(f);
+exports.withScopedFork = withScopedFork;
+const withFlattenStrategy = (f, strategy) => new _fxPrimitive.WithFlattenStrategy(f, strategy);
+exports.withFlattenStrategy = withFlattenStrategy;
+const during = exports.during = /*#__PURE__*/(0, _Function.dual)(2, function during(fx, window) {
+  return withEarlyExit(({
+    fork,
+    sink
+  }) => _effect.Effect.suspend(() => {
+    let taking = false;
+    return _effect.Effect.flatMap(fork((0, _run.run)(take(window, 1), Sink.WithContext(sink.onFailure, nested => {
+      taking = true;
+      return fork((0, _run.run)(take(nested, 1), Sink.WithContext(sink.onFailure, () => sink.earlyExit)));
+    }))), () => (0, _helpers.adjustTime)(1).pipe(_effect.Effect.zipRight((0, _run.run)(fx, Sink.Sink(sink.onFailure, a => taking ? sink.onSuccess(a) : _effect.Effect.unit)))));
+  }));
+});
+const since = exports.since = /*#__PURE__*/(0, _Function.dual)(2, function since(fx, window) {
+  return during(fx, map(window, () => never));
+});
+const until = exports.until = /*#__PURE__*/(0, _Function.dual)(2, function until(fx, window) {
+  return during(fx, succeed(window));
+});
+const fromScheduled = exports.fromScheduled = /*#__PURE__*/(0, _Function.dual)(2, function fromScheduled(fx, scheduled) {
+  return fromSink(sink => _effect.Effect.catchAllCause(_effect.Effect.repeat(_effect.Effect.matchCauseEffect(fx, sink), scheduled), sink.onFailure));
+});
+const periodic = exports.periodic = /*#__PURE__*/(0, _Function.dual)(2, function periodic(fx, duration) {
+  return fromScheduled(fx, Schedule.spaced(duration));
+});
+const provide = exports.provide = /*#__PURE__*/(0, _Function.dual)(2, function provideContext(fx, context) {
+  if (_effect.Layer.isLayer(context)) {
+    return FxProvide.make(fx, Provide.ProvideLayer(context));
+  } else if ((0, _context.isContext)(context)) {
+    return FxProvide.make(fx, Provide.ProvideContext(context));
+  } else {
+    return FxProvide.make(fx, Provide.ProvideRuntime(context));
+  }
+});
+const provideService = exports.provideService = /*#__PURE__*/(0, _Function.dual)(3, function provideService(fx, tag, service) {
+  return FxProvide.make(fx, Provide.ProvideService(tag, service));
+});
+const provideServiceEffect = exports.provideServiceEffect = /*#__PURE__*/(0, _Function.dual)(3, function provideService(fx, tag, service) {
+  return FxProvide.make(fx, Provide.ProvideServiceEffect(tag, service));
+});
+const skipRepeatsWith = exports.skipRepeatsWith = /*#__PURE__*/(0, _Function.dual)(2, function skipRepeatsWith(fx, eq) {
+  return FilterMapLoop.make(fx, _effect.Option.none(), (previous, a) => _effect.Option.match(previous, {
+    onNone: () => _effect.Option.some([a, _effect.Option.some(a)]),
+    onSome: prev => eq(a, prev) ? _effect.Option.none() : _effect.Option.some([a, _effect.Option.some(a)])
+  }));
+});
+const skipRepeats = fx => skipRepeatsWith(fx, _effect.Equal.equals);
+exports.skipRepeats = skipRepeats;
+class Reduce extends _effect.Effectable.Class {
+  fx;
+  seed;
+  f;
+  constructor(fx, seed, f) {
+    super();
+    this.fx = fx;
+    this.seed = seed;
+    this.f = f;
+  }
+  static make(fx, seed, f) {
+    if (fx instanceof _fxPrimitive.Transformer) {
+      return FilterMapReduce.make(fx.i0, seed, (0, _syncOperator.compileSyncReducer)(fx.i1, f));
+    }
+    return new Reduce(fx, seed, f);
+  }
+  cached = null;
+  commit() {
+    return this.cached ||= _effect.Effect.suspend(() => {
+      let acc = this.seed;
+      return _effect.Effect.map(observe(this.fx, a => _effect.Effect.sync(() => acc = this.f(acc, a))), () => acc);
+    });
+  }
+}
+class FilterMapReduce extends _effect.Effectable.Class {
+  i0;
+  i1;
+  i2;
+  constructor(i0, i1, i2) {
+    super();
+    this.i0 = i0;
+    this.i1 = i1;
+    this.i2 = i2;
+  }
+  static make(fx, seed, f) {
+    if (fx instanceof _fxPrimitive.FromIterable) {
+      if (Array.isArray(fx.i0)) {
+        return new _protos.OnceEffect(_effect.Effect.sync(() => reduceFilterArray(fx.i0, seed, f)));
+      } else {
+        return _effect.Effect.sync(() => reduceFilterIterable(fx.i0, seed, f));
+      }
+    }
+    return new FilterMapReduce(fx, seed, f);
+  }
+  cached = null;
+  commit() {
+    return this.cached ||= _effect.Effect.suspend(() => {
+      let acc = this.i1;
+      return _effect.Effect.map(observe(this.i0, a => _effect.Option.match(this.i2(acc, a), {
+        onNone: () => _effect.Effect.unit,
+        onSome: b => _effect.Effect.succeed(acc = b)
+      })), () => acc);
+    });
+  }
+}
+function reduceFilterIterable(iterable, seed, f) {
+  const iterator = iterable[Symbol.iterator]();
+  let acc = seed;
+  let result = iterator.next();
+  let option = _effect.Option.none();
+  while (!result.done) {
+    option = f(acc, result.value);
+    if (_effect.Option.isSome(option)) {
+      acc = option.value;
+    }
+    result = iterator.next();
+  }
+  return acc;
+}
+function reduceFilterArray(iterable, seed, f) {
+  const length = iterable.length;
+  let acc = seed;
+  let option = _effect.Option.none();
+  for (let i = 0; i < length; i++) {
+    option = f(acc, iterable[i]);
+    if (_effect.Option.isSome(option)) {
+      acc = option.value;
+    }
+  }
+  return acc;
+}
+const reduce = exports.reduce = /*#__PURE__*/(0, _Function.dual)(3, function reduce(fx, seed, f) {
+  return Reduce.make(fx, seed, f);
+});
+function toChunk(fx) {
+  return reduce(fx, _effect.Chunk.empty(), _effect.Chunk.append);
+}
+const snapshot = exports.snapshot = /*#__PURE__*/(0, _Function.dual)(3, function snapshot(fx, sampled, f) {
+  return new Snapshot(fx, sampled, f);
+});
+function fromEmitter(f) {
+  return withEarlyExit(({
+    scope,
+    sink
+  }) => _effect.Effect.zipRight(_effect.Effect.provideService(_effect.Effect.flatMap(Emitter.make(sink), f), _effect.Scope.Scope, scope), _effect.Effect.never));
+}
+function fromEffect(effect) {
+  return (0, _effectPrimitive.matchEffectPrimitive)(effect, {
+    Success: e => succeed(e.i0),
+    Failure: e => failCause(e.i0),
+    Left: e => fail(e.left),
+    Right: e => succeed(e.right),
+    None: () => fail(new _effect.Cause.NoSuchElementException()),
+    Some: e => succeed(e.value),
+    Sync: e => sync(e.i0),
+    Otherwise: () => fromSink(sink => _effect.Effect.matchCauseEffect(effect, sink))
+  });
+}
+function fromStream(stream, options) {
+  return fromSink(sink => _effect.Effect.acquireUseRelease(_effect.Scope.make(), scope => _effect.Effect.gen(function* (_) {
+    const pull = _effect.Effect.either(yield* _(_effect.Stream.toPull(stream), _effect.Effect.provideService(_effect.Scope.Scope, scope)));
+    while (true) {
+      const either = yield* _(pull);
+      if (_effect.Either.isRight(either)) {
+        yield* _(_effect.Effect.forEach(either.right, sink.onSuccess));
+      } else if (_effect.Option.isNone(either.left)) {
+        return;
+      } else {
+        yield* _(sink.onFailure(_effect.Cause.fail(either.left.value)));
+      }
+      // Schedule subsequent pulls using the current scheduler.
+      yield* _(_effect.Effect.yieldNow(options));
+    }
+  }), _effect.Scope.close));
+}
+const matchers = {
+  RefSubject: _Function.identity,
+  Fx: _Function.identity,
+  Effect: fromEffect,
+  Cause: failCause,
+  Iterable: fromIterable,
+  Otherwise: succeed
+};
+function from(input) {
+  return (0, _matchers.matchFxInput)(input, matchers);
+}
+//# sourceMappingURL=core.js.map