@slicemachine/manager 0.22.2-alpha.dani-repeatable-links-codegen.2 → 0.22.2-alpha.dani-repeatable-links-warning.1

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

@@ -1 +0,0 @@
-{"version":3,"file":"ReaderTaskEither.js","sources":["../../../../../../node_modules/fp-ts/es6/ReaderTaskEither.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 { ask as ask_, asks as asks_, fromReaderK as fromReaderK_, tapReader as tapReader_ } from './FromReader';\nimport { fromTaskK as fromTaskK_, tapTask as tapTask_ } from './FromTask';\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';\nimport * as RT from './ReaderTask';\nimport * as T from './Task';\nimport * as TE from './TaskEither';\n// -------------------------------------------------------------------------------------\n// constructors\n// -------------------------------------------------------------------------------------\n/**\n * @category conversions\n * @since 2.0.0\n */\nexport var fromTaskEither = /*#__PURE__*/ R.of;\n/**\n * @category constructors\n * @since 2.0.0\n */\nexport var left = /*#__PURE__*/ ET.left(RT.Pointed);\n/**\n * @category constructors\n * @since 2.0.0\n */\nexport var right = /*#__PURE__*/ ET.right(RT.Pointed);\n/**\n * @category constructors\n * @since 2.0.0\n */\nexport var rightTask = /*#__PURE__*/ flow(TE.rightTask, fromTaskEither);\n/**\n * @category constructors\n * @since 2.0.0\n */\nexport var leftTask = /*#__PURE__*/ flow(TE.leftTask, fromTaskEither);\n/**\n * @category constructors\n * @since 2.0.0\n */\nexport var rightReader = function (ma) {\n    return flow(ma, TE.right);\n};\n/**\n * @category constructors\n * @since 2.0.0\n */\nexport var leftReader = function (me) {\n    return flow(me, TE.left);\n};\n/**\n * @category constructors\n * @since 2.5.0\n */\nexport var rightReaderTask = \n/*#__PURE__*/ ET.rightF(RT.Functor);\n/**\n * @category constructors\n * @since 2.5.0\n */\nexport var leftReaderTask = \n/*#__PURE__*/ ET.leftF(RT.Functor);\n/**\n * @category constructors\n * @since 2.0.0\n */\nexport var rightIO = /*#__PURE__*/ flow(TE.rightIO, fromTaskEither);\n/**\n * @category constructors\n * @since 2.0.0\n */\nexport var leftIO = /*#__PURE__*/ flow(TE.leftIO, fromTaskEither);\n/**\n * @category constructors\n * @since 2.13.0\n */\nexport var rightReaderIO = /*#__PURE__*/ function (ma) { return flow(ma, TE.rightIO); };\n/**\n * @category constructors\n * @since 2.13.0\n */\nexport var leftReaderIO = /*#__PURE__*/ function (me) { return flow(me, TE.leftIO); };\n// -------------------------------------------------------------------------------------\n// conversions\n// -------------------------------------------------------------------------------------\n/**\n * @category conversions\n * @since 2.0.0\n */\nexport var fromEither = RT.of;\n/**\n * @category conversions\n * @since 2.11.0\n */\nexport var fromReader = rightReader;\n/**\n * @category conversions\n * @since 2.0.0\n */\nexport var fromIO = rightIO;\n/**\n * @category conversions\n * @since 2.0.0\n */\nexport var fromTask = rightTask;\n/**\n * @category conversions\n * @since 2.0.0\n */\nexport var fromIOEither = /*#__PURE__*/ flow(TE.fromIOEither, fromTaskEither);\n/**\n * @category conversions\n * @since 2.0.0\n */\nexport var fromReaderEither = function (ma) {\n    return flow(ma, TE.fromEither);\n};\n/**\n * @category pattern matching\n * @since 2.10.0\n */\nexport var match = /*#__PURE__*/ ET.match(RT.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 (`ReaderTask`).\n *\n * @category pattern matching\n * @since 2.10.0\n */\nexport var matchE = /*#__PURE__*/ ET.matchE(RT.Chain);\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(RT.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(RT.Functor);\n/**\n * @category conversions\n * @since 2.12.0\n */\nexport var fromNullable = \n/*#__PURE__*/ ET.fromNullable(RT.Pointed);\n/**\n * Use `liftNullable`.\n *\n * @category legacy\n * @since 2.12.0\n */\nexport var fromNullableK = /*#__PURE__*/ ET.fromNullableK(RT.Pointed);\n/**\n * Use `flatMapNullable`.\n *\n * @category legacy\n * @since 2.12.0\n */\nexport var chainNullableK = /*#__PURE__*/ ET.chainNullableK(RT.Monad);\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 [`asksReaderTaskEither`](#asksreadertaskeither).\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 asksReaderTaskEitherW = R.asksReaderW;\n/**\n * Effectfully accesses the environment.\n *\n * @category constructors\n * @since 2.11.0\n */\nexport var asksReaderTaskEither = asksReaderTaskEitherW;\n/**\n * @category error handling\n * @since 2.0.0\n */\nexport var orElse = /*#__PURE__*/ ET.orElse(RT.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(RT.Monad));\n/**\n * @category error handling\n * @since 2.11.0\n */\nexport var orLeft = /*#__PURE__*/ ET.orLeft(RT.Monad);\n/**\n * @since 2.0.0\n */\nexport var swap = /*#__PURE__*/ ET.swap(RT.Functor);\n/**\n * @category lifting\n * @since 2.4.0\n */\nexport var fromIOEitherK = function (f) { return flow(f, fromIOEither); };\n/**\n * @category lifting\n * @since 2.4.0\n */\nexport var fromTaskEitherK = function (f) { return flow(f, fromTaskEither); };\n/**\n * @category lifting\n * @since 2.11.0\n */\nexport var fromReaderEitherK = function (f) { return flow(f, fromReaderEither); };\nvar _map = function (fa, f) { return pipe(fa, map(f)); };\nvar _apPar = 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 = \n/*#__PURE__*/ ET.map(RT.Functor);\n/**\n * Returns a `ReaderTaskEither` whose failure and success channels have been mapped by the specified pair of functions, `f` and `g`.\n *\n * @example\n * import * as ReaderTaskEither from 'fp-ts/ReaderTaskEither'\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 * async function test() {\n *   assert.deepStrictEqual(await ReaderTaskEither.mapBoth(ReaderTaskEither.right(1), f, g)({})(), Either.right(2))\n *   assert.deepStrictEqual(await ReaderTaskEither.mapBoth(ReaderTaskEither.left('err'), f, g)({})(), Either.left(new Error('err')))\n * }\n *\n * test()\n *\n * @category error handling\n * @since 2.16.0\n */\nexport var mapBoth = /*#__PURE__*/ dual(3, ET.mapBoth(RT.Functor));\n/**\n * Alias of `mapBoth`.\n *\n * @category legacy\n * @since 2.0.0\n */\nexport var bimap = mapBoth;\n/**\n * Returns a `ReaderTaskEither` with its error channel mapped using the specified function.\n *\n * @example\n * import * as ReaderTaskEither from 'fp-ts/ReaderTaskEither'\n * import * as Either from 'fp-ts/Either'\n *\n * const f = (s: string) => new Error(s)\n *\n * async function test() {\n *   assert.deepStrictEqual(await ReaderTaskEither.mapError(ReaderTaskEither.right(1), f)({})(), Either.right(1))\n *   assert.deepStrictEqual(await ReaderTaskEither.mapError(ReaderTaskEither.left('err'), f)({})(), Either.left(new Error('err')))\n * }\n *\n * test()\n *\n * @category error handling\n * @since 2.16.0\n */\nexport var mapError = /*#__PURE__*/ dual(2, ET.mapError(RT.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(RT.ApplyPar);\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.7.0\n */\nexport var of = right;\n/**\n * @category sequencing\n * @since 2.14.0\n */\nexport var flatMap = /*#__PURE__*/ dual(2, ET.flatMap(RT.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 = /*#__PURE__*/ ET.alt(RT.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.0.0\n */\nexport var throwError = left;\n/**\n * @category type lambdas\n * @since 2.0.0\n */\nexport var URI = 'ReaderTaskEither';\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_(RT.Functor, C),\n        separate: separate_(RT.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_(RT.Functor, F);\n    var filterMap = filterMap_(RT.Functor, F);\n    var partition = partition_(RT.Functor, F);\n    var partitionMap = partitionMap_(RT.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 [`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 getApplicativeReaderTaskValidation(A, S) {\n    var ap = ap_(R.Apply, TE.getApplicativeTaskValidation(A, 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 getAltReaderTaskValidation(S) {\n    var alt = ET.altValidation(RT.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 `ReaderTaskEither` 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 `ReaderTaskEither` 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 * 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: _apPar\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 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_(ApplyPar);\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 * Runs computations in parallel.\n *\n * @category instances\n * @since 2.7.0\n */\nexport var ApplicativePar = {\n    URI: URI,\n    map: _map,\n    ap: _apPar,\n    of: of\n};\n/**\n * Runs computations sequentially.\n *\n * @category instances\n * @since 2.10.0\n */\nexport var ApplySeq = {\n    URI: URI,\n    map: _map,\n    ap: _apSeq\n};\n/**\n * Runs computations sequentially.\n *\n * @category instances\n * @since 2.7.0\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: _apPar,\n    chain: flatMap\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var Monad = {\n    URI: URI,\n    map: _map,\n    ap: _apPar,\n    chain: flatMap,\n    of: of\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var MonadIO = {\n    URI: URI,\n    map: _map,\n    ap: _apPar,\n    chain: flatMap,\n    of: of,\n    fromIO: fromIO\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var MonadTask = {\n    URI: URI,\n    map: _map,\n    ap: _apPar,\n    chain: flatMap,\n    of: of,\n    fromIO: fromIO,\n    fromTask: fromTask\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var MonadThrow = {\n    URI: URI,\n    map: _map,\n    ap: _apPar,\n    chain: flatMap,\n    of: of,\n    throwError: throwError\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 * @category instances\n * @since 2.10.0\n */\nexport var FromTask = {\n    URI: URI,\n    fromIO: fromIO,\n    fromTask: fromTask\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 RTE from 'fp-ts/ReaderTaskEither'\n *\n * const checkString = (value: string) => pipe(\n *   RTE.ask<number>(),\n *   RTE.tapEither((minLength) => value.length > minLength ? E.right('ok') : E.left('error'))\n * )\n *\n * async function test() {\n *   assert.deepStrictEqual(await checkString('')(2)(), E.left('error'))\n *   assert.deepStrictEqual(await checkString('fp-ts')(2)(), E.right(2))\n * }\n *\n * test()\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 * as RTE from 'fp-ts/ReaderTaskEither'\n * import * as E from 'fp-ts/Either'\n * import * as Console from 'fp-ts/Console'\n *\n *\n * // Will produce `Hello, fp-ts` to the stdout\n * const effect = RTE.tapIO(\n *   RTE.ask<string>(),\n *   (value) => Console.log(`Hello, ${value}`)\n * )\n *\n * async function test() {\n *   assert.deepStrictEqual(await effect('fp-ts')(), E.of('fp-ts'))\n * }\n *\n * test()\n *\n * @category combinators\n * @since 2.16.0\n */\nexport var tapIO = /*#__PURE__*/ dual(2, tapIO_(FromIO, 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 RTE from 'fp-ts/ReaderTaskEither'\n * import * as E from 'fp-ts/Either'\n * import * as T from 'fp-ts/Task'\n *\n *\n * const effect = RTE.tapTask(\n *   RTE.ask<number>(),\n *   (value) => T.of(value + 1)\n * )\n *\n * async function test() {\n *   assert.deepStrictEqual(await effect(1)(), E.of(1))\n * }\n *\n * test()\n *\n * @category combinators\n * @since 2.16.0\n */\nexport var tapTask = /*#__PURE__*/ dual(2, tapTask_(FromTask, 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 * 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 tapReaderEither = /*#__PURE__*/ dual(2, function (self, f) { return tap(self, fromReaderEitherK(f)); });\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 tapTaskEither = /*#__PURE__*/ dual(2, function (self, f) { return tap(self, fromTaskEitherK(f)); });\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 tapReaderTask = /*#__PURE__*/ dual(2, function (self, f) { return tap(self, fromReaderTaskK(f)); });\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 tapReaderIO = /*#__PURE__*/ dual(2, function (self, f) {\n    return tap(self, fromReaderIOK(f));\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 * @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 [`chainFirstReaderK`](#chainfirstreaderk).\n *\n * The `W` suffix (short for **W**idening) means that the environment types and the error types will be merged.\n *\n * @category legacy\n * @since 2.11.0\n */\nexport var chainFirstReaderKW = tapReader;\n/**\n * Alias of `tapReaderEither`.\n *\n * Less strict version of [`chainFirstReaderEitherK`](#chainfirstreadereitherk).\n *\n * The `W` suffix (short for **W**idening) means that the environment types and the error types will be merged.\n *\n * @category legacy\n * @since 2.11.0\n */\nexport var chainFirstReaderEitherKW = tapReaderEither;\n/**\n * Alias of `tapReaderEither`.\n *\n * @category legacy\n * @since 2.11.0\n */\nexport var chainFirstReaderEitherK = tapReaderEither;\n/**\n * Alias of `tapTaskEither`.\n *\n * Less strict version of [`chainFirstTaskEitherK`](#chainfirsttaskeitherk).\n *\n * The `W` suffix (short for **W**idening) means that the environment types and the error types will be merged.\n *\n * @category legacy\n * @since 2.11.0\n */\nexport var chainFirstTaskEitherKW = tapTaskEither;\n/**\n * Alias of `tapTaskEither`.\n *\n * @category legacy\n * @since 2.11.0\n */\nexport var chainFirstTaskEitherK = tapTaskEither;\n/**\n * @category lifting\n * @since 2.11.0\n */\nexport var fromReaderTaskK = function (f) {\n    return function () {\n        var a = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            a[_i] = arguments[_i];\n        }\n        return rightReaderTask(f.apply(void 0, a));\n    };\n};\n/**\n * Alias of `tapReaderTask`.\n *\n * Less strict version of [`chainFirstReaderTaskK`](#chainfirstreadertaskk).\n *\n * The `W` suffix (short for **W**idening) means that the environment types and the error types will be merged.\n *\n * @category legacy\n * @since 2.11.0\n */\nexport var chainFirstReaderTaskKW = tapReaderTask;\n/**\n * Alias of `tapReaderTask`.\n *\n * @category legacy\n * @since 2.11.0\n */\nexport var chainFirstReaderTaskK = tapReaderTask;\n/**\n * @category lifting\n * @since 2.13.0\n */\nexport var fromReaderIOK = function (f) {\n    return function () {\n        var a = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            a[_i] = arguments[_i];\n        }\n        return rightReaderIO(f.apply(void 0, a));\n    };\n};\n/**\n * Alias of `tapReaderIO`.\n *\n * Less strict version of [`chainFirstReaderIOK`](#chainfirstreaderiok).\n *\n * @category legacy\n * @since 2.13.0\n */\nexport var chainFirstReaderIOKW = tapReaderIO;\n/**\n * Alias of `tapReaderIO`.\n *\n * @category legacy\n * @since 2.13.0\n */\nexport var chainFirstReaderIOK = tapReaderIO;\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/**\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/** @internal */\nvar _FromIO = {\n    fromIO: fromIO\n};\n/** @internal */\nvar _FromTask = {\n    fromTask: fromTask\n};\n/** @internal */\nvar _FromReader = {\n    fromReader: fromReader\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 flatMapTaskEither = /*#__PURE__*/ dual(2, function (self, f) { return flatMap(self, fromTaskEitherK(f)); });\n/**\n * @category sequencing\n * @since 2.16.0\n */\nexport var flatMapReaderTask = /*#__PURE__*/ dual(2, function (self, f) { return flatMap(self, fromReaderTaskK(f)); });\n/**\n * @category sequencing\n * @since 2.16.0\n */\nexport var flatMapIO = /*#__PURE__*/ _.flatMapIO(_FromIO, _FlatMap);\n/**\n * @category sequencing\n * @since 2.16.0\n */\nexport var flatMapTask = /*#__PURE__*/ _.flatMapTask(_FromTask, _FlatMap);\n/**\n * @category sequencing\n * @since 2.16.0\n */\nexport var flatMapReader = /*#__PURE__*/ _.flatMapReader(_FromReader, _FlatMap);\n/**\n * @category sequencing\n * @since 2.16.0\n */\nexport var flatMapReaderIO = /*#__PURE__*/ dual(2, function (self, f) {\n    return flatMap(self, fromReaderIOK(f));\n});\n/**\n * @category sequencing\n * @since 2.16.0\n */\nexport var flatMapIOEither = /*#__PURE__*/ dual(2, function (self, f) {\n    return flatMap(self, fromIOEitherK(f));\n});\n/**\n * @category sequencing\n * @since 2.16.0\n */\nexport var flatMapReaderEither = /*#__PURE__*/ dual(2, function (self, f) { return flatMap(self, fromReaderEitherK(f)); });\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 and the error types will be merged.\n *\n * @category legacy\n * @since 2.12.0\n */\nexport var chainFirstEitherKW = tapEither;\n/**\n * Alias of `flatMapTaskEither`.\n *\n * Less strict version of [`chainTaskEitherK`](#chaintaskeitherk).\n *\n * The `W` suffix (short for **W**idening) means that the environment types and the error types will be merged.\n *\n * @category legacy\n * @since 2.6.1\n */\nexport var chainTaskEitherKW = flatMapTaskEither;\n/**\n * Alias of `flatMapTaskEither`.\n *\n * @category legacy\n * @since 2.4.0\n */\nexport var chainTaskEitherK = flatMapTaskEither;\n/**\n * Alias of `flatMapReaderTask`.\n *\n * Less strict version of [`chainReaderTaskK`](#chainreadertaskk).\n *\n * The `W` suffix (short for **W**idening) means that the environment types and the error types will be merged.\n *\n * @category legacy\n * @since 2.11.0\n */\nexport var chainReaderTaskKW = flatMapReaderTask;\n/**\n * Alias of `flatMapReaderTask`.\n *\n * @category legacy\n * @since 2.11.0\n */\nexport var chainReaderTaskK = flatMapReaderTask;\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 * @category lifting\n * @since 2.10.0\n */\nexport var fromIOK = /*#__PURE__*/ fromIOK_(FromIO);\n/**\n * Alias of `flatMapIO`.\n *\n * @category legacy\n * @since 2.10.0\n */\nexport var chainIOK = flatMapIO;\n/**\n * Alias of `tapIO`.\n *\n * @category legacy\n * @since 2.10.0\n */\nexport var chainFirstIOK = tapIO;\n/**\n * @category lifting\n * @since 2.10.0\n */\nexport var fromTaskK = /*#__PURE__*/ fromTaskK_(FromTask);\n/**\n * Alias of `flatMapTask`.\n *\n * @category legacy\n * @since 2.10.0\n */\nexport var chainTaskK = flatMapTask;\n/**\n * Alias of `tapTask`.\n * @category legacy\n * @since 2.10.0\n */\nexport var chainFirstTaskK = tapTask;\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 and the error types will be merged.\n *\n * @category legacy\n * @since 2.11.0\n */\nexport var chainReaderKW = flatMapReader;\n/**\n * Alias of `flatMapReaderIO`.\n *\n * Less strict version of [`chainReaderIOK`](#chainreaderiok).\n *\n * @category legacy\n * @since 2.13.0\n */\nexport var chainReaderIOKW = flatMapReaderIO;\n/**\n * Alias of `flatMapReaderIO`.\n *\n * @category legacy\n * @since 2.13.0\n */\nexport var chainReaderIOK = flatMapReaderIO;\n/**\n * Alias of `flatMapIOEither`.\n *\n * Less strict version of [`chainIOEitherK`](#chainioeitherk).\n *\n * The `W` suffix (short for **W**idening) means that the environment types and the error types will be merged.\n *\n * @category legacy\n * @since 2.6.1\n */\nexport var chainIOEitherKW = flatMapIOEither;\n/**\n * Alias of `flatMapIOEither`.\n *\n * @category legacy\n * @since 2.4.0\n */\nexport var chainIOEitherK = flatMapIOEither;\n/**\n * Alias of `flatMapReaderEither`.\n *\n * Less strict version of [`chainReaderEitherK`](#chainreadereitherk).\n *\n * The `W` suffix (short for **W**idening) means that the environment types and the error types will be merged.\n *\n * @category legacy\n * @since 2.11.0\n */\nexport var chainReaderEitherKW = flatMapReaderEither;\n/**\n * Alias of `flatMapReaderEither`.\n *\n * @category legacy\n * @since 2.11.0\n */\nexport var chainReaderEitherK = flatMapReaderEither;\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.4\n */\nexport function bracket(acquire, use, release) {\n    return bracketW(acquire, use, release);\n}\n/**\n * Less strict version of [`bracket`](#bracket).\n *\n * @since 2.12.0\n */\nexport function bracketW(acquire, use, release) {\n    return function (r) {\n        return TE.bracketW(acquire(r), function (a) { return use(a)(r); }, function (a, e) { return release(a, e)(r); });\n    };\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 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_(ApplyPar);\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(ApplicativePar)`.\n *\n * @category traversing\n * @since 2.11.0\n */\nexport var traverseReadonlyNonEmptyArrayWithIndex = function (f) {\n    return flow(R.traverseReadonlyNonEmptyArrayWithIndex(f), R.map(TE.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 flow(R.traverseReadonlyNonEmptyArrayWithIndex(f), R.map(TE.traverseReadonlyNonEmptyArrayWithIndexSeq(SK)));\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) {\n    return traverseReadonlyArrayWithIndex(function (_, a) { return f(a); });\n};\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 * 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) {\n    return traverseReadonlyArrayWithIndexSeq(function (_, a) { return f(a); });\n};\n/**\n * Equivalent to `ReadonlyArray#sequence(ApplicativeSeq)`.\n *\n * @category traversing\n * @since 2.9.0\n */\nexport var sequenceSeqArray = /*#__PURE__*/ traverseSeqArray(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 `RTE.Functor` instead of `RTE.readerTaskEither`\n * (where `RTE` is from `import RTE from 'fp-ts/ReaderTaskEither'`)\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var readerTaskEither = {\n    URI: URI,\n    map: _map,\n    of: of,\n    ap: _apPar,\n    chain: flatMap,\n    alt: _alt,\n    bimap: mapBoth,\n    mapLeft: mapError,\n    fromIO: fromIO,\n    fromTask: fromTask,\n    throwError: throwError\n};\n/**\n * This instance is deprecated, use small, specific instances instead.\n * For example if a function needs a `Functor` instance, pass `RTE.Functor` instead of `RTE.readerTaskEitherSeq`\n * (where `RTE` is from `import RTE from 'fp-ts/ReaderTaskEither'`)\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var readerTaskEitherSeq = {\n    URI: URI,\n    map: _map,\n    of: of,\n    ap: _apSeq,\n    chain: flatMap,\n    alt: _alt,\n    bimap: mapBoth,\n    mapLeft: mapError,\n    fromIO: fromIO,\n    fromTask: fromTask,\n    throwError: throwError\n};\n/**\n * Use [`getApplySemigroup`](./Apply.ts.html#getapplysemigroup) instead.\n *\n * Semigroup returning the left-most `Left` value. If both operands are `Right`s then the inner values\n * are concatenated using the provided `Semigroup`\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getApplySemigroup = \n/*#__PURE__*/ getApplySemigroup_(ApplySeq);\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(ApplicativeSeq);\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_(RT.ApplySeq)(E.getSemigroup(S));\n};\n/**\n * Use [`getApplicativeReaderTaskValidation`](#getapplicativereadertaskvalidation) and [`getAltReaderTaskValidation`](#getaltreadertaskvalidation) instead.\n *\n * @category instances\n * @since 2.3.0\n * @deprecated\n */\nexport function getReaderTaskValidation(SE) {\n    var applicativeReaderTaskValidation = getApplicativeReaderTaskValidation(T.ApplicativePar, SE);\n    var altReaderTaskValidation = getAltReaderTaskValidation(SE);\n    return {\n        URI: URI,\n        _E: undefined,\n        map: _map,\n        of: of,\n        chain: flatMap,\n        bimap: mapBoth,\n        mapLeft: mapError,\n        ap: applicativeReaderTaskValidation.ap,\n        alt: altReaderTaskValidation.alt,\n        fromIO: fromIO,\n        fromTask: fromTask,\n        throwError: throwError\n    };\n}\n/**\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\n/* istanbul ignore next */\nexport function run(ma, r) {\n    return ma(r)();\n}\n"],"names":["R.of","ET.left","RT.Pointed","ET.right","TE.rightTask","TE.leftTask","TE.right","TE.left","ET.rightF","RT.Functor","ET.leftF","TE.rightIO","TE.leftIO","RT.of","TE.fromIOEither","TE.fromEither","ET.match","ET.matchE","RT.Chain","ET.getOrElse","RT.Monad","ET.toUnion","ET.fromNullable","ET.fromNullableK","ET.chainNullableK","R.local","R.asksReaderW","ET.orElse","ET.tapError","ET.orLeft","ET.swap","ET.map","ET.mapBoth","ET.mapError","ET.ap","RT.ApplyPar","ET.flatMap","ET.alt","E.getCompactable","compact_","separate_","E.Functor","E.getFilterable","filter","filter_","filterMap","filterMap_","partition","partition_","partitionMap","partitionMap_","ap","ap_","R.Apply","TE.getApplicativeTaskValidation","alt","ET.altValidation","as_","asUnit_","flap_","apFirst_","apSecond_","chainable.tap","tapEither_","tapIO_","tapTask_","tapReader_","ask_","asks_","fromReaderK_","fromOption_","fromOptionK_","chainOptionK_","_.liftNullable","_.liftOption","_.flatMapNullable","_.flatMapOption","_.flatMapEither","_.flatMapIO","_.flatMapTask","_.flatMapReader","fromPredicate_","filterOrElse_","fromEitherK_","fromIOK_","fromTaskK_","TE.bracketW","_.emptyRecord","bindTo_","let__","chainable.bind","apS_","_.emptyReadonlyArray","R.traverseReadonlyNonEmptyArrayWithIndex","R.map","TE.traverseReadonlyNonEmptyArrayWithIndex","as","_.isNonEmpty","TE.traverseReadonlyNonEmptyArrayWithIndexSeq","getApplySemigroup_","RT.ApplySeq","E.getSemigroup","T.ApplicativePar"],"mappings":"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","x_google_ignoreList":[0]}