@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/TaskEither.cjs

@@ -0,0 +1,725 @@
+"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 FromTask$1 = require("./FromTask.cjs");
+const _function = require("./function.cjs");
+const Functor$1 = require("./Functor.cjs");
+const internal = require("./internal.cjs");
+const Task = require("./Task.cjs");
+var __awaiter = globalThis && globalThis.__awaiter || function(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+var __generator = globalThis && globalThis.__generator || function(thisArg, body) {
+  var _ = { label: 0, sent: function() {
+    if (t[0] & 1)
+      throw t[1];
+    return t[1];
+  }, trys: [], ops: [] }, f, y, t, g;
+  return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+    return this;
+  }), g;
+  function verb(n) {
+    return function(v) {
+      return step([n, v]);
+    };
+  }
+  function step(op) {
+    if (f)
+      throw new TypeError("Generator is already executing.");
+    while (g && (g = 0, op[0] && (_ = 0)), _)
+      try {
+        if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
+          return t;
+        if (y = 0, t)
+          op = [op[0] & 2, t.value];
+        switch (op[0]) {
+          case 0:
+          case 1:
+            t = op;
+            break;
+          case 4:
+            _.label++;
+            return { value: op[1], done: false };
+          case 5:
+            _.label++;
+            y = op[1];
+            op = [0];
+            continue;
+          case 7:
+            op = _.ops.pop();
+            _.trys.pop();
+            continue;
+          default:
+            if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+              _ = 0;
+              continue;
+            }
+            if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+              _.label = op[1];
+              break;
+            }
+            if (op[0] === 6 && _.label < t[1]) {
+              _.label = t[1];
+              t = op;
+              break;
+            }
+            if (t && _.label < t[2]) {
+              _.label = t[2];
+              _.ops.push(op);
+              break;
+            }
+            if (t[2])
+              _.ops.pop();
+            _.trys.pop();
+            continue;
+        }
+        op = body.call(thisArg, _);
+      } catch (e) {
+        op = [6, e];
+        y = 0;
+      } finally {
+        f = t = 0;
+      }
+    if (op[0] & 5)
+      throw op[1];
+    return { value: op[0] ? op[1] : void 0, done: true };
+  }
+};
+var left = /* @__PURE__ */ EitherT.left(Task.Pointed);
+var right = /* @__PURE__ */ EitherT.right(Task.Pointed);
+var rightTask = /* @__PURE__ */ EitherT.rightF(Task.Functor);
+var leftTask = /* @__PURE__ */ EitherT.leftF(Task.Functor);
+var rightIO = /* @__PURE__ */ _function.flow(Task.fromIO, rightTask);
+var leftIO = /* @__PURE__ */ _function.flow(Task.fromIO, leftTask);
+var fromIO = rightIO;
+var fromTask = rightTask;
+var fromEither = Task.of;
+var fromIOEither = Task.fromIO;
+var fromTaskOption = function(onNone) {
+  return Task.map(Either.fromOption(onNone));
+};
+var match = /* @__PURE__ */ EitherT.match(Task.Functor);
+var matchW = match;
+var matchE = /* @__PURE__ */ EitherT.matchE(Task.Monad);
+var fold = matchE;
+var matchEW = matchE;
+var foldW = matchEW;
+var getOrElse = /* @__PURE__ */ EitherT.getOrElse(Task.Monad);
+var getOrElseW = getOrElse;
+var tryCatch = function(f, onRejected) {
+  return function() {
+    return __awaiter(void 0, void 0, void 0, function() {
+      var reason_1;
+      return __generator(this, function(_a) {
+        switch (_a.label) {
+          case 0:
+            _a.trys.push([0, 2, , 3]);
+            return [4, f().then(internal.right)];
+          case 1:
+            return [2, _a.sent()];
+          case 2:
+            reason_1 = _a.sent();
+            return [2, internal.left(onRejected(reason_1))];
+          case 3:
+            return [
+              2
+              /*return*/
+            ];
+        }
+      });
+    });
+  };
+};
+var tryCatchK = function(f, onRejected) {
+  return function() {
+    var a = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+      a[_i] = arguments[_i];
+    }
+    return tryCatch(function() {
+      return f.apply(void 0, a);
+    }, onRejected);
+  };
+};
+var toUnion = /* @__PURE__ */ EitherT.toUnion(Task.Functor);
+var fromNullable = /* @__PURE__ */ EitherT.fromNullable(Task.Pointed);
+var fromNullableK = /* @__PURE__ */ EitherT.fromNullableK(Task.Pointed);
+var chainNullableK = /* @__PURE__ */ EitherT.chainNullableK(Task.Monad);
+var orElse = /* @__PURE__ */ EitherT.orElse(Task.Monad);
+var orElseW = orElse;
+var tapError = /* @__PURE__ */ _function.dual(2, EitherT.tapError(Task.Monad));
+var orElseFirstIOK = function(onLeft) {
+  return tapError(fromIOK(onLeft));
+};
+var orElseFirstTaskK = function(onLeft) {
+  return tapError(fromTaskK(onLeft));
+};
+var orLeft = /* @__PURE__ */ EitherT.orLeft(Task.Monad);
+var swap = /* @__PURE__ */ EitherT.swap(Task.Functor);
+var fromTaskOptionK = function(onNone) {
+  var from = fromTaskOption(onNone);
+  return function(f) {
+    return _function.flow(f, from);
+  };
+};
+var chainTaskOptionKW = function(onNone) {
+  return function(f) {
+    return function(ma) {
+      return flatMap(ma, fromTaskOptionK(onNone)(f));
+    };
+  };
+};
+var chainTaskOptionK = chainTaskOptionKW;
+var fromIOEitherK = function(f) {
+  return _function.flow(f, fromIOEither);
+};
+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(Task.Functor);
+var mapBoth = /* @__PURE__ */ _function.dual(3, EitherT.mapBoth(Task.Functor));
+var bimap = mapBoth;
+var mapError = /* @__PURE__ */ _function.dual(2, EitherT.mapError(Task.Functor));
+var mapLeft = mapError;
+var ap = /* @__PURE__ */ EitherT.ap(Task.ApplyPar);
+var apW = ap;
+var flatMap = /* @__PURE__ */ _function.dual(2, EitherT.flatMap(Task.Monad));
+var flattenW = /* @__PURE__ */ flatMap(_function.identity);
+var flatten = flattenW;
+var alt = /* @__PURE__ */ EitherT.alt(Task.Monad);
+var altW = alt;
+var of = right;
+var throwError = left;
+var URI = "TaskEither";
+function getApplicativeTaskValidation(A, S) {
+  var ap2 = Apply.ap(A, Either.getApplicativeValidation(S));
+  return {
+    URI,
+    _E: void 0,
+    map: _map,
+    ap: function(fab, fa) {
+      return _function.pipe(fab, ap2(fa));
+    },
+    of
+  };
+}
+function getAltTaskValidation(S) {
+  var alt2 = EitherT.altValidation(Task.Monad, S);
+  return {
+    URI,
+    _E: void 0,
+    map: _map,
+    alt: function(fa, that) {
+      return _function.pipe(fa, alt2(that));
+    }
+  };
+}
+var getCompactable = function(M) {
+  var C = Either.getCompactable(M);
+  return {
+    URI,
+    _E: void 0,
+    compact: Compactable.compact(Task.Functor, C),
+    separate: Compactable.separate(Task.Functor, C, Either.Functor)
+  };
+};
+function getFilterable(M) {
+  var F = Either.getFilterable(M);
+  var C = getCompactable(M);
+  var filter = Filterable.filter(Task.Functor, F);
+  var filterMap = Filterable.filterMap(Task.Functor, F);
+  var partition = Filterable.partition(Task.Functor, F);
+  var partitionMap = Filterable.partitionMap(Task.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));
+    }
+  };
+}
+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 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 Bifunctor = {
+  URI,
+  bimap: mapBoth,
+  mapLeft: mapError
+};
+var Alt = {
+  URI,
+  map: _map,
+  alt: _alt
+};
+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: FromIO.fromIO
+};
+var _FromTask = {
+  fromTask
+};
+var flatMapNullable = /* @__PURE__ */ internal.flatMapNullable(_FromEither, _FlatMap);
+var flatMapOption = /* @__PURE__ */ internal.flatMapOption(_FromEither, _FlatMap);
+var flatMapEither = /* @__PURE__ */ internal.flatMapEither(_FromEither, _FlatMap);
+var flatMapIO = /* @__PURE__ */ internal.flatMapIO(_FromIO, _FlatMap);
+var flatMapTask = /* @__PURE__ */ internal.flatMapTask(_FromTask, _FlatMap);
+var flatMapIOEither = /* @__PURE__ */ _function.dual(2, function(self, f) {
+  return flatMap(self, fromIOEitherK(f));
+});
+var flatMapTaskOption = /* @__PURE__ */ _function.dual(3, function(self, f, onNone) {
+  return flatMap(self, function(a) {
+    return fromTaskOption(function() {
+      return onNone(a);
+    })(f(a));
+  });
+});
+var chainEitherK = flatMapEither;
+var chainEitherKW = flatMapEither;
+var chainFirstEitherK = tapEither;
+var chainFirstEitherKW = tapEither;
+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 chainIOEitherKW = flatMapIOEither;
+var chainIOEitherK = flatMapIOEither;
+function taskify(f) {
+  return function() {
+    var args = Array.prototype.slice.call(arguments);
+    return function() {
+      return new Promise(function(resolve) {
+        var cbResolver = function(e, r) {
+          return e != null ? resolve(internal.left(e)) : resolve(internal.right(r));
+        };
+        f.apply(null, args.concat(cbResolver));
+      });
+    };
+  };
+}
+var bracket = function(acquire, use, release) {
+  return bracketW(acquire, use, release);
+};
+var bracketW = function(acquire, use, release) {
+  return flatMap(acquire, function(a) {
+    return Task.flatMap(use(a), function(e) {
+      return flatMap(release(a, e), function() {
+        return Task.of(e);
+      });
+    });
+  });
+};
+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(Task.traverseReadonlyNonEmptyArrayWithIndex(f), Task.map(Either.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(as2) {
+    return function() {
+      return internal.tail(as2).reduce(function(acc, a, i) {
+        return acc.then(function(ebs) {
+          return internal.isLeft(ebs) ? acc : f(i + 1, a)().then(function(eb) {
+            if (internal.isLeft(eb)) {
+              return eb;
+            }
+            ebs.right.push(eb.right);
+            return ebs;
+          });
+        });
+      }, f(0, internal.head(as2))().then(Either.map(internal.singleton)));
+    };
+  };
+};
+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 taskEither = {
+  URI,
+  bimap: mapBoth,
+  mapLeft: mapError,
+  map: _map,
+  of,
+  ap: _apPar,
+  chain: flatMap,
+  alt: _alt,
+  fromIO,
+  fromTask,
+  throwError
+};
+var taskEitherSeq = {
+  URI,
+  bimap: mapBoth,
+  mapLeft: mapError,
+  map: _map,
+  of,
+  ap: _apSeq,
+  chain: flatMap,
+  alt: _alt,
+  fromIO,
+  fromTask,
+  throwError
+};
+var getApplySemigroup = /* @__PURE__ */ Apply.getApplySemigroup(ApplySeq);
+var getApplyMonoid = /* @__PURE__ */ Applicative.getApplicativeMonoid(ApplicativeSeq);
+var getSemigroup = function(S) {
+  return Apply.getApplySemigroup(Task.ApplySeq)(Either.getSemigroup(S));
+};
+function getTaskValidation(SE) {
+  var applicativeTaskValidation = getApplicativeTaskValidation(Task.ApplicativePar, SE);
+  var altTaskValidation = getAltTaskValidation(SE);
+  return {
+    URI,
+    _E: void 0,
+    map: _map,
+    ap: applicativeTaskValidation.ap,
+    of,
+    chain: flatMap,
+    bimap: mapBoth,
+    mapLeft: mapError,
+    alt: altTaskValidation.alt,
+    fromIO,
+    fromTask,
+    throwError
+  };
+}
+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.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.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.chainFirstTaskK = chainFirstTaskK;
+exports.chainFirstW = chainFirstW;
+exports.chainIOEitherK = chainIOEitherK;
+exports.chainIOEitherKW = chainIOEitherKW;
+exports.chainIOK = chainIOK;
+exports.chainNullableK = chainNullableK;
+exports.chainOptionK = chainOptionK;
+exports.chainOptionKW = chainOptionKW;
+exports.chainTaskK = chainTaskK;
+exports.chainTaskOptionK = chainTaskOptionK;
+exports.chainTaskOptionKW = chainTaskOptionKW;
+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.flatMapTask = flatMapTask;
+exports.flatMapTaskOption = flatMapTaskOption;
+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.fromTask = fromTask;
+exports.fromTaskK = fromTaskK;
+exports.fromTaskOption = fromTaskOption;
+exports.fromTaskOptionK = fromTaskOptionK;
+exports.getAltTaskValidation = getAltTaskValidation;
+exports.getApplicativeTaskValidation = getApplicativeTaskValidation;
+exports.getApplyMonoid = getApplyMonoid;
+exports.getApplySemigroup = getApplySemigroup;
+exports.getCompactable = getCompactable;
+exports.getFilterable = getFilterable;
+exports.getOrElse = getOrElse;
+exports.getOrElseW = getOrElseW;
+exports.getSemigroup = getSemigroup;
+exports.getTaskValidation = getTaskValidation;
+exports.left = left;
+exports.leftIO = leftIO;
+exports.leftTask = leftTask;
+exports.let = let_;
+exports.liftNullable = liftNullable;
+exports.liftOption = liftOption;
+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.orElseFirstIOK = orElseFirstIOK;
+exports.orElseFirstTaskK = orElseFirstTaskK;
+exports.orElseFirstW = orElseFirstW;
+exports.orElseW = orElseW;
+exports.orLeft = orLeft;
+exports.right = right;
+exports.rightIO = rightIO;
+exports.rightTask = rightTask;
+exports.sequenceArray = sequenceArray;
+exports.sequenceSeqArray = sequenceSeqArray;
+exports.swap = swap;
+exports.tap = tap;
+exports.tapEither = tapEither;
+exports.tapError = tapError;
+exports.tapIO = tapIO;
+exports.tapTask = tapTask;
+exports.taskEither = taskEither;
+exports.taskEitherSeq = taskEitherSeq;
+exports.taskify = taskify;
+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;
+exports.tryCatch = tryCatch;
+exports.tryCatchK = tryCatchK;
+//# sourceMappingURL=TaskEither.cjs.map