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

package/dist/_node_modules/fp-ts/es6/IOEither.js

@@ -0,0 +1,482 @@
+import { getApplicativeMonoid } from "./Applicative.js";
+import { apFirst as apFirst$1, apSecond as apSecond$1, apS as apS$1, getApplySemigroup as getApplySemigroup$1, ap as ap$2 } from "./Apply.js";
+import { tap as tap$1, bind as bind$1 } from "./Chain.js";
+import { compact, separate } from "./Compactable.js";
+import { tryCatch as tryCatch$1, getCompactable as getCompactable$1, getFilterable as getFilterable$1, getSemigroup as getSemigroup$1, getApplicativeValidation, Functor as Functor$2, traverseReadonlyNonEmptyArrayWithIndex as traverseReadonlyNonEmptyArrayWithIndex$2 } from "./Either.js";
+import { left as left$1, right as right$1, rightF, leftF, match as match$1, matchE as matchE$1, getOrElse as getOrElse$1, toUnion as toUnion$1, orElse as orElse$1, tapError as tapError$1, orLeft as orLeft$1, swap as swap$1, map as map$1, mapBoth as mapBoth$1, mapError as mapError$1, ap as ap$1, flatMap as flatMap$1, alt as alt$1, altValidation } from "./EitherT.js";
+import { filter, filterMap, partition, partitionMap } from "./Filterable.js";
+import { tapEither as tapEither$1, fromOption as fromOption$1, fromOptionK as fromOptionK$1, chainOptionK as chainOptionK$1, fromPredicate as fromPredicate$1, filterOrElse as filterOrElse$1, fromEitherK as fromEitherK$1 } from "./FromEither.js";
+import { tapIO as tapIO$1, fromIOK as fromIOK$1 } from "./FromIO.js";
+import { dual, identity, pipe, flow, SK } from "./function.js";
+import { as as as$1, asUnit as asUnit$1, flap as flap$1, bindTo as bindTo$1, let as let_$1 } from "./Functor.js";
+import { liftNullable as liftNullable$1, liftOption as liftOption$1, flatMapNullable as flatMapNullable$1, flatMapOption as flatMapOption$1, flatMapEither as flatMapEither$1, flatMapIO as flatMapIO$1, emptyRecord, emptyReadonlyArray, isNonEmpty, head, isLeft, right as right$2 } from "./internal.js";
+import { Pointed as Pointed$1, Functor as Functor$1, of as of$1, Monad as Monad$1, Apply, flatMap as flatMap$2, map as map$2, traverseReadonlyNonEmptyArrayWithIndex as traverseReadonlyNonEmptyArrayWithIndex$1 } from "./IO.js";
+var left = /* @__PURE__ */ left$1(Pointed$1);
+var right = /* @__PURE__ */ right$1(Pointed$1);
+var rightIO = /* @__PURE__ */ rightF(Functor$1);
+var leftIO = /* @__PURE__ */ leftF(Functor$1);
+var fromEither = of$1;
+var fromIO = rightIO;
+var match = /* @__PURE__ */ match$1(Functor$1);
+var matchW = match;
+var matchE = /* @__PURE__ */ matchE$1(Monad$1);
+var fold = matchE;
+var matchEW = matchE;
+var foldW = matchEW;
+var getOrElse = /* @__PURE__ */ getOrElse$1(Monad$1);
+var getOrElseW = getOrElse;
+var tryCatch = function(f, onThrow) {
+  return function() {
+    return tryCatch$1(f, onThrow);
+  };
+};
+var tryCatchK = function(f, onThrow) {
+  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);
+    }, onThrow);
+  };
+};
+var toUnion = /* @__PURE__ */ toUnion$1(Functor$1);
+var orElse = /* @__PURE__ */ orElse$1(Monad$1);
+var orElseW = orElse;
+var tapError = /* @__PURE__ */ dual(2, tapError$1(Monad$1));
+var orElseFirstIOK = function(onLeft) {
+  return tapError(fromIOK(onLeft));
+};
+var orLeft = /* @__PURE__ */ orLeft$1(Monad$1);
+var swap = /* @__PURE__ */ swap$1(Functor$1);
+var _map = function(fa, f) {
+  return pipe(fa, map(f));
+};
+var _ap = function(fab, fa) {
+  return pipe(fab, ap(fa));
+};
+var _apSeq = function(fab, fa) {
+  return flatMap(fab, function(f) {
+    return pipe(fa, map(f));
+  });
+};
+var _alt = function(fa, that) {
+  return pipe(fa, alt(that));
+};
+var map = /* @__PURE__ */ map$1(Functor$1);
+var mapBoth = /* @__PURE__ */ dual(3, mapBoth$1(Functor$1));
+var bimap = mapBoth;
+var mapError = /* @__PURE__ */ dual(2, mapError$1(Functor$1));
+var mapLeft = mapError;
+var ap = /* @__PURE__ */ ap$1(Apply);
+var apW = ap;
+var of = right;
+var flatMap = /* @__PURE__ */ dual(2, flatMap$1(Monad$1));
+var flattenW = /* @__PURE__ */ flatMap(identity);
+var flatten = flattenW;
+var alt = /* @__PURE__ */ alt$1(Monad$1);
+var altW = alt;
+var throwError = left;
+var URI = "IOEither";
+function getApplicativeIOValidation(S) {
+  var ap2 = ap$2(Apply, getApplicativeValidation(S));
+  return {
+    URI,
+    _E: void 0,
+    map: _map,
+    ap: function(fab, fa) {
+      return pipe(fab, ap2(fa));
+    },
+    of
+  };
+}
+function getAltIOValidation(S) {
+  var alt2 = altValidation(Monad$1, S);
+  return {
+    URI,
+    _E: void 0,
+    map: _map,
+    alt: function(fa, that) {
+      return pipe(fa, alt2(that));
+    }
+  };
+}
+var getCompactable = function(M) {
+  var C = getCompactable$1(M);
+  return {
+    URI,
+    _E: void 0,
+    compact: compact(Functor$1, C),
+    separate: separate(Functor$1, C, Functor$2)
+  };
+};
+function getFilterable(M) {
+  var F = getFilterable$1(M);
+  var C = getCompactable(M);
+  var filter$1 = filter(Functor$1, F);
+  var filterMap$1 = filterMap(Functor$1, F);
+  var partition$1 = partition(Functor$1, F);
+  var partitionMap$1 = partitionMap(Functor$1, F);
+  return {
+    URI,
+    _E: void 0,
+    map: _map,
+    compact: C.compact,
+    separate: C.separate,
+    filter: function(fa, predicate) {
+      return pipe(fa, filter$1(predicate));
+    },
+    filterMap: function(fa, f) {
+      return pipe(fa, filterMap$1(f));
+    },
+    partition: function(fa, predicate) {
+      return pipe(fa, partition$1(predicate));
+    },
+    partitionMap: function(fa, f) {
+      return pipe(fa, partitionMap$1(f));
+    }
+  };
+}
+var Functor = {
+  URI,
+  map: _map
+};
+var as = dual(2, as$1(Functor));
+var asUnit = asUnit$1(Functor);
+var flap = /* @__PURE__ */ flap$1(Functor);
+var Pointed = {
+  URI,
+  of
+};
+var Bifunctor = {
+  URI,
+  bimap: mapBoth,
+  mapLeft: mapError
+};
+var ApplyPar = {
+  URI,
+  map: _map,
+  ap: _ap
+};
+var apFirst = /* @__PURE__ */ apFirst$1(ApplyPar);
+var apFirstW = apFirst;
+var apSecond = /* @__PURE__ */ apSecond$1(ApplyPar);
+var apSecondW = apSecond;
+var ApplicativePar = {
+  URI,
+  map: _map,
+  ap: _ap,
+  of
+};
+var ApplicativeSeq = {
+  URI,
+  map: _map,
+  ap: _apSeq,
+  of
+};
+var Chain = {
+  URI,
+  map: _map,
+  ap: _ap,
+  chain: flatMap
+};
+var Monad = {
+  URI,
+  map: _map,
+  ap: _ap,
+  of,
+  chain: flatMap
+};
+var FromEither = {
+  URI,
+  fromEither
+};
+var FromIO = {
+  URI,
+  fromIO
+};
+var tap = /* @__PURE__ */ dual(2, tap$1(Chain));
+var tapEither = /* @__PURE__ */ dual(2, tapEither$1(FromEither, Chain));
+var tapIO = /* @__PURE__ */ dual(2, tapIO$1(FromIO, Chain));
+var Alt = {
+  URI,
+  map: _map,
+  alt: _alt
+};
+var MonadIO = {
+  URI,
+  map: _map,
+  ap: _ap,
+  of,
+  chain: flatMap,
+  fromIO
+};
+var MonadThrow = {
+  URI,
+  map: _map,
+  ap: _ap,
+  of,
+  chain: flatMap,
+  throwError
+};
+var fromIOK = /* @__PURE__ */ fromIOK$1(FromIO);
+var chainFirstIOK = tapIO;
+var fromOption = /* @__PURE__ */ fromOption$1(FromEither);
+var fromOptionK = /* @__PURE__ */ fromOptionK$1(FromEither);
+var chainOptionK = /* @__PURE__ */ chainOptionK$1(FromEither, Chain);
+var chainOptionKW = chainOptionK;
+var _FromEither = {
+  fromEither: FromEither.fromEither
+};
+var _FromIO = {
+  fromIO
+};
+var liftNullable = /* @__PURE__ */ liftNullable$1(_FromEither);
+var liftOption = /* @__PURE__ */ liftOption$1(_FromEither);
+var _FlatMap = {
+  flatMap
+};
+var flatMapNullable = /* @__PURE__ */ flatMapNullable$1(_FromEither, _FlatMap);
+var flatMapOption = /* @__PURE__ */ flatMapOption$1(_FromEither, _FlatMap);
+var flatMapEither = /* @__PURE__ */ flatMapEither$1(_FromEither, _FlatMap);
+var flatMapIO = /* @__PURE__ */ flatMapIO$1(_FromIO, _FlatMap);
+var chainIOK = flatMapIO;
+var chainEitherK = flatMapEither;
+var chainEitherKW = flatMapEither;
+var chainFirstEitherK = tapEither;
+var chainFirstEitherKW = tapEither;
+var fromPredicate = /* @__PURE__ */ fromPredicate$1(FromEither);
+var filterOrElse = /* @__PURE__ */ filterOrElse$1(FromEither, Chain);
+var filterOrElseW = filterOrElse;
+var fromEitherK = /* @__PURE__ */ fromEitherK$1(FromEither);
+var bracket = function(acquire, use, release) {
+  return bracketW(acquire, use, release);
+};
+var bracketW = function(acquire, use, release) {
+  return flatMap(acquire, function(a) {
+    return flatMap$2(use(a), function(e) {
+      return flatMap(release(a, e), function() {
+        return of$1(e);
+      });
+    });
+  });
+};
+var Do = /* @__PURE__ */ of(emptyRecord);
+var bindTo = /* @__PURE__ */ bindTo$1(Functor);
+var let_ = /* @__PURE__ */ let_$1(Functor);
+var bind = /* @__PURE__ */ bind$1(Chain);
+var bindW = bind;
+var apS = /* @__PURE__ */ apS$1(ApplyPar);
+var apSW = apS;
+var ApT = /* @__PURE__ */ of(emptyReadonlyArray);
+var traverseReadonlyNonEmptyArrayWithIndex = function(f) {
+  return flow(traverseReadonlyNonEmptyArrayWithIndex$1(f), map$2(traverseReadonlyNonEmptyArrayWithIndex$2(SK)));
+};
+var traverseReadonlyArrayWithIndex = function(f) {
+  var g = traverseReadonlyNonEmptyArrayWithIndex(f);
+  return function(as2) {
+    return isNonEmpty(as2) ? g(as2) : ApT;
+  };
+};
+var traverseReadonlyNonEmptyArrayWithIndexSeq = function(f) {
+  return function(as2) {
+    return function() {
+      var e = f(0, head(as2))();
+      if (isLeft(e)) {
+        return e;
+      }
+      var out = [e.right];
+      for (var i = 1; i < as2.length; i++) {
+        var e_1 = f(i, as2[i])();
+        if (isLeft(e_1)) {
+          return e_1;
+        }
+        out.push(e_1.right);
+      }
+      return right$2(out);
+    };
+  };
+};
+var traverseReadonlyArrayWithIndexSeq = function(f) {
+  var g = traverseReadonlyNonEmptyArrayWithIndexSeq(f);
+  return function(as2) {
+    return isNonEmpty(as2) ? g(as2) : ApT;
+  };
+};
+var traverseArrayWithIndex = traverseReadonlyArrayWithIndex;
+var traverseArray = function(f) {
+  return traverseReadonlyArrayWithIndex(function(_, a) {
+    return f(a);
+  });
+};
+var sequenceArray = /* @__PURE__ */ traverseArray(identity);
+var traverseSeqArrayWithIndex = traverseReadonlyArrayWithIndexSeq;
+var traverseSeqArray = function(f) {
+  return traverseReadonlyArrayWithIndexSeq(function(_, a) {
+    return f(a);
+  });
+};
+var sequenceSeqArray = /* @__PURE__ */ traverseSeqArray(identity);
+var Applicative = ApplicativePar;
+var chain = flatMap;
+var chainW = flatMap;
+var chainFirst = tap;
+var chainFirstW = tap;
+var orElseFirst = tapError;
+var orElseFirstW = tapError;
+var ioEither = {
+  URI,
+  bimap: mapBoth,
+  mapLeft: mapError,
+  map: _map,
+  of,
+  ap: _ap,
+  chain: flatMap,
+  alt: _alt,
+  fromIO,
+  throwError
+};
+var getApplySemigroup = /* @__PURE__ */ getApplySemigroup$1(ApplyPar);
+var getApplyMonoid = /* @__PURE__ */ getApplicativeMonoid(ApplicativePar);
+var getSemigroup = function(S) {
+  return getApplySemigroup$1(Apply)(getSemigroup$1(S));
+};
+function getIOValidation(SE) {
+  var applicativeIOValidation = getApplicativeIOValidation(SE);
+  var altIOValidation = getAltIOValidation(SE);
+  return {
+    URI,
+    _E: void 0,
+    map: _map,
+    ap: applicativeIOValidation.ap,
+    of,
+    chain: flatMap,
+    bimap: mapBoth,
+    mapLeft: mapError,
+    alt: altIOValidation.alt,
+    fromIO,
+    throwError
+  };
+}
+export {
+  Alt,
+  ApT,
+  Applicative,
+  ApplicativePar,
+  ApplicativeSeq,
+  ApplyPar,
+  Bifunctor,
+  Chain,
+  Do,
+  FromEither,
+  FromIO,
+  Functor,
+  Monad,
+  MonadIO,
+  MonadThrow,
+  Pointed,
+  URI,
+  alt,
+  altW,
+  ap,
+  apFirst,
+  apFirstW,
+  apS,
+  apSW,
+  apSecond,
+  apSecondW,
+  apW,
+  as,
+  asUnit,
+  bimap,
+  bind,
+  bindTo,
+  bindW,
+  bracket,
+  bracketW,
+  chain,
+  chainEitherK,
+  chainEitherKW,
+  chainFirst,
+  chainFirstEitherK,
+  chainFirstEitherKW,
+  chainFirstIOK,
+  chainFirstW,
+  chainIOK,
+  chainOptionK,
+  chainOptionKW,
+  chainW,
+  filterOrElse,
+  filterOrElseW,
+  flap,
+  flatMap,
+  flatMapEither,
+  flatMapIO,
+  flatMapNullable,
+  flatMapOption,
+  flatten,
+  flattenW,
+  fold,
+  foldW,
+  fromEither,
+  fromEitherK,
+  fromIO,
+  fromIOK,
+  fromOption,
+  fromOptionK,
+  fromPredicate,
+  getAltIOValidation,
+  getApplicativeIOValidation,
+  getApplyMonoid,
+  getApplySemigroup,
+  getCompactable,
+  getFilterable,
+  getIOValidation,
+  getOrElse,
+  getOrElseW,
+  getSemigroup,
+  ioEither,
+  left,
+  leftIO,
+  let_ as let,
+  liftNullable,
+  liftOption,
+  map,
+  mapBoth,
+  mapError,
+  mapLeft,
+  match,
+  matchE,
+  matchEW,
+  matchW,
+  of,
+  orElse,
+  orElseFirst,
+  orElseFirstIOK,
+  orElseFirstW,
+  orElseW,
+  orLeft,
+  right,
+  rightIO,
+  sequenceArray,
+  sequenceSeqArray,
+  swap,
+  tap,
+  tapEither,
+  tapError,
+  tapIO,
+  throwError,
+  toUnion,
+  traverseArray,
+  traverseArrayWithIndex,
+  traverseReadonlyArrayWithIndex,
+  traverseReadonlyArrayWithIndexSeq,
+  traverseReadonlyNonEmptyArrayWithIndex,
+  traverseReadonlyNonEmptyArrayWithIndexSeq,
+  traverseSeqArray,
+  traverseSeqArrayWithIndex,
+  tryCatch,
+  tryCatchK
+};
+//# sourceMappingURL=IOEither.js.map

package/dist/_node_modules/fp-ts/es6/IOEither.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IOEither.js","sources":["../../../../../../node_modules/fp-ts/es6/IOEither.js"],"sourcesContent":["import { getApplicativeMonoid } from './Applicative';\nimport { ap as ap_, apFirst as apFirst_, apS as apS_, apSecond as apSecond_, getApplySemigroup as getApplySemigroup_ } from './Apply';\nimport * as chainable from './Chain';\nimport { compact as compact_, separate as separate_ } from './Compactable';\nimport * as E from './Either';\nimport * as ET from './EitherT';\nimport { filter as filter_, filterMap as filterMap_, partition as partition_, partitionMap as partitionMap_ } from './Filterable';\nimport { chainOptionK as chainOptionK_, filterOrElse as filterOrElse_, fromEitherK as fromEitherK_, fromOption as fromOption_, fromOptionK as fromOptionK_, fromPredicate as fromPredicate_, tapEither as tapEither_ } from './FromEither';\nimport { fromIOK as fromIOK_, tapIO as tapIO_ } from './FromIO';\nimport { dual, flow, identity, pipe, SK } from './function';\nimport { as as as_, asUnit as asUnit_, bindTo as bindTo_, flap as flap_, let as let__ } from './Functor';\nimport * as _ from './internal';\nimport * as I from './IO';\n// -------------------------------------------------------------------------------------\n// constructors\n// -------------------------------------------------------------------------------------\n/**\n * @category constructors\n * @since 2.0.0\n */\nexport var left = /*#__PURE__*/ ET.left(I.Pointed);\n/**\n * @category constructors\n * @since 2.0.0\n */\nexport var right = /*#__PURE__*/ ET.right(I.Pointed);\n/**\n * @category constructors\n * @since 2.0.0\n */\nexport var rightIO = /*#__PURE__*/ ET.rightF(I.Functor);\n/**\n * @category constructors\n * @since 2.0.0\n */\nexport var leftIO = /*#__PURE__*/ ET.leftF(I.Functor);\n// -------------------------------------------------------------------------------------\n// conversions\n// -------------------------------------------------------------------------------------\n/**\n * @category conversions\n * @since 2.0.0\n */\nexport var fromEither = I.of;\n/**\n * @category conversions\n * @since 2.7.0\n */\nexport var fromIO = rightIO;\n/**\n * @category pattern matching\n * @since 2.10.0\n */\nexport var match = \n/*#__PURE__*/ ET.match(I.Functor);\n/**\n * Less strict version of [`match`](#match).\n *\n * The `W` suffix (short for **W**idening) means that the handler return types will be merged.\n *\n * @category pattern matching\n * @since 2.10.0\n */\nexport var matchW = match;\n/**\n * The `E` suffix (short for **E**ffect) means that the handlers return an effect (`IO`).\n *\n * @category pattern matching\n * @since 2.10.0\n */\nexport var matchE = \n/*#__PURE__*/ ET.matchE(I.Monad);\n/**\n * Alias of [`matchE`](#matche).\n *\n * @category pattern matching\n * @since 2.0.0\n */\nexport var fold = matchE;\n/**\n * Less strict version of [`matchE`](#matche).\n *\n * The `W` suffix (short for **W**idening) means that the handler return types will be merged.\n *\n * @category pattern matching\n * @since 2.10.0\n */\nexport var matchEW = matchE;\n/**\n * Alias of [`matchEW`](#matchew).\n *\n * @category pattern matching\n * @since 2.10.0\n */\nexport var foldW = matchEW;\n/**\n * @category error handling\n * @since 2.0.0\n */\nexport var getOrElse = /*#__PURE__*/ ET.getOrElse(I.Monad);\n/**\n * Less strict version of [`getOrElse`](#getorelse).\n *\n * The `W` suffix (short for **W**idening) means that the handler return type will be merged.\n *\n * @category error handling\n * @since 2.6.0\n */\nexport var getOrElseW = getOrElse;\n/**\n * Constructs a new `IOEither` from a function that performs a side effect and might throw\n *\n * See also [`tryCatchK`](#trycatchk).\n *\n * @category interop\n * @since 2.0.0\n */\nexport var tryCatch = function (f, onThrow) {\n    return function () {\n        return E.tryCatch(f, onThrow);\n    };\n};\n/**\n * Converts a function that may throw to one returning a `IOEither`.\n *\n * @category interop\n * @since 2.10.0\n */\nexport var tryCatchK = function (f, onThrow) {\n    return function () {\n        var a = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            a[_i] = arguments[_i];\n        }\n        return tryCatch(function () { return f.apply(void 0, a); }, onThrow);\n    };\n};\n/**\n * @category conversions\n * @since 2.10.0\n */\nexport var toUnion = /*#__PURE__*/ ET.toUnion(I.Functor);\n// -------------------------------------------------------------------------------------\n// combinators\n// -------------------------------------------------------------------------------------\n/**\n * @category error handling\n * @since 2.0.0\n */\nexport var orElse = \n/*#__PURE__*/ ET.orElse(I.Monad);\n/**\n * Less strict version of [`orElse`](#orelse).\n *\n * The `W` suffix (short for **W**idening) means that the return types will be merged.\n *\n * @category error handling\n * @since 2.10.0\n */\nexport var orElseW = orElse;\n/**\n * Returns an effect that effectfully \"peeks\" at the failure of this effect.\n *\n * @category error handling\n * @since 2.15.0\n */\nexport var tapError = /*#__PURE__*/ dual(2, ET.tapError(I.Monad));\n/**\n * @category error handling\n * @since 2.12.0\n */\nexport var orElseFirstIOK = function (onLeft) {\n    return tapError(fromIOK(onLeft));\n};\n/**\n * @category error handling\n * @since 2.11.0\n */\nexport var orLeft = \n/*#__PURE__*/ ET.orLeft(I.Monad);\n/**\n * @since 2.0.0\n */\nexport var swap = /*#__PURE__*/ ET.swap(I.Functor);\n/* istanbul ignore next */\nvar _map = function (fa, f) { return pipe(fa, map(f)); };\n/* istanbul ignore next */\nvar _ap = function (fab, fa) { return pipe(fab, ap(fa)); };\nvar _apSeq = function (fab, fa) { return flatMap(fab, function (f) { return pipe(fa, map(f)); }); };\n/* istanbul ignore next */\nvar _alt = function (fa, that) { return pipe(fa, alt(that)); };\n/**\n * `map` can be used to turn functions `(a: A) => B` into functions `(fa: F<A>) => F<B>` whose argument and return types\n * use the type constructor `F` to represent some computational context.\n *\n * @category mapping\n * @since 2.0.0\n */\nexport var map = /*#__PURE__*/ ET.map(I.Functor);\n/**\n * Returns a `IOEither` whose failure and success channels have been mapped by the specified pair of functions, `f` and `g`.\n *\n * @example\n * import * as IOEither from 'fp-ts/IOEither'\n * import * as Either from 'fp-ts/Either'\n *\n * const f = (s: string) => new Error(s)\n * const g = (n: number) => n * 2\n *\n * assert.deepStrictEqual(IOEither.mapBoth(IOEither.right(1), f, g)(), Either.right(2))\n * assert.deepStrictEqual(IOEither.mapBoth(IOEither.left('err'), f, g)(), Either.left(new Error('err')))\n *\n * @category error handling\n * @since 2.16.0\n */\nexport var mapBoth = /*#__PURE__*/ dual(3, ET.mapBoth(I.Functor));\n/**\n * Alias of `mapBoth`.\n *\n * @category legacy\n * @since 2.0.0\n */\nexport var bimap = mapBoth;\n/**\n * Returns a `IOEither` with its error channel mapped using the specified function.\n *\n * @example\n * import * as IOEither from 'fp-ts/IOEither'\n * import * as Either from 'fp-ts/Either'\n *\n * const f = (s: string) => new Error(s)\n *\n * assert.deepStrictEqual(IOEither.mapError(IOEither.right(1), f)(), Either.right(1))\n * assert.deepStrictEqual(IOEither.mapError(IOEither.left('err'), f)(), Either.left(new Error('err')))\n *\n * @category error handling\n * @since 2.16.0\n */\nexport var mapError = /*#__PURE__*/ dual(2, ET.mapError(I.Functor));\n/**\n * Alias of `mapError`.\n *\n * @category legacy\n * @since 2.0.0\n */\nexport var mapLeft = mapError;\n/**\n * @since 2.0.0\n */\nexport var ap = \n/*#__PURE__*/ ET.ap(I.Apply);\n/**\n * Less strict version of [`ap`](#ap).\n *\n * The `W` suffix (short for **W**idening) means that the error types will be merged.\n *\n * @since 2.8.0\n */\nexport var apW = ap;\n/**\n * @category constructors\n * @since 2.8.5\n */\nexport var of = right;\n/**\n * @category sequencing\n * @since 2.14.0\n */\nexport var flatMap = /*#__PURE__*/ dual(2, ET.flatMap(I.Monad));\n/**\n * Less strict version of [`flatten`](#flatten).\n *\n * The `W` suffix (short for **W**idening) means that the error types will be merged.\n *\n * @category sequencing\n * @since 2.11.0\n */\nexport var flattenW = \n/*#__PURE__*/ flatMap(identity);\n/**\n * @category sequencing\n * @since 2.0.0\n */\nexport var flatten = flattenW;\n/**\n * Identifies an associative operation on a type constructor. It is similar to `Semigroup`, except that it applies to\n * types of kind `* -> *`.\n *\n * @category error handling\n * @since 2.0.0\n */\nexport var alt = \n/*#__PURE__*/ ET.alt(I.Monad);\n/**\n * Less strict version of [`alt`](#alt).\n *\n * The `W` suffix (short for **W**idening) means that the error and the return types will be merged.\n *\n * @category error handling\n * @since 2.9.0\n */\nexport var altW = alt;\n/**\n * @since 2.7.0\n */\nexport var throwError = left;\n/**\n * @category type lambdas\n * @since 2.0.0\n */\nexport var URI = 'IOEither';\n/**\n * The default [`ApplicativePar`](#applicativepar) instance returns the first error, if you want to\n * get all errors you need to provide a way to concatenate them via a `Semigroup`.\n *\n * See [`getApplicativeValidation`](./Either.ts.html#getapplicativevalidation).\n *\n * @category error handling\n * @since 2.7.0\n */\nexport function getApplicativeIOValidation(S) {\n    var ap = ap_(I.Apply, E.getApplicativeValidation(S));\n    return {\n        URI: URI,\n        _E: undefined,\n        map: _map,\n        ap: function (fab, fa) { return pipe(fab, ap(fa)); },\n        of: of\n    };\n}\n/**\n * The default [`Alt`](#alt) instance returns the last error, if you want to\n * get all errors you need to provide a way to concatenate them via a `Semigroup`.\n *\n * See [`getAltValidation`](./Either.ts.html#getaltvalidation).\n *\n * @category error handling\n * @since 2.7.0\n */\nexport function getAltIOValidation(S) {\n    var alt = ET.altValidation(I.Monad, S);\n    return {\n        URI: URI,\n        _E: undefined,\n        map: _map,\n        alt: function (fa, that) { return pipe(fa, alt(that)); }\n    };\n}\n/**\n * @category filtering\n * @since 2.10.0\n */\nexport var getCompactable = function (M) {\n    var C = E.getCompactable(M);\n    return {\n        URI: URI,\n        _E: undefined,\n        compact: compact_(I.Functor, C),\n        separate: separate_(I.Functor, C, E.Functor)\n    };\n};\n/**\n * @category filtering\n * @since 2.1.0\n */\nexport function getFilterable(M) {\n    var F = E.getFilterable(M);\n    var C = getCompactable(M);\n    var filter = filter_(I.Functor, F);\n    var filterMap = filterMap_(I.Functor, F);\n    var partition = partition_(I.Functor, F);\n    var partitionMap = partitionMap_(I.Functor, F);\n    return {\n        URI: URI,\n        _E: undefined,\n        map: _map,\n        compact: C.compact,\n        separate: C.separate,\n        filter: function (fa, predicate) { return pipe(fa, filter(predicate)); },\n        filterMap: function (fa, f) { return pipe(fa, filterMap(f)); },\n        partition: function (fa, predicate) { return pipe(fa, partition(predicate)); },\n        partitionMap: function (fa, f) { return pipe(fa, partitionMap(f)); }\n    };\n}\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Functor = {\n    URI: URI,\n    map: _map\n};\n/**\n * Maps the `Right` value of this `IOEither` to the specified constant value.\n *\n * @category mapping\n * @since 2.16.0\n */\nexport var as = dual(2, as_(Functor));\n/**\n * Maps the `Right` value of this `IOEither` to the void constant value.\n *\n * @category mapping\n * @since 2.16.0\n */\nexport var asUnit = asUnit_(Functor);\n/**\n * @category mapping\n * @since 2.10.0\n */\nexport var flap = /*#__PURE__*/ flap_(Functor);\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var Pointed = {\n    URI: URI,\n    of: of\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Bifunctor = {\n    URI: URI,\n    bimap: mapBoth,\n    mapLeft: mapError\n};\n/**\n * Runs computations in parallel.\n *\n * @category instances\n * @since 2.10.0\n */\nexport var ApplyPar = {\n    URI: URI,\n    map: _map,\n    ap: _ap\n};\n/**\n * Combine two effectful actions, keeping only the result of the first.\n *\n * @since 2.0.0\n */\nexport var apFirst = /*#__PURE__*/ apFirst_(ApplyPar);\n/**\n * Less strict version of [`apFirst`](#apfirst).\n *\n * The `W` suffix (short for **W**idening) means that the error types will be merged.\n *\n * @since 2.12.0\n */\nexport var apFirstW = apFirst;\n/**\n * Combine two effectful actions, keeping only the result of the second.\n *\n * @since 2.0.0\n */\nexport var apSecond = /*#__PURE__*/ apSecond_(ApplyPar);\n/**\n * Less strict version of [`apSecond`](#apsecond).\n *\n * The `W` suffix (short for **W**idening) means that the error types will be merged.\n *\n * @since 2.12.0\n */\nexport var apSecondW = apSecond;\n/**\n * Runs computations in parallel.\n *\n * @category instances\n * @since 2.8.4\n */\nexport var ApplicativePar = {\n    URI: URI,\n    map: _map,\n    ap: _ap,\n    of: of\n};\n/**\n * Runs computations sequentially.\n *\n * @category instances\n * @since 2.8.4\n */\nexport var ApplicativeSeq = {\n    URI: URI,\n    map: _map,\n    ap: _apSeq,\n    of: of\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var Chain = {\n    URI: URI,\n    map: _map,\n    ap: _ap,\n    chain: flatMap\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Monad = {\n    URI: URI,\n    map: _map,\n    ap: _ap,\n    of: of,\n    chain: flatMap\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var FromEither = {\n    URI: URI,\n    fromEither: fromEither\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var FromIO = {\n    URI: URI,\n    fromIO: fromIO\n};\n/**\n * Composes computations in sequence, using the return value of one computation to determine the next computation and\n * keeping only the result of the first.\n *\n * @category combinators\n * @since 2.15.0\n */\nexport var tap = /*#__PURE__*/ dual(2, chainable.tap(Chain));\n/**\n * Composes computations in sequence, using the return value of one computation to determine the next computation and\n * keeping only the result of the first.\n *\n * @example\n * import { pipe } from 'fp-ts/function'\n * import * as IOE from 'fp-ts/IOEither'\n * import * as E from 'fp-ts/Either'\n *\n * const compute = (value: string) => pipe(\n *   IOE.of(value),\n *   IOE.tapEither(() => value.length > 0 ? E.right('ok') : E.left('error')),\n * )\n *\n * assert.deepStrictEqual(compute('')(), E.left('error'))\n * assert.deepStrictEqual(compute('fp-ts')(), E.right('fp-ts'))\n *\n * @category combinators\n * @since 2.16.0\n */\nexport var tapEither = /*#__PURE__*/ dual(2, tapEither_(FromEither, Chain));\n/**\n * Composes computations in sequence, using the return value of one computation to determine the next computation and\n * keeping only the result of the first.\n *\n * @example\n * import { pipe } from 'fp-ts/function'\n * import * as IOE from 'fp-ts/IOEither'\n * import * as E from 'fp-ts/Either'\n * import * as Console from 'fp-ts/Console'\n *\n * const sayHello = (value: string) => Console.log(`Hello, ${value}`)\n *\n * // Will produce `Hello, fp-ts` to the stdout\n * const effectA = IOE.tapIO(IOE.of('fp-ts'), sayHello)\n *\n * // No output to the stdout\n * const effectB = pipe(IOE.left<string>('error'), IOE.tapIO(sayHello))\n *\n * assert.deepStrictEqual(effectA(), E.right('fp-ts'))\n * assert.deepStrictEqual(effectB(), E.left('error'))\n *\n * @category combinators\n * @since 2.16.0\n */\nexport var tapIO = /*#__PURE__*/ dual(2, tapIO_(FromIO, Chain));\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Alt = {\n    URI: URI,\n    map: _map,\n    alt: _alt\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var MonadIO = {\n    URI: URI,\n    map: _map,\n    ap: _ap,\n    of: of,\n    chain: flatMap,\n    fromIO: fromIO\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var MonadThrow = {\n    URI: URI,\n    map: _map,\n    ap: _ap,\n    of: of,\n    chain: flatMap,\n    throwError: throwError\n};\n/**\n * @category lifting\n * @since 2.10.0\n */\nexport var fromIOK = /*#__PURE__*/ fromIOK_(FromIO);\n/**\n * Alias of `tapIO`.\n *\n * @category legacy\n * @since 2.10.0\n */\nexport var chainFirstIOK = tapIO;\n/**\n * @category conversions\n * @since 2.0.0\n */\nexport var fromOption = \n/*#__PURE__*/ fromOption_(FromEither);\n/**\n * Use `liftOption`.\n *\n * @category legacy\n * @since 2.10.0\n */\nexport var fromOptionK = \n/*#__PURE__*/ fromOptionK_(FromEither);\n/**\n * Use `flatMapOption`.\n *\n * @category legacy\n * @since 2.10.0\n */\nexport var chainOptionK = /*#__PURE__*/ chainOptionK_(FromEither, Chain);\n/**\n * Use `flatMapOption`.\n *\n * @category legacy\n * @since 2.13.2\n */\nexport var chainOptionKW = \n/*#__PURE__*/ chainOptionK;\n/** @internal */\nvar _FromEither = {\n    fromEither: FromEither.fromEither\n};\n/** @internal */\nvar _FromIO = {\n    fromIO: fromIO\n};\n/**\n * @category lifting\n * @since 2.15.0\n */\nexport var liftNullable = /*#__PURE__*/ _.liftNullable(_FromEither);\n/**\n * @category lifting\n * @since 2.15.0\n */\nexport var liftOption = /*#__PURE__*/ _.liftOption(_FromEither);\n/** @internal */\nvar _FlatMap = {\n    flatMap: flatMap\n};\n/**\n * @category sequencing\n * @since 2.15.0\n */\nexport var flatMapNullable = /*#__PURE__*/ _.flatMapNullable(_FromEither, _FlatMap);\n/**\n * @category sequencing\n * @since 2.15.0\n */\nexport var flatMapOption = /*#__PURE__*/ _.flatMapOption(_FromEither, _FlatMap);\n/**\n * @category sequencing\n * @since 2.15.0\n */\nexport var flatMapEither = /*#__PURE__*/ _.flatMapEither(_FromEither, _FlatMap);\n/**\n * @category sequencing\n * @since 2.16.0\n */\nexport var flatMapIO = /*#__PURE__*/ _.flatMapIO(_FromIO, _FlatMap);\n/**\n * Alias of `flatMapIO`.\n * @category legacy\n * @since 2.10.0\n */\nexport var chainIOK = flatMapIO;\n/**\n * Alias of `flatMapEither`.\n *\n * @category legacy\n * @since 2.4.0\n */\nexport var chainEitherK = flatMapEither;\n/**\n * Alias of `flatMapEither`.\n *\n * @category legacy\n * @since 2.6.1\n */\nexport var chainEitherKW = flatMapEither;\n/**\n * Alias of `tapEither`.\n *\n * @category legacy\n * @since 2.12.0\n */\nexport var chainFirstEitherK = tapEither;\n/**\n * Alias of `tapEither`.\n *\n * The `W` suffix (short for **W**idening) means that the error types will be merged.\n *\n * @category legacy\n * @since 2.12.0\n */\nexport var chainFirstEitherKW = tapEither;\n/**\n * @category lifting\n * @since 2.0.0\n */\nexport var fromPredicate = /*#__PURE__*/ fromPredicate_(FromEither);\n/**\n * @category filtering\n * @since 2.0.0\n */\nexport var filterOrElse = /*#__PURE__*/ filterOrElse_(FromEither, Chain);\n/**\n * Less strict version of [`filterOrElse`](#filterorelse).\n *\n * The `W` suffix (short for **W**idening) means that the error types will be merged.\n *\n * @category filtering\n * @since 2.9.0\n */\nexport var filterOrElseW = filterOrElse;\n/**\n * @category lifting\n * @since 2.4.0\n */\nexport var fromEitherK = /*#__PURE__*/ fromEitherK_(FromEither);\n// -------------------------------------------------------------------------------------\n// utils\n// -------------------------------------------------------------------------------------\n/**\n * Make sure that a resource is cleaned up in the event of an exception (\\*). The release action is called regardless of\n * whether the body action throws (\\*) or returns.\n *\n * (\\*) i.e. returns a `Left`\n *\n * @since 2.0.0\n */\nexport var bracket = function (acquire, use, release) { return bracketW(acquire, use, release); };\n/**\n * Less strict version of [`bracket`](#bracket).\n *\n * The `W` suffix (short for **W**idening) means that the error types will be merged.\n *\n * @since 2.12.0\n */\nexport var bracketW = function (acquire, use, release) {\n    return flatMap(acquire, function (a) { return I.flatMap(use(a), function (e) { return flatMap(release(a, e), function () { return I.of(e); }); }); });\n};\n// -------------------------------------------------------------------------------------\n// do notation\n// -------------------------------------------------------------------------------------\n/**\n * @category do notation\n * @since 2.9.0\n */\nexport var Do = /*#__PURE__*/ of(_.emptyRecord);\n/**\n * @category do notation\n * @since 2.8.0\n */\nexport var bindTo = /*#__PURE__*/ bindTo_(Functor);\nvar let_ = /*#__PURE__*/ let__(Functor);\nexport { \n/**\n * @category do notation\n * @since 2.13.0\n */\nlet_ as let };\n/**\n * @category do notation\n * @since 2.8.0\n */\nexport var bind = /*#__PURE__*/ chainable.bind(Chain);\n/**\n * The `W` suffix (short for **W**idening) means that the error types will be merged.\n *\n * @category do notation\n * @since 2.8.0\n */\nexport var bindW = bind;\n/**\n * @category do notation\n * @since 2.8.0\n */\nexport var apS = /*#__PURE__*/ apS_(ApplyPar);\n/**\n * Less strict version of [`apS`](#aps).\n *\n * The `W` suffix (short for **W**idening) means that the error types will be merged.\n *\n * @category do notation\n * @since 2.8.0\n */\nexport var apSW = apS;\n/**\n * @since 2.11.0\n */\nexport var ApT = /*#__PURE__*/ of(_.emptyReadonlyArray);\n// -------------------------------------------------------------------------------------\n// array utils\n// -------------------------------------------------------------------------------------\n/**\n * Equivalent to `ReadonlyNonEmptyArray#traverseWithIndex(ApplicativePar)`.\n *\n * @category traversing\n * @since 2.11.0\n */\nexport var traverseReadonlyNonEmptyArrayWithIndex = function (f) {\n    return flow(I.traverseReadonlyNonEmptyArrayWithIndex(f), I.map(E.traverseReadonlyNonEmptyArrayWithIndex(SK)));\n};\n/**\n * Equivalent to `ReadonlyArray#traverseWithIndex(ApplicativePar)`.\n *\n * @category traversing\n * @since 2.11.0\n */\nexport var traverseReadonlyArrayWithIndex = function (f) {\n    var g = traverseReadonlyNonEmptyArrayWithIndex(f);\n    return function (as) { return (_.isNonEmpty(as) ? g(as) : ApT); };\n};\n/**\n * Equivalent to `ReadonlyNonEmptyArray#traverseWithIndex(ApplicativeSeq)`.\n *\n * @category traversing\n * @since 2.11.0\n */\nexport var traverseReadonlyNonEmptyArrayWithIndexSeq = function (f) {\n    return function (as) {\n        return function () {\n            var e = f(0, _.head(as))();\n            if (_.isLeft(e)) {\n                return e;\n            }\n            var out = [e.right];\n            for (var i = 1; i < as.length; i++) {\n                var e_1 = f(i, as[i])();\n                if (_.isLeft(e_1)) {\n                    return e_1;\n                }\n                out.push(e_1.right);\n            }\n            return _.right(out);\n        };\n    };\n};\n/**\n * Equivalent to `ReadonlyArray#traverseWithIndex(ApplicativeSeq)`.\n *\n * @category traversing\n * @since 2.11.0\n */\nexport var traverseReadonlyArrayWithIndexSeq = function (f) {\n    var g = traverseReadonlyNonEmptyArrayWithIndexSeq(f);\n    return function (as) { return (_.isNonEmpty(as) ? g(as) : ApT); };\n};\n/**\n * Equivalent to `ReadonlyArray#traverseWithIndex(Applicative)`.\n *\n * @category traversing\n * @since 2.9.0\n */\nexport var traverseArrayWithIndex = traverseReadonlyArrayWithIndex;\n/**\n * Equivalent to `ReadonlyArray#traverse(Applicative)`.\n *\n * @category traversing\n * @since 2.9.0\n */\nexport var traverseArray = function (f) { return traverseReadonlyArrayWithIndex(function (_, a) { return f(a); }); };\n/**\n * Equivalent to `ReadonlyArray#sequence(Applicative)`.\n *\n * @category traversing\n * @since 2.9.0\n */\nexport var sequenceArray = \n/*#__PURE__*/ traverseArray(identity);\n/**\n * Equivalent to `ReadonlyArray#traverseWithIndex(ApplicativeSeq)`.\n *\n * @category traversing\n * @since 2.9.0\n */\nexport var traverseSeqArrayWithIndex = traverseReadonlyArrayWithIndexSeq;\n/**\n * Equivalent to `ReadonlyArray#traverse(ApplicativeSeq)`.\n *\n * @category traversing\n * @since 2.9.0\n */\nexport var traverseSeqArray = function (f) { return traverseReadonlyArrayWithIndexSeq(function (_, a) { return f(a); }); };\n/**\n * Equivalent to `ReadonlyArray#sequence(ApplicativeSeq)`.\n *\n * @category traversing\n * @since 2.9.0\n */\nexport var sequenceSeqArray = \n/*#__PURE__*/ traverseSeqArray(identity);\n// -------------------------------------------------------------------------------------\n// deprecated\n// -------------------------------------------------------------------------------------\n/**\n * Use [`ApplicativePar`](#applicativepar) instead\n *\n * @category zone of death\n * @since 2.7.0\n * @deprecated\n */\nexport var Applicative = ApplicativePar;\n// -------------------------------------------------------------------------------------\n// legacy\n// -------------------------------------------------------------------------------------\n/**\n * Alias of `flatMap`.\n *\n * @category legacy\n * @since 2.0.0\n */\nexport var chain = flatMap;\n/**\n * Alias of `flatMap`.\n *\n * @category legacy\n * @since 2.6.0\n */\nexport var chainW = flatMap;\n/**\n * Alias of `tap`.\n *\n * @category legacy\n * @since 2.0.0\n */\nexport var chainFirst = tap;\n/**\n * Alias of `tap`.\n *\n * @category legacy\n * @since 2.8.0\n */\nexport var chainFirstW = tap;\n/**\n * Alias of `tapError`.\n *\n * @category legacy\n * @since 2.11.0\n */\nexport var orElseFirst = tapError;\n/**\n * Alias of `tapError`.\n *\n * @category legacy\n * @since 2.11.0\n */\nexport var orElseFirstW = tapError;\n// -------------------------------------------------------------------------------------\n// deprecated\n// -------------------------------------------------------------------------------------\n/**\n * This instance is deprecated, use small, specific instances instead.\n * For example if a function needs a `Functor` instance, pass `IOE.Functor` instead of `IOE.ioEither`\n * (where `IOE` is from `import IOE from 'fp-ts/IOEither'`)\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var ioEither = {\n    URI: URI,\n    bimap: mapBoth,\n    mapLeft: mapError,\n    map: _map,\n    of: of,\n    ap: _ap,\n    chain: flatMap,\n    alt: _alt,\n    fromIO: fromIO,\n    throwError: throwError\n};\n/**\n * Use [`getApplySemigroup`](./Apply.ts.html#getapplysemigroup) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getApplySemigroup = \n/*#__PURE__*/ getApplySemigroup_(ApplyPar);\n/**\n * Use [`getApplicativeMonoid`](./Applicative.ts.html#getapplicativemonoid) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getApplyMonoid = \n/*#__PURE__*/ getApplicativeMonoid(ApplicativePar);\n/**\n * Use [`getApplySemigroup`](./Apply.ts.html#getapplysemigroup) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getSemigroup = function (S) {\n    return getApplySemigroup_(I.Apply)(E.getSemigroup(S));\n};\n/**\n * Use [`getApplicativeIOValidation`](#getapplicativeiovalidation) and [`getAltIOValidation`](#getaltiovalidation).\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport function getIOValidation(SE) {\n    var applicativeIOValidation = getApplicativeIOValidation(SE);\n    var altIOValidation = getAltIOValidation(SE);\n    return {\n        URI: URI,\n        _E: undefined,\n        map: _map,\n        ap: applicativeIOValidation.ap,\n        of: of,\n        chain: flatMap,\n        bimap: mapBoth,\n        mapLeft: mapError,\n        alt: altIOValidation.alt,\n        fromIO: fromIO,\n        throwError: throwError\n    };\n}\n"],"names":["ET.left","I.Pointed","ET.right","ET.rightF","I.Functor","ET.leftF","I.of","ET.match","ET.matchE","I.Monad","ET.getOrElse","E.tryCatch","ET.toUnion","ET.orElse","ET.tapError","ET.orLeft","ET.swap","ET.map","ET.mapBoth","ET.mapError","ET.ap","I.Apply","ET.flatMap","ET.alt","ap","ap_","E.getApplicativeValidation","alt","ET.altValidation","E.getCompactable","compact_","separate_","E.Functor","E.getFilterable","filter","filter_","filterMap","filterMap_","partition","partition_","partitionMap","partitionMap_","as_","asUnit_","flap_","apFirst_","apSecond_","chainable.tap","tapEither_","tapIO_","fromIOK_","fromOption_","fromOptionK_","chainOptionK_","_.liftNullable","_.liftOption","_.flatMapNullable","_.flatMapOption","_.flatMapEither","_.flatMapIO","fromPredicate_","filterOrElse_","fromEitherK_","I.flatMap","_.emptyRecord","bindTo_","let__","chainable.bind","apS_","_.emptyReadonlyArray","I.traverseReadonlyNonEmptyArrayWithIndex","I.map","E.traverseReadonlyNonEmptyArrayWithIndex","as","_.isNonEmpty","_.head","_.isLeft","_.right","getApplySemigroup_","E.getSemigroup"],"mappings":"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","x_google_ignoreList":[0]}