@slicemachine/manager 0.22.2-alpha.dani-snippets.6 → 0.22.2-alpha.dani-repeatable-links-codegen.1

package/dist/_node_modules/fp-ts/es6/ReaderTaskEither.cjs

@@ -0,0 +1,680 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Applicative = require("./Applicative.cjs");
+const Apply = require("./Apply.cjs");
+const Chain$1 = require("./Chain.cjs");
+const Compactable = require("./Compactable.cjs");
+const Either = require("./Either.cjs");
+const EitherT = require("./EitherT.cjs");
+const Filterable = require("./Filterable.cjs");
+const FromEither$1 = require("./FromEither.cjs");
+const FromIO$1 = require("./FromIO.cjs");
+const FromReader$1 = require("./FromReader.cjs");
+const FromTask$1 = require("./FromTask.cjs");
+const _function = require("./function.cjs");
+const Functor$1 = require("./Functor.cjs");
+const internal = require("./internal.cjs");
+const Reader = require("./Reader.cjs");
+const ReaderTask = require("./ReaderTask.cjs");
+const Task = require("./Task.cjs");
+const TaskEither = require("./TaskEither.cjs");
+var fromTaskEither = Reader.of;
+var left = /* @__PURE__ */ EitherT.left(ReaderTask.Pointed);
+var right = /* @__PURE__ */ EitherT.right(ReaderTask.Pointed);
+var rightTask = /* @__PURE__ */ _function.flow(TaskEither.rightTask, fromTaskEither);
+var leftTask = /* @__PURE__ */ _function.flow(TaskEither.leftTask, fromTaskEither);
+var rightReader = function(ma) {
+  return _function.flow(ma, TaskEither.right);
+};
+var leftReader = function(me) {
+  return _function.flow(me, TaskEither.left);
+};
+var rightReaderTask = /* @__PURE__ */ EitherT.rightF(ReaderTask.Functor);
+var leftReaderTask = /* @__PURE__ */ EitherT.leftF(ReaderTask.Functor);
+var rightIO = /* @__PURE__ */ _function.flow(TaskEither.rightIO, fromTaskEither);
+var leftIO = /* @__PURE__ */ _function.flow(TaskEither.leftIO, fromTaskEither);
+var rightReaderIO = function(ma) {
+  return _function.flow(ma, TaskEither.rightIO);
+};
+var leftReaderIO = function(me) {
+  return _function.flow(me, TaskEither.leftIO);
+};
+var fromEither = ReaderTask.of;
+var fromReader = rightReader;
+var fromIO = rightIO;
+var fromTask = rightTask;
+var fromIOEither = /* @__PURE__ */ _function.flow(TaskEither.fromIOEither, fromTaskEither);
+var fromReaderEither = function(ma) {
+  return _function.flow(ma, TaskEither.fromEither);
+};
+var match = /* @__PURE__ */ EitherT.match(ReaderTask.Functor);
+var matchW = match;
+var matchE = /* @__PURE__ */ EitherT.matchE(ReaderTask.Chain);
+var fold = matchE;
+var matchEW = matchE;
+var foldW = matchEW;
+var getOrElse = /* @__PURE__ */ EitherT.getOrElse(ReaderTask.Monad);
+var getOrElseW = getOrElse;
+var toUnion = /* @__PURE__ */ EitherT.toUnion(ReaderTask.Functor);
+var fromNullable = /* @__PURE__ */ EitherT.fromNullable(ReaderTask.Pointed);
+var fromNullableK = /* @__PURE__ */ EitherT.fromNullableK(ReaderTask.Pointed);
+var chainNullableK = /* @__PURE__ */ EitherT.chainNullableK(ReaderTask.Monad);
+var local = Reader.local;
+var asksReaderTaskEitherW = Reader.asksReaderW;
+var asksReaderTaskEither = asksReaderTaskEitherW;
+var orElse = /* @__PURE__ */ EitherT.orElse(ReaderTask.Monad);
+var orElseW = orElse;
+var tapError = /* @__PURE__ */ _function.dual(2, EitherT.tapError(ReaderTask.Monad));
+var orLeft = /* @__PURE__ */ EitherT.orLeft(ReaderTask.Monad);
+var swap = /* @__PURE__ */ EitherT.swap(ReaderTask.Functor);
+var fromIOEitherK = function(f) {
+  return _function.flow(f, fromIOEither);
+};
+var fromTaskEitherK = function(f) {
+  return _function.flow(f, fromTaskEither);
+};
+var fromReaderEitherK = function(f) {
+  return _function.flow(f, fromReaderEither);
+};
+var _map = function(fa, f) {
+  return _function.pipe(fa, map(f));
+};
+var _apPar = function(fab, fa) {
+  return _function.pipe(fab, ap(fa));
+};
+var _apSeq = function(fab, fa) {
+  return flatMap(fab, function(f) {
+    return _function.pipe(fa, map(f));
+  });
+};
+var _alt = function(fa, that) {
+  return _function.pipe(fa, alt(that));
+};
+var map = /* @__PURE__ */ EitherT.map(ReaderTask.Functor);
+var mapBoth = /* @__PURE__ */ _function.dual(3, EitherT.mapBoth(ReaderTask.Functor));
+var bimap = mapBoth;
+var mapError = /* @__PURE__ */ _function.dual(2, EitherT.mapError(ReaderTask.Functor));
+var mapLeft = mapError;
+var ap = /* @__PURE__ */ EitherT.ap(ReaderTask.ApplyPar);
+var apW = ap;
+var of = right;
+var flatMap = /* @__PURE__ */ _function.dual(2, EitherT.flatMap(ReaderTask.Monad));
+var flattenW = /* @__PURE__ */ flatMap(_function.identity);
+var flatten = flattenW;
+var alt = /* @__PURE__ */ EitherT.alt(ReaderTask.Monad);
+var altW = alt;
+var throwError = left;
+var URI = "ReaderTaskEither";
+var getCompactable = function(M) {
+  var C = Either.getCompactable(M);
+  return {
+    URI,
+    _E: void 0,
+    compact: Compactable.compact(ReaderTask.Functor, C),
+    separate: Compactable.separate(ReaderTask.Functor, C, Either.Functor)
+  };
+};
+function getFilterable(M) {
+  var F = Either.getFilterable(M);
+  var C = getCompactable(M);
+  var filter = Filterable.filter(ReaderTask.Functor, F);
+  var filterMap = Filterable.filterMap(ReaderTask.Functor, F);
+  var partition = Filterable.partition(ReaderTask.Functor, F);
+  var partitionMap = Filterable.partitionMap(ReaderTask.Functor, F);
+  return {
+    URI,
+    _E: void 0,
+    map: _map,
+    compact: C.compact,
+    separate: C.separate,
+    filter: function(fa, predicate) {
+      return _function.pipe(fa, filter(predicate));
+    },
+    filterMap: function(fa, f) {
+      return _function.pipe(fa, filterMap(f));
+    },
+    partition: function(fa, predicate) {
+      return _function.pipe(fa, partition(predicate));
+    },
+    partitionMap: function(fa, f) {
+      return _function.pipe(fa, partitionMap(f));
+    }
+  };
+}
+function getApplicativeReaderTaskValidation(A, S) {
+  var ap2 = Apply.ap(Reader.Apply, TaskEither.getApplicativeTaskValidation(A, S));
+  return {
+    URI,
+    _E: void 0,
+    map: _map,
+    ap: function(fab, fa) {
+      return _function.pipe(fab, ap2(fa));
+    },
+    of
+  };
+}
+function getAltReaderTaskValidation(S) {
+  var alt2 = EitherT.altValidation(ReaderTask.Monad, S);
+  return {
+    URI,
+    _E: void 0,
+    map: _map,
+    alt: function(fa, that) {
+      return _function.pipe(fa, alt2(that));
+    }
+  };
+}
+var Functor = {
+  URI,
+  map: _map
+};
+var as = _function.dual(2, Functor$1.as(Functor));
+var asUnit = Functor$1.asUnit(Functor);
+var flap = /* @__PURE__ */ Functor$1.flap(Functor);
+var Pointed = {
+  URI,
+  of
+};
+var ApplyPar = {
+  URI,
+  map: _map,
+  ap: _apPar
+};
+var apFirst = /* @__PURE__ */ Apply.apFirst(ApplyPar);
+var apFirstW = apFirst;
+var apSecond = /* @__PURE__ */ Apply.apSecond(ApplyPar);
+var apSecondW = apSecond;
+var ApplicativePar = {
+  URI,
+  map: _map,
+  ap: _apPar,
+  of
+};
+var ApplySeq = {
+  URI,
+  map: _map,
+  ap: _apSeq
+};
+var ApplicativeSeq = {
+  URI,
+  map: _map,
+  ap: _apSeq,
+  of
+};
+var Chain = {
+  URI,
+  map: _map,
+  ap: _apPar,
+  chain: flatMap
+};
+var Monad = {
+  URI,
+  map: _map,
+  ap: _apPar,
+  chain: flatMap,
+  of
+};
+var MonadIO = {
+  URI,
+  map: _map,
+  ap: _apPar,
+  chain: flatMap,
+  of,
+  fromIO
+};
+var MonadTask = {
+  URI,
+  map: _map,
+  ap: _apPar,
+  chain: flatMap,
+  of,
+  fromIO,
+  fromTask
+};
+var MonadThrow = {
+  URI,
+  map: _map,
+  ap: _apPar,
+  chain: flatMap,
+  of,
+  throwError
+};
+var FromEither = {
+  URI,
+  fromEither
+};
+var FromIO = {
+  URI,
+  fromIO
+};
+var FromTask = {
+  URI,
+  fromIO,
+  fromTask
+};
+var FromReader = {
+  URI,
+  fromReader
+};
+var tap = /* @__PURE__ */ _function.dual(2, Chain$1.tap(Chain));
+var tapEither = /* @__PURE__ */ _function.dual(2, FromEither$1.tapEither(FromEither, Chain));
+var tapIO = /* @__PURE__ */ _function.dual(2, FromIO$1.tapIO(FromIO, Chain));
+var tapTask = /* @__PURE__ */ _function.dual(2, FromTask$1.tapTask(FromTask, Chain));
+var tapReader = /* @__PURE__ */ _function.dual(2, FromReader$1.tapReader(FromReader, Chain));
+var tapReaderEither = /* @__PURE__ */ _function.dual(2, function(self, f) {
+  return tap(self, fromReaderEitherK(f));
+});
+var tapTaskEither = /* @__PURE__ */ _function.dual(2, function(self, f) {
+  return tap(self, fromTaskEitherK(f));
+});
+var tapReaderTask = /* @__PURE__ */ _function.dual(2, function(self, f) {
+  return tap(self, fromReaderTaskK(f));
+});
+var tapReaderIO = /* @__PURE__ */ _function.dual(2, function(self, f) {
+  return tap(self, fromReaderIOK(f));
+});
+var Bifunctor = {
+  URI,
+  bimap: mapBoth,
+  mapLeft: mapError
+};
+var Alt = {
+  URI,
+  map: _map,
+  alt: _alt
+};
+var ask = /* @__PURE__ */ FromReader$1.ask(FromReader);
+var asks = /* @__PURE__ */ FromReader$1.asks(FromReader);
+var fromReaderK = /* @__PURE__ */ FromReader$1.fromReaderK(FromReader);
+var chainFirstReaderK = tapReader;
+var chainFirstReaderKW = tapReader;
+var chainFirstReaderEitherKW = tapReaderEither;
+var chainFirstReaderEitherK = tapReaderEither;
+var chainFirstTaskEitherKW = tapTaskEither;
+var chainFirstTaskEitherK = tapTaskEither;
+var fromReaderTaskK = function(f) {
+  return function() {
+    var a = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+      a[_i] = arguments[_i];
+    }
+    return rightReaderTask(f.apply(void 0, a));
+  };
+};
+var chainFirstReaderTaskKW = tapReaderTask;
+var chainFirstReaderTaskK = tapReaderTask;
+var fromReaderIOK = function(f) {
+  return function() {
+    var a = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+      a[_i] = arguments[_i];
+    }
+    return rightReaderIO(f.apply(void 0, a));
+  };
+};
+var chainFirstReaderIOKW = tapReaderIO;
+var chainFirstReaderIOK = tapReaderIO;
+var fromOption = /* @__PURE__ */ FromEither$1.fromOption(FromEither);
+var fromOptionK = /* @__PURE__ */ FromEither$1.fromOptionK(FromEither);
+var chainOptionK = /* @__PURE__ */ FromEither$1.chainOptionK(FromEither, Chain);
+var chainOptionKW = chainOptionK;
+var _FromEither = {
+  fromEither: FromEither.fromEither
+};
+var liftNullable = /* @__PURE__ */ internal.liftNullable(_FromEither);
+var liftOption = /* @__PURE__ */ internal.liftOption(_FromEither);
+var _FlatMap = {
+  flatMap
+};
+var _FromIO = {
+  fromIO
+};
+var _FromTask = {
+  fromTask
+};
+var _FromReader = {
+  fromReader
+};
+var flatMapNullable = /* @__PURE__ */ internal.flatMapNullable(_FromEither, _FlatMap);
+var flatMapOption = /* @__PURE__ */ internal.flatMapOption(_FromEither, _FlatMap);
+var flatMapEither = /* @__PURE__ */ internal.flatMapEither(_FromEither, _FlatMap);
+var flatMapTaskEither = /* @__PURE__ */ _function.dual(2, function(self, f) {
+  return flatMap(self, fromTaskEitherK(f));
+});
+var flatMapReaderTask = /* @__PURE__ */ _function.dual(2, function(self, f) {
+  return flatMap(self, fromReaderTaskK(f));
+});
+var flatMapIO = /* @__PURE__ */ internal.flatMapIO(_FromIO, _FlatMap);
+var flatMapTask = /* @__PURE__ */ internal.flatMapTask(_FromTask, _FlatMap);
+var flatMapReader = /* @__PURE__ */ internal.flatMapReader(_FromReader, _FlatMap);
+var flatMapReaderIO = /* @__PURE__ */ _function.dual(2, function(self, f) {
+  return flatMap(self, fromReaderIOK(f));
+});
+var flatMapIOEither = /* @__PURE__ */ _function.dual(2, function(self, f) {
+  return flatMap(self, fromIOEitherK(f));
+});
+var flatMapReaderEither = /* @__PURE__ */ _function.dual(2, function(self, f) {
+  return flatMap(self, fromReaderEitherK(f));
+});
+var chainEitherK = flatMapEither;
+var chainEitherKW = flatMapEither;
+var chainFirstEitherK = tapEither;
+var chainFirstEitherKW = tapEither;
+var chainTaskEitherKW = flatMapTaskEither;
+var chainTaskEitherK = flatMapTaskEither;
+var chainReaderTaskKW = flatMapReaderTask;
+var chainReaderTaskK = flatMapReaderTask;
+var fromPredicate = /* @__PURE__ */ FromEither$1.fromPredicate(FromEither);
+var filterOrElse = /* @__PURE__ */ FromEither$1.filterOrElse(FromEither, Chain);
+var filterOrElseW = filterOrElse;
+var fromEitherK = /* @__PURE__ */ FromEither$1.fromEitherK(FromEither);
+var fromIOK = /* @__PURE__ */ FromIO$1.fromIOK(FromIO);
+var chainIOK = flatMapIO;
+var chainFirstIOK = tapIO;
+var fromTaskK = /* @__PURE__ */ FromTask$1.fromTaskK(FromTask);
+var chainTaskK = flatMapTask;
+var chainFirstTaskK = tapTask;
+var chainReaderK = flatMapReader;
+var chainReaderKW = flatMapReader;
+var chainReaderIOKW = flatMapReaderIO;
+var chainReaderIOK = flatMapReaderIO;
+var chainIOEitherKW = flatMapIOEither;
+var chainIOEitherK = flatMapIOEither;
+var chainReaderEitherKW = flatMapReaderEither;
+var chainReaderEitherK = flatMapReaderEither;
+function bracket(acquire, use, release) {
+  return bracketW(acquire, use, release);
+}
+function bracketW(acquire, use, release) {
+  return function(r) {
+    return TaskEither.bracketW(acquire(r), function(a) {
+      return use(a)(r);
+    }, function(a, e) {
+      return release(a, e)(r);
+    });
+  };
+}
+var Do = /* @__PURE__ */ of(internal.emptyRecord);
+var bindTo = /* @__PURE__ */ Functor$1.bindTo(Functor);
+var let_ = /* @__PURE__ */ Functor$1.let(Functor);
+var bind = /* @__PURE__ */ Chain$1.bind(Chain);
+var bindW = bind;
+var apS = /* @__PURE__ */ Apply.apS(ApplyPar);
+var apSW = apS;
+var ApT = /* @__PURE__ */ of(internal.emptyReadonlyArray);
+var traverseReadonlyNonEmptyArrayWithIndex = function(f) {
+  return _function.flow(Reader.traverseReadonlyNonEmptyArrayWithIndex(f), Reader.map(TaskEither.traverseReadonlyNonEmptyArrayWithIndex(_function.SK)));
+};
+var traverseReadonlyArrayWithIndex = function(f) {
+  var g = traverseReadonlyNonEmptyArrayWithIndex(f);
+  return function(as2) {
+    return internal.isNonEmpty(as2) ? g(as2) : ApT;
+  };
+};
+var traverseReadonlyNonEmptyArrayWithIndexSeq = function(f) {
+  return _function.flow(Reader.traverseReadonlyNonEmptyArrayWithIndex(f), Reader.map(TaskEither.traverseReadonlyNonEmptyArrayWithIndexSeq(_function.SK)));
+};
+var traverseReadonlyArrayWithIndexSeq = function(f) {
+  var g = traverseReadonlyNonEmptyArrayWithIndexSeq(f);
+  return function(as2) {
+    return internal.isNonEmpty(as2) ? g(as2) : ApT;
+  };
+};
+var traverseArrayWithIndex = traverseReadonlyArrayWithIndex;
+var traverseArray = function(f) {
+  return traverseReadonlyArrayWithIndex(function(_, a) {
+    return f(a);
+  });
+};
+var sequenceArray = /* @__PURE__ */ traverseArray(_function.identity);
+var traverseSeqArrayWithIndex = traverseReadonlyArrayWithIndexSeq;
+var traverseSeqArray = function(f) {
+  return traverseReadonlyArrayWithIndexSeq(function(_, a) {
+    return f(a);
+  });
+};
+var sequenceSeqArray = /* @__PURE__ */ traverseSeqArray(_function.identity);
+var chain = flatMap;
+var chainW = flatMap;
+var chainFirst = tap;
+var chainFirstW = tap;
+var orElseFirst = tapError;
+var orElseFirstW = tapError;
+var readerTaskEither = {
+  URI,
+  map: _map,
+  of,
+  ap: _apPar,
+  chain: flatMap,
+  alt: _alt,
+  bimap: mapBoth,
+  mapLeft: mapError,
+  fromIO,
+  fromTask,
+  throwError
+};
+var readerTaskEitherSeq = {
+  URI,
+  map: _map,
+  of,
+  ap: _apSeq,
+  chain: flatMap,
+  alt: _alt,
+  bimap: mapBoth,
+  mapLeft: mapError,
+  fromIO,
+  fromTask,
+  throwError
+};
+var getApplySemigroup = /* @__PURE__ */ Apply.getApplySemigroup(ApplySeq);
+var getApplyMonoid = /* @__PURE__ */ Applicative.getApplicativeMonoid(ApplicativeSeq);
+var getSemigroup = function(S) {
+  return Apply.getApplySemigroup(ReaderTask.ApplySeq)(Either.getSemigroup(S));
+};
+function getReaderTaskValidation(SE) {
+  var applicativeReaderTaskValidation = getApplicativeReaderTaskValidation(Task.ApplicativePar, SE);
+  var altReaderTaskValidation = getAltReaderTaskValidation(SE);
+  return {
+    URI,
+    _E: void 0,
+    map: _map,
+    of,
+    chain: flatMap,
+    bimap: mapBoth,
+    mapLeft: mapError,
+    ap: applicativeReaderTaskValidation.ap,
+    alt: altReaderTaskValidation.alt,
+    fromIO,
+    fromTask,
+    throwError
+  };
+}
+function run(ma, r) {
+  return ma(r)();
+}
+exports.Alt = Alt;
+exports.ApT = ApT;
+exports.ApplicativePar = ApplicativePar;
+exports.ApplicativeSeq = ApplicativeSeq;
+exports.ApplyPar = ApplyPar;
+exports.ApplySeq = ApplySeq;
+exports.Bifunctor = Bifunctor;
+exports.Chain = Chain;
+exports.Do = Do;
+exports.FromEither = FromEither;
+exports.FromIO = FromIO;
+exports.FromReader = FromReader;
+exports.FromTask = FromTask;
+exports.Functor = Functor;
+exports.Monad = Monad;
+exports.MonadIO = MonadIO;
+exports.MonadTask = MonadTask;
+exports.MonadThrow = MonadThrow;
+exports.Pointed = Pointed;
+exports.URI = URI;
+exports.alt = alt;
+exports.altW = altW;
+exports.ap = ap;
+exports.apFirst = apFirst;
+exports.apFirstW = apFirstW;
+exports.apS = apS;
+exports.apSW = apSW;
+exports.apSecond = apSecond;
+exports.apSecondW = apSecondW;
+exports.apW = apW;
+exports.as = as;
+exports.asUnit = asUnit;
+exports.ask = ask;
+exports.asks = asks;
+exports.asksReaderTaskEither = asksReaderTaskEither;
+exports.asksReaderTaskEitherW = asksReaderTaskEitherW;
+exports.bimap = bimap;
+exports.bind = bind;
+exports.bindTo = bindTo;
+exports.bindW = bindW;
+exports.bracket = bracket;
+exports.bracketW = bracketW;
+exports.chain = chain;
+exports.chainEitherK = chainEitherK;
+exports.chainEitherKW = chainEitherKW;
+exports.chainFirst = chainFirst;
+exports.chainFirstEitherK = chainFirstEitherK;
+exports.chainFirstEitherKW = chainFirstEitherKW;
+exports.chainFirstIOK = chainFirstIOK;
+exports.chainFirstReaderEitherK = chainFirstReaderEitherK;
+exports.chainFirstReaderEitherKW = chainFirstReaderEitherKW;
+exports.chainFirstReaderIOK = chainFirstReaderIOK;
+exports.chainFirstReaderIOKW = chainFirstReaderIOKW;
+exports.chainFirstReaderK = chainFirstReaderK;
+exports.chainFirstReaderKW = chainFirstReaderKW;
+exports.chainFirstReaderTaskK = chainFirstReaderTaskK;
+exports.chainFirstReaderTaskKW = chainFirstReaderTaskKW;
+exports.chainFirstTaskEitherK = chainFirstTaskEitherK;
+exports.chainFirstTaskEitherKW = chainFirstTaskEitherKW;
+exports.chainFirstTaskK = chainFirstTaskK;
+exports.chainFirstW = chainFirstW;
+exports.chainIOEitherK = chainIOEitherK;
+exports.chainIOEitherKW = chainIOEitherKW;
+exports.chainIOK = chainIOK;
+exports.chainNullableK = chainNullableK;
+exports.chainOptionK = chainOptionK;
+exports.chainOptionKW = chainOptionKW;
+exports.chainReaderEitherK = chainReaderEitherK;
+exports.chainReaderEitherKW = chainReaderEitherKW;
+exports.chainReaderIOK = chainReaderIOK;
+exports.chainReaderIOKW = chainReaderIOKW;
+exports.chainReaderK = chainReaderK;
+exports.chainReaderKW = chainReaderKW;
+exports.chainReaderTaskK = chainReaderTaskK;
+exports.chainReaderTaskKW = chainReaderTaskKW;
+exports.chainTaskEitherK = chainTaskEitherK;
+exports.chainTaskEitherKW = chainTaskEitherKW;
+exports.chainTaskK = chainTaskK;
+exports.chainW = chainW;
+exports.filterOrElse = filterOrElse;
+exports.filterOrElseW = filterOrElseW;
+exports.flap = flap;
+exports.flatMap = flatMap;
+exports.flatMapEither = flatMapEither;
+exports.flatMapIO = flatMapIO;
+exports.flatMapIOEither = flatMapIOEither;
+exports.flatMapNullable = flatMapNullable;
+exports.flatMapOption = flatMapOption;
+exports.flatMapReader = flatMapReader;
+exports.flatMapReaderEither = flatMapReaderEither;
+exports.flatMapReaderIO = flatMapReaderIO;
+exports.flatMapReaderTask = flatMapReaderTask;
+exports.flatMapTask = flatMapTask;
+exports.flatMapTaskEither = flatMapTaskEither;
+exports.flatten = flatten;
+exports.flattenW = flattenW;
+exports.fold = fold;
+exports.foldW = foldW;
+exports.fromEither = fromEither;
+exports.fromEitherK = fromEitherK;
+exports.fromIO = fromIO;
+exports.fromIOEither = fromIOEither;
+exports.fromIOEitherK = fromIOEitherK;
+exports.fromIOK = fromIOK;
+exports.fromNullable = fromNullable;
+exports.fromNullableK = fromNullableK;
+exports.fromOption = fromOption;
+exports.fromOptionK = fromOptionK;
+exports.fromPredicate = fromPredicate;
+exports.fromReader = fromReader;
+exports.fromReaderEither = fromReaderEither;
+exports.fromReaderEitherK = fromReaderEitherK;
+exports.fromReaderIOK = fromReaderIOK;
+exports.fromReaderK = fromReaderK;
+exports.fromReaderTaskK = fromReaderTaskK;
+exports.fromTask = fromTask;
+exports.fromTaskEither = fromTaskEither;
+exports.fromTaskEitherK = fromTaskEitherK;
+exports.fromTaskK = fromTaskK;
+exports.getAltReaderTaskValidation = getAltReaderTaskValidation;
+exports.getApplicativeReaderTaskValidation = getApplicativeReaderTaskValidation;
+exports.getApplyMonoid = getApplyMonoid;
+exports.getApplySemigroup = getApplySemigroup;
+exports.getCompactable = getCompactable;
+exports.getFilterable = getFilterable;
+exports.getOrElse = getOrElse;
+exports.getOrElseW = getOrElseW;
+exports.getReaderTaskValidation = getReaderTaskValidation;
+exports.getSemigroup = getSemigroup;
+exports.left = left;
+exports.leftIO = leftIO;
+exports.leftReader = leftReader;
+exports.leftReaderIO = leftReaderIO;
+exports.leftReaderTask = leftReaderTask;
+exports.leftTask = leftTask;
+exports.let = let_;
+exports.liftNullable = liftNullable;
+exports.liftOption = liftOption;
+exports.local = local;
+exports.map = map;
+exports.mapBoth = mapBoth;
+exports.mapError = mapError;
+exports.mapLeft = mapLeft;
+exports.match = match;
+exports.matchE = matchE;
+exports.matchEW = matchEW;
+exports.matchW = matchW;
+exports.of = of;
+exports.orElse = orElse;
+exports.orElseFirst = orElseFirst;
+exports.orElseFirstW = orElseFirstW;
+exports.orElseW = orElseW;
+exports.orLeft = orLeft;
+exports.readerTaskEither = readerTaskEither;
+exports.readerTaskEitherSeq = readerTaskEitherSeq;
+exports.right = right;
+exports.rightIO = rightIO;
+exports.rightReader = rightReader;
+exports.rightReaderIO = rightReaderIO;
+exports.rightReaderTask = rightReaderTask;
+exports.rightTask = rightTask;
+exports.run = run;
+exports.sequenceArray = sequenceArray;
+exports.sequenceSeqArray = sequenceSeqArray;
+exports.swap = swap;
+exports.tap = tap;
+exports.tapEither = tapEither;
+exports.tapError = tapError;
+exports.tapIO = tapIO;
+exports.tapReader = tapReader;
+exports.tapReaderEither = tapReaderEither;
+exports.tapReaderIO = tapReaderIO;
+exports.tapReaderTask = tapReaderTask;
+exports.tapTask = tapTask;
+exports.tapTaskEither = tapTaskEither;
+exports.throwError = throwError;
+exports.toUnion = toUnion;
+exports.traverseArray = traverseArray;
+exports.traverseArrayWithIndex = traverseArrayWithIndex;
+exports.traverseReadonlyArrayWithIndex = traverseReadonlyArrayWithIndex;
+exports.traverseReadonlyArrayWithIndexSeq = traverseReadonlyArrayWithIndexSeq;
+exports.traverseReadonlyNonEmptyArrayWithIndex = traverseReadonlyNonEmptyArrayWithIndex;
+exports.traverseReadonlyNonEmptyArrayWithIndexSeq = traverseReadonlyNonEmptyArrayWithIndexSeq;
+exports.traverseSeqArray = traverseSeqArray;
+exports.traverseSeqArrayWithIndex = traverseSeqArrayWithIndex;
+//# sourceMappingURL=ReaderTaskEither.cjs.map