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

@@ -0,0 +1,398 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Applicative$1 = require("./Applicative.cjs");
+const Apply$1 = 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 FromReader$1 = require("./FromReader.cjs");
+const _function = require("./function.cjs");
+const Functor$1 = require("./Functor.cjs");
+const internal = require("./internal.cjs");
+const Reader = require("./Reader.cjs");
+var left = /* @__PURE__ */ EitherT.left(Reader.Pointed);
+var right = /* @__PURE__ */ EitherT.right(Reader.Pointed);
+var rightReader = /* @__PURE__ */ EitherT.rightF(Reader.Functor);
+var leftReader = /* @__PURE__ */ EitherT.leftF(Reader.Functor);
+var fromEither = Reader.of;
+var fromReader = rightReader;
+var match = /* @__PURE__ */ EitherT.match(Reader.Functor);
+var matchW = match;
+var matchE = /* @__PURE__ */ EitherT.matchE(Reader.Monad);
+var fold = matchE;
+var matchEW = matchE;
+var foldW = matchEW;
+var getOrElse = /* @__PURE__ */ EitherT.getOrElse(Reader.Monad);
+var getOrElseW = getOrElse;
+var toUnion = /* @__PURE__ */ EitherT.toUnion(Reader.Functor);
+var local = Reader.local;
+var asksReaderEitherW = Reader.asksReaderW;
+var asksReaderEither = asksReaderEitherW;
+var orElse = /* @__PURE__ */ EitherT.orElse(Reader.Monad);
+var orElseW = orElse;
+var tapError = /* @__PURE__ */ _function.dual(2, EitherT.tapError(Reader.Monad));
+var orLeft = /* @__PURE__ */ EitherT.orLeft(Reader.Monad);
+var swap = /* @__PURE__ */ EitherT.swap(Reader.Functor);
+var _map = function(fa, f) {
+  return _function.pipe(fa, map(f));
+};
+var _ap = function(fab, fa) {
+  return _function.pipe(fab, ap(fa));
+};
+var _alt = function(fa, that) {
+  return _function.pipe(fa, alt(that));
+};
+var map = /* @__PURE__ */ EitherT.map(Reader.Functor);
+var mapBoth = /* @__PURE__ */ _function.dual(3, EitherT.mapBoth(Reader.Functor));
+var bimap = mapBoth;
+var mapError = /* @__PURE__ */ _function.dual(2, EitherT.mapError(Reader.Functor));
+var mapLeft = mapError;
+var ap = /* @__PURE__ */ EitherT.ap(Reader.Apply);
+var apW = ap;
+var of = right;
+var flatMap = /* @__PURE__ */ _function.dual(2, EitherT.flatMap(Reader.Monad));
+var flattenW = /* @__PURE__ */ flatMap(_function.identity);
+var flatten = flattenW;
+var alt = /* @__PURE__ */ EitherT.alt(Reader.Monad);
+var altW = alt;
+var throwError = left;
+var URI = "ReaderEither";
+var getCompactable = function(M) {
+  var C = Either.getCompactable(M);
+  return {
+    URI,
+    _E: void 0,
+    compact: Compactable.compact(Reader.Functor, C),
+    separate: Compactable.separate(Reader.Functor, C, Either.Functor)
+  };
+};
+function getFilterable(M) {
+  var F = Either.getFilterable(M);
+  var C = getCompactable(M);
+  var filter = Filterable.filter(Reader.Functor, F);
+  var filterMap = Filterable.filterMap(Reader.Functor, F);
+  var partition = Filterable.partition(Reader.Functor, F);
+  var partitionMap = Filterable.partitionMap(Reader.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 getApplicativeReaderValidation(S) {
+  var ap2 = Apply$1.ap(Reader.Apply, Either.getApplicativeValidation(S));
+  return {
+    URI,
+    _E: void 0,
+    map: _map,
+    ap: function(fab, fa) {
+      return _function.pipe(fab, ap2(fa));
+    },
+    of
+  };
+}
+function getAltReaderValidation(S) {
+  var alt2 = EitherT.altValidation(Reader.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 Apply = {
+  URI,
+  map: _map,
+  ap: _ap
+};
+var apFirst = /* @__PURE__ */ Apply$1.apFirst(Apply);
+var apFirstW = apFirst;
+var apSecond = /* @__PURE__ */ Apply$1.apSecond(Apply);
+var apSecondW = apSecond;
+var Applicative = {
+  URI,
+  map: _map,
+  ap: _ap,
+  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 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 tapReader = /* @__PURE__ */ _function.dual(2, FromReader$1.tapReader(FromReader, Chain));
+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 MonadThrow = {
+  URI,
+  map: _map,
+  ap: _ap,
+  of,
+  chain: flatMap,
+  throwError
+};
+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 _FromReader = {
+  fromReader: FromReader.fromReader
+};
+var liftNullable = /* @__PURE__ */ internal.liftNullable(_FromEither);
+var liftOption = /* @__PURE__ */ internal.liftOption(_FromEither);
+var _FlatMap = {
+  flatMap
+};
+var flatMapNullable = /* @__PURE__ */ internal.flatMapNullable(_FromEither, _FlatMap);
+var flatMapOption = /* @__PURE__ */ internal.flatMapOption(_FromEither, _FlatMap);
+var flatMapEither = /* @__PURE__ */ internal.flatMapEither(_FromEither, _FlatMap);
+var flatMapReader = /* @__PURE__ */ internal.flatMapReader(_FromReader, _FlatMap);
+var chainEitherK = flatMapEither;
+var chainEitherKW = flatMapEither;
+var chainFirstEitherK = tapEither;
+var chainFirstEitherKW = tapEither;
+var chainReaderK = flatMapReader;
+var chainReaderKW = flatMapReader;
+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 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$1.apS(Apply);
+var apSW = apS;
+var ApT = /* @__PURE__ */ of(internal.emptyReadonlyArray);
+var traverseReadonlyNonEmptyArrayWithIndex = function(f) {
+  return _function.flow(Reader.traverseReadonlyNonEmptyArrayWithIndex(f), Reader.map(Either.traverseReadonlyNonEmptyArrayWithIndex(_function.SK)));
+};
+var traverseReadonlyArrayWithIndex = function(f) {
+  var g = traverseReadonlyNonEmptyArrayWithIndex(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 chain = flatMap;
+var chainW = flatMap;
+var chainFirst = tap;
+var chainFirstW = tap;
+var orElseFirst = tapError;
+var orElseFirstW = tapError;
+var readerEither = {
+  URI,
+  bimap: mapBoth,
+  mapLeft: mapError,
+  map: _map,
+  of,
+  ap: _ap,
+  chain: flatMap,
+  alt: _alt,
+  throwError: left
+};
+var getApplySemigroup = /* @__PURE__ */ Apply$1.getApplySemigroup(Apply);
+var getApplyMonoid = /* @__PURE__ */ Applicative$1.getApplicativeMonoid(Applicative);
+var getSemigroup = function(S) {
+  return Apply$1.getApplySemigroup(Reader.Apply)(Either.getSemigroup(S));
+};
+function getReaderValidation(SE) {
+  var applicativeReaderValidation = getApplicativeReaderValidation(SE);
+  var altReaderValidation = getAltReaderValidation(SE);
+  return {
+    URI,
+    _E: void 0,
+    map: _map,
+    ap: applicativeReaderValidation.ap,
+    of,
+    chain: flatMap,
+    bimap: mapBoth,
+    mapLeft: mapError,
+    alt: altReaderValidation.alt,
+    throwError
+  };
+}
+exports.Alt = Alt;
+exports.ApT = ApT;
+exports.Applicative = Applicative;
+exports.Apply = Apply;
+exports.Bifunctor = Bifunctor;
+exports.Chain = Chain;
+exports.Do = Do;
+exports.FromEither = FromEither;
+exports.FromReader = FromReader;
+exports.Functor = Functor;
+exports.Monad = Monad;
+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.asksReaderEither = asksReaderEither;
+exports.asksReaderEitherW = asksReaderEitherW;
+exports.bimap = bimap;
+exports.bind = bind;
+exports.bindTo = bindTo;
+exports.bindW = bindW;
+exports.chain = chain;
+exports.chainEitherK = chainEitherK;
+exports.chainEitherKW = chainEitherKW;
+exports.chainFirst = chainFirst;
+exports.chainFirstEitherK = chainFirstEitherK;
+exports.chainFirstEitherKW = chainFirstEitherKW;
+exports.chainFirstReaderK = chainFirstReaderK;
+exports.chainFirstReaderKW = chainFirstReaderKW;
+exports.chainFirstW = chainFirstW;
+exports.chainOptionK = chainOptionK;
+exports.chainOptionKW = chainOptionKW;
+exports.chainReaderK = chainReaderK;
+exports.chainReaderKW = chainReaderKW;
+exports.chainW = chainW;
+exports.filterOrElse = filterOrElse;
+exports.filterOrElseW = filterOrElseW;
+exports.flap = flap;
+exports.flatMap = flatMap;
+exports.flatMapEither = flatMapEither;
+exports.flatMapNullable = flatMapNullable;
+exports.flatMapOption = flatMapOption;
+exports.flatMapReader = flatMapReader;
+exports.flatten = flatten;
+exports.flattenW = flattenW;
+exports.fold = fold;
+exports.foldW = foldW;
+exports.fromEither = fromEither;
+exports.fromEitherK = fromEitherK;
+exports.fromOption = fromOption;
+exports.fromOptionK = fromOptionK;
+exports.fromPredicate = fromPredicate;
+exports.fromReader = fromReader;
+exports.fromReaderK = fromReaderK;
+exports.getAltReaderValidation = getAltReaderValidation;
+exports.getApplicativeReaderValidation = getApplicativeReaderValidation;
+exports.getApplyMonoid = getApplyMonoid;
+exports.getApplySemigroup = getApplySemigroup;
+exports.getCompactable = getCompactable;
+exports.getFilterable = getFilterable;
+exports.getOrElse = getOrElse;
+exports.getOrElseW = getOrElseW;
+exports.getReaderValidation = getReaderValidation;
+exports.getSemigroup = getSemigroup;
+exports.left = left;
+exports.leftReader = leftReader;
+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.readerEither = readerEither;
+exports.right = right;
+exports.rightReader = rightReader;
+exports.sequenceArray = sequenceArray;
+exports.swap = swap;
+exports.tap = tap;
+exports.tapEither = tapEither;
+exports.tapError = tapError;
+exports.tapReader = tapReader;
+exports.throwError = throwError;
+exports.toUnion = toUnion;
+exports.traverseArray = traverseArray;
+exports.traverseArrayWithIndex = traverseArrayWithIndex;
+exports.traverseReadonlyArrayWithIndex = traverseReadonlyArrayWithIndex;
+exports.traverseReadonlyNonEmptyArrayWithIndex = traverseReadonlyNonEmptyArrayWithIndex;
+//# sourceMappingURL=ReaderEither.cjs.map

package/dist/_node_modules/fp-ts/es6/ReaderEither.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReaderEither.cjs","sources":["../../../../../../node_modules/fp-ts/es6/ReaderEither.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 { ask as ask_, asks as asks_, fromReaderK as fromReaderK_, tapReader as tapReader_ } from './FromReader';\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 R from './Reader';\n// -------------------------------------------------------------------------------------\n// constructors\n// -------------------------------------------------------------------------------------\n/**\n * @category constructors\n * @since 2.0.0\n */\nexport var left = /*#__PURE__*/ ET.left(R.Pointed);\n/**\n * @category constructors\n * @since 2.0.0\n */\nexport var right = /*#__PURE__*/ ET.right(R.Pointed);\n/**\n * @category constructors\n * @since 2.0.0\n */\nexport var rightReader = \n/*#__PURE__*/ ET.rightF(R.Functor);\n/**\n * @category constructors\n * @since 2.0.0\n */\nexport var leftReader = /*#__PURE__*/ ET.leftF(R.Functor);\n// -------------------------------------------------------------------------------------\n// conversions\n// -------------------------------------------------------------------------------------\n/**\n * @category conversions\n * @since 2.0.0\n */\nexport var fromEither = R.of;\n/**\n * @category conversions\n * @since 2.11.0\n */\nexport var fromReader = rightReader;\n/**\n * @category pattern matching\n * @since 2.10.0\n */\nexport var match = /*#__PURE__*/ ET.match(R.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 (`Reader`).\n *\n * @category pattern matching\n * @since 2.10.0\n */\nexport var matchE = /*#__PURE__*/ ET.matchE(R.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 = \n/*#__PURE__*/ ET.getOrElse(R.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 * @category conversions\n * @since 2.10.0\n */\nexport var toUnion = /*#__PURE__*/ ET.toUnion(R.Functor);\n// -------------------------------------------------------------------------------------\n// combinators\n// -------------------------------------------------------------------------------------\n/**\n * Changes the value of the local context during the execution of the action `ma` (similar to `Contravariant`'s\n * `contramap`).\n *\n * @since 2.0.0\n */\nexport var local = R.local;\n/**\n * Less strict version of [`asksReaderEither`](#asksreadereither).\n *\n * The `W` suffix (short for **W**idening) means that the environment types will be merged.\n *\n * @category constructors\n * @since 2.11.0\n */\nexport var asksReaderEitherW = R.asksReaderW;\n/**\n * Effectfully accesses the environment.\n *\n * @category constructors\n * @since 2.11.0\n */\nexport var asksReaderEither = asksReaderEitherW;\n/**\n * @category error handling\n * @since 2.0.0\n */\nexport var orElse = /*#__PURE__*/ ET.orElse(R.Monad);\n/**\n * Less strict version of [`orElse`](#orelse).\n *\n * The `W` suffix (short for **W**idening) means that the environment types and 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(R.Monad));\n/**\n * @category error handling\n * @since 2.11.0\n */\nexport var orLeft = /*#__PURE__*/ ET.orLeft(R.Monad);\n/**\n * @since 2.0.0\n */\nexport var swap = /*#__PURE__*/ ET.swap(R.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)); };\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 = \n/*#__PURE__*/ ET.map(R.Functor);\n/**\n * Returns a `ReaderEither` whose failure and success channels have been mapped by the specified pair of functions, `f` and `g`.\n *\n * @example\n * import * as ReaderEither from 'fp-ts/ReaderEither'\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(ReaderEither.mapBoth(ReaderEither.right(1), f, g)({}), Either.right(2))\n * assert.deepStrictEqual(ReaderEither.mapBoth(ReaderEither.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(R.Functor));\n/**\n * Alias of `mapBoth`.\n *\n * @category legacy\n * @since 2.0.0\n */\nexport var bimap = mapBoth;\n/**\n * Returns a `ReaderEither` with its error channel mapped using the specified function.\n *\n * @example\n * import * as ReaderEither from 'fp-ts/ReaderEither'\n * import * as Either from 'fp-ts/Either'\n *\n * const f = (s: string) => new Error(s)\n *\n * assert.deepStrictEqual(ReaderEither.mapError(ReaderEither.right(1), f)({}), Either.right(1))\n * assert.deepStrictEqual(ReaderEither.mapError(ReaderEither.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(R.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 = /*#__PURE__*/ ET.ap(R.Apply);\n/**\n * Less strict version of [`ap`](#ap).\n *\n * The `W` suffix (short for **W**idening) means that the environment types and 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(R.Monad));\n/**\n * Less strict version of [`flatten`](#flatten).\n *\n * The `W` suffix (short for **W**idening) means that the environment types and the error types will be merged.\n *\n * @category sequencing\n * @since 2.11.0\n */\nexport var flattenW = /*#__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(R.Monad);\n/**\n * Less strict version of [`alt`](#alt).\n *\n * The `W` suffix (short for **W**idening) means that the environment, 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 = 'ReaderEither';\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_(R.Functor, C),\n        separate: separate_(R.Functor, C, E.Functor)\n    };\n};\n/**\n * @category filtering\n * @since 2.10.0\n */\nexport function getFilterable(M) {\n    var F = E.getFilterable(M);\n    var C = getCompactable(M);\n    var filter = filter_(R.Functor, F);\n    var filterMap = filterMap_(R.Functor, F);\n    var partition = partition_(R.Functor, F);\n    var partitionMap = partitionMap_(R.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 * The default [`Applicative`](#applicative) 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 getApplicativeReaderValidation(S) {\n    var ap = ap_(R.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 getAltReaderValidation(S) {\n    var alt = ET.altValidation(R.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 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 `ReaderEither` 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 `ReaderEither` 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.10.0\n */\nexport var Apply = {\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_(Apply);\n/**\n * Less strict version of [`apFirst`](#apfirst)\n *\n * The `W` suffix (short for **W**idening) means that the environment types and 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_(Apply);\n/**\n * Less strict version of [`apSecond`](#apsecond)\n *\n * The `W` suffix (short for **W**idening) means that the environment types and the error types will be merged.\n *\n * @since 2.12.0\n */\nexport var apSecondW = apSecond;\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Applicative = {\n    URI: URI,\n    map: _map,\n    ap: _ap,\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.11.0\n */\nexport var FromReader = {\n    URI: URI,\n    fromReader: fromReader\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 * as E from 'fp-ts/Either'\n * import { pipe } from 'fp-ts/function'\n * import * as RE from 'fp-ts/ReaderEither'\n *\n * const checkString = (value: string) => pipe(\n *   RE.ask<number>(),\n *   RE.tapEither(\n *     (minLength) => value.length > minLength\n *       ? E.right('ok')\n *       : E.left('error')\n *   )\n * )\n *\n * assert.deepStrictEqual(checkString('')(1), E.left('error'))\n * assert.deepStrictEqual(checkString('fp-ts')(2), E.right(2))\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 * @category combinators\n * @since 2.16.0\n */\nexport var tapReader = /*#__PURE__*/ dual(2, tapReader_(FromReader, Chain));\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 * @category instances\n * @since 2.7.0\n */\nexport var Alt = {\n    URI: URI,\n    map: _map,\n    alt: _alt\n};\n/**\n * Reads the current context.\n *\n * @category constructors\n * @since 2.0.0\n */\nexport var ask = /*#__PURE__*/ ask_(FromReader);\n/**\n * Projects a value from the global context in a `ReaderEither`.\n *\n * @category constructors\n * @since 2.0.0\n */\nexport var asks = /*#__PURE__*/ asks_(FromReader);\n/**\n * @category lifting\n * @since 2.11.0\n */\nexport var fromReaderK = /*#__PURE__*/ fromReaderK_(FromReader);\n/**\n * Alias of `tapReader`.\n *\n * @category legacy\n * @since 2.11.0\n */\nexport var chainFirstReaderK = tapReader;\n/**\n * Alias of `tapReader`.\n *\n * Less strict version of [`chainReaderK`](#chainreaderk).\n *\n * The `W` suffix (short for **W**idening) means that the environment types will be merged.\n *\n * @category legacy\n * @since 2.11.0\n */\nexport var chainFirstReaderKW = tapReader;\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 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 = /*#__PURE__*/ fromOptionK_(FromEither);\n/**\n * Use `flatMapOption`.\n *\n * @category legacy\n * @since 2.10.0\n */\nexport var chainOptionK = \n/*#__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 _FromReader = {\n    fromReader: FromReader.fromReader\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 flatMapReader = /*#__PURE__*/ _.flatMapReader(_FromReader, _FlatMap);\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 * Less strict version of [`chainFirstEitherK`](#chainfirsteitherk).\n *\n * The `W` suffix (short for **W**idening) means that the environment types will be merged.\n *\n * @category legacy\n * @since 2.12.0\n */\nexport var chainFirstEitherKW = tapEither;\n/**\n * Alias of `flatMapReader`.\n *\n * @category legacy\n * @since 2.11.0\n */\nexport var chainReaderK = flatMapReader;\n/**\n * Alias of `flatMapReader`.\n *\n * Less strict version of [`chainReaderK`](#chainreaderk).\n *\n * The `W` suffix (short for **W**idening) means that the environment types will be merged.\n *\n * @category legacy\n * @since 2.11.0\n */\nexport var chainReaderKW = flatMapReader;\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// 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 environment types and 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_(Apply);\n/**\n * Less strict version of [`apS`](#aps).\n *\n * The `W` suffix (short for **W**idening) means that the environment types and 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(Applicative)`.\n *\n * @category traversing\n * @since 2.11.0\n */\nexport var traverseReadonlyNonEmptyArrayWithIndex = function (f) {\n    return flow(R.traverseReadonlyNonEmptyArrayWithIndex(f), R.map(E.traverseReadonlyNonEmptyArrayWithIndex(SK)));\n};\n/**\n * Equivalent to `ReadonlyArray#traverseWithIndex(Applicative)`.\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 `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 = /*#__PURE__*/ traverseArray(identity);\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 `RE.Functor` instead of `RE.readerEither`\n * (where `R` is from `import R from 'fp-ts/ReaderEither'`)\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var readerEither = {\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    throwError: left\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_(Apply);\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(Applicative);\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_(R.Apply)(E.getSemigroup(S));\n};\n/**\n * Use [`getApplicativeReaderValidation`](#getapplicativereadervalidation) and [`getAltReaderValidation`](#getaltreadervalidation) instead.\n *\n * @category zone of death\n * @since 2.3.0\n * @deprecated\n */\nexport function getReaderValidation(SE) {\n    var applicativeReaderValidation = getApplicativeReaderValidation(SE);\n    var altReaderValidation = getAltReaderValidation(SE);\n    return {\n        URI: URI,\n        _E: undefined,\n        map: _map,\n        ap: applicativeReaderValidation.ap,\n        of: of,\n        chain: flatMap,\n        bimap: mapBoth,\n        mapLeft: mapError,\n        alt: altReaderValidation.alt,\n        throwError: throwError\n    };\n}\n"],"names":["ET.left","R.Pointed","ET.right","ET.rightF","R.Functor","ET.leftF","R.of","ET.match","ET.matchE","R.Monad","ET.getOrElse","ET.toUnion","R.local","R.asksReaderW","ET.orElse","dual","ET.tapError","ET.orLeft","ET.swap","pipe","ET.map","ET.mapBoth","ET.mapError","ET.ap","R.Apply","ET.flatMap","identity","ET.alt","E.getCompactable","compact_","separate_","E.Functor","E.getFilterable","filter_","filterMap_","partition_","partitionMap_","ap","ap_","E.getApplicativeValidation","alt","ET.altValidation","as_","asUnit_","flap_","apFirst_","apSecond_","chainable.tap","tapEither_","tapReader_","ask_","asks_","fromReaderK_","fromOption_","fromOptionK_","chainOptionK_","_.liftNullable","_.liftOption","_.flatMapNullable","_.flatMapOption","_.flatMapEither","_.flatMapReader","fromPredicate_","filterOrElse_","fromEitherK_","_.emptyRecord","bindTo_","let__","chainable.bind","apS_","_.emptyReadonlyArray","flow","R.traverseReadonlyNonEmptyArrayWithIndex","R.map","E.traverseReadonlyNonEmptyArrayWithIndex","SK","as","_.isNonEmpty","getApplySemigroup_","getApplicativeMonoid","E.getSemigroup"],"mappings":"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","x_google_ignoreList":[0]}