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

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1995) hide show

package/dist/_node_modules/fp-ts/es6/Either.cjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"Either.cjs","sources":["../../../../../../node_modules/fp-ts/es6/Either.js"],"sourcesContent":["import { getApplicativeMonoid } from './Applicative';\nimport { apFirst as apFirst_, apS as apS_, apSecond as apSecond_, getApplySemigroup as getApplySemigroup_ } from './Apply';\nimport * as chainable from './Chain';\nimport { tailRec } from './ChainRec';\nimport { chainOptionK as chainOptionK_, filterOrElse as filterOrElse_, fromOption as fromOption_, fromOptionK as fromOptionK_, fromPredicate as fromPredicate_ } from './FromEither';\nimport { dual, flow, identity, pipe } 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 { separated } from './Separated';\nimport { wiltDefault, witherDefault } from './Witherable';\n// -------------------------------------------------------------------------------------\n// constructors\n// -------------------------------------------------------------------------------------\n/*\n Constructs a new `Either` holding a `Left` value. This usually represents a failure, due to the right-bias of this\n * structure.\n \n @category constructors\n * @since 2.0.0\n /\nexport var left = _.left;\n/\n Constructs a new `Either` holding a `Right` value. This usually represents a successful value due to the right bias\n * of this structure.\n \n @category constructors\n * @since 2.0.0\n /\nexport var right = _.right;\n/\n @category sequencing\n * @since 2.14.0\n /\nexport var flatMap = /#__PURE__/ dual(2, function (ma, f) { return (isLeft(ma) ? ma : f(ma.right)); });\nvar _map = function (fa, f) { return pipe(fa, map(f)); };\nvar _ap = function (fab, fa) { return pipe(fab, ap(fa)); };\n/ istanbul ignore next /\nvar _reduce = function (fa, b, f) { return pipe(fa, reduce(b, f)); };\n/ istanbul ignore next /\nvar _foldMap = function (M) { return function (fa, f) {\n var foldMapM = foldMap(M);\n return pipe(fa, foldMapM(f));\n}; };\n/ istanbul ignore next /\nvar _reduceRight = function (fa, b, f) { return pipe(fa, reduceRight(b, f)); };\nvar _traverse = function (F) {\n var traverseF = traverse(F);\n return function (ta, f) { return pipe(ta, traverseF(f)); };\n};\nvar _bimap = function (fa, f, g) { return pipe(fa, bimap(f, g)); };\nvar _mapLeft = function (fa, f) { return pipe(fa, mapLeft(f)); };\n/ istanbul ignore next /\nvar _alt = function (fa, that) { return pipe(fa, alt(that)); };\n/ istanbul ignore next /\nvar _extend = function (wa, f) { return pipe(wa, extend(f)); };\nvar _chainRec = function (a, f) {\n return tailRec(f(a), function (e) {\n return isLeft(e) ? right(left(e.left)) : isLeft(e.right) ? left(f(e.right.left)) : right(right(e.right.right));\n });\n};\n/\n @category type lambdas\n * @since 2.0.0\n /\nexport var URI = 'Either';\n/\n @category instances\n * @since 2.0.0\n /\nexport var getShow = function (SE, SA) { return ({\n show: function (ma) { return (isLeft(ma) ? \"left(\".concat(SE.show(ma.left), \")\") : \"right(\".concat(SA.show(ma.right), \")\")); }\n}); };\n/\n @category instances\n * @since 2.0.0\n /\nexport var getEq = function (EL, EA) { return ({\n equals: function (x, y) {\n return x === y \|\| (isLeft(x) ? isLeft(y) && EL.equals(x.left, y.left) : isRight(y) && EA.equals(x.right, y.right));\n }\n}); };\n/\n Semigroup returning the left-most non-`Left` value. If both operands are `Right`s then the inner values are\n * concatenated using the provided `Semigroup`\n \n @example\n * import { getSemigroup, left, right } from 'fp-ts/Either'\n * import { SemigroupSum } from 'fp-ts/number'\n \n const S = getSemigroup<string, number>(SemigroupSum)\n * assert.deepStrictEqual(S.concat(left('a'), left('b')), left('a'))\n * assert.deepStrictEqual(S.concat(left('a'), right(2)), right(2))\n * assert.deepStrictEqual(S.concat(right(1), left('b')), right(1))\n * assert.deepStrictEqual(S.concat(right(1), right(2)), right(3))\n \n @category instances\n * @since 2.0.0\n /\nexport var getSemigroup = function (S) { return ({\n concat: function (x, y) { return (isLeft(y) ? x : isLeft(x) ? y : right(S.concat(x.right, y.right))); }\n}); };\n/\n Builds a `Compactable` instance for `Either` given `Monoid` for the left side.\n \n @category filtering\n * @since 2.10.0\n /\nexport var getCompactable = function (M) {\n var empty = left(M.empty);\n return {\n URI: URI,\n _E: undefined,\n compact: function (ma) { return (isLeft(ma) ? ma : ma.right._tag === 'None' ? empty : right(ma.right.value)); },\n separate: function (ma) {\n return isLeft(ma)\n ? separated(ma, ma)\n : isLeft(ma.right)\n ? separated(right(ma.right.left), empty)\n : separated(empty, right(ma.right.right));\n }\n };\n};\n/\n Builds a `Filterable` instance for `Either` given `Monoid` for the left side\n \n @category filtering\n * @since 2.10.0\n /\nexport var getFilterable = function (M) {\n var empty = left(M.empty);\n var _a = getCompactable(M), compact = _a.compact, separate = _a.separate;\n var filter = function (ma, predicate) {\n return isLeft(ma) ? ma : predicate(ma.right) ? ma : empty;\n };\n var partition = function (ma, p) {\n return isLeft(ma)\n ? separated(ma, ma)\n : p(ma.right)\n ? separated(empty, right(ma.right))\n : separated(right(ma.right), empty);\n };\n return {\n URI: URI,\n _E: undefined,\n map: _map,\n compact: compact,\n separate: separate,\n filter: filter,\n filterMap: function (ma, f) {\n if (isLeft(ma)) {\n return ma;\n }\n var ob = f(ma.right);\n return ob._tag === 'None' ? empty : right(ob.value);\n },\n partition: partition,\n partitionMap: function (ma, f) {\n if (isLeft(ma)) {\n return separated(ma, ma);\n }\n var e = f(ma.right);\n return isLeft(e) ? separated(right(e.left), empty) : separated(empty, right(e.right));\n }\n };\n};\n/\n Builds `Witherable` instance for `Either` given `Monoid` for the left side\n \n @category filtering\n * @since 2.0.0\n /\nexport var getWitherable = function (M) {\n var F_ = getFilterable(M);\n var C = getCompactable(M);\n return {\n URI: URI,\n _E: undefined,\n map: _map,\n compact: F_.compact,\n separate: F_.separate,\n filter: F_.filter,\n filterMap: F_.filterMap,\n partition: F_.partition,\n partitionMap: F_.partitionMap,\n traverse: _traverse,\n sequence: sequence,\n reduce: _reduce,\n foldMap: _foldMap,\n reduceRight: _reduceRight,\n wither: witherDefault(Traversable, C),\n wilt: wiltDefault(Traversable, C)\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 @example\n * import * as A from 'fp-ts/Apply'\n * import * as E from 'fp-ts/Either'\n * import { pipe } from 'fp-ts/function'\n * import * as S from 'fp-ts/Semigroup'\n * import * as string from 'fp-ts/string'\n \n const parseString = (u: unknown): E.Either<string, string> =>\n * typeof u === 'string' ? E.right(u) : E.left('not a string')\n \n const parseNumber = (u: unknown): E.Either<string, number> =>\n * typeof u === 'number' ? E.right(u) : E.left('not a number')\n \n interface Person {\n * readonly name: string\n * readonly age: number\n * }\n \n const parsePerson = (\n * input: Record<string, unknown>\n * ): E.Either<string, Person> =>\n * pipe(\n * E.Do,\n * E.apS('name', parseString(input.name)),\n * E.apS('age', parseNumber(input.age))\n * )\n \n assert.deepStrictEqual(parsePerson({}), E.left('not a string')) // <= first error\n \n const Applicative = E.getApplicativeValidation(\n * pipe(string.Semigroup, S.intercalate(', '))\n * )\n \n const apS = A.apS(Applicative)\n \n const parsePersonAll = (\n * input: Record<string, unknown>\n * ): E.Either<string, Person> =>\n * pipe(\n * E.Do,\n * apS('name', parseString(input.name)),\n * apS('age', parseNumber(input.age))\n * )\n \n assert.deepStrictEqual(parsePersonAll({}), E.left('not a string, not a number')) // <= all errors\n \n @category error handling\n * @since 2.7.0\n /\nexport var getApplicativeValidation = function (SE) { return ({\n URI: URI,\n _E: undefined,\n map: _map,\n ap: function (fab, fa) {\n return isLeft(fab)\n ? isLeft(fa)\n ? left(SE.concat(fab.left, fa.left))\n : fab\n : isLeft(fa)\n ? fa\n : right(fab.right(fa.right));\n },\n of: of\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 @example\n * import * as E from 'fp-ts/Either'\n * import { pipe } from 'fp-ts/function'\n * import * as S from 'fp-ts/Semigroup'\n * import * as string from 'fp-ts/string'\n \n const parseString = (u: unknown): E.Either<string, string> =>\n * typeof u === 'string' ? E.right(u) : E.left('not a string')\n \n const parseNumber = (u: unknown): E.Either<string, number> =>\n * typeof u === 'number' ? E.right(u) : E.left('not a number')\n \n const parse = (u: unknown): E.Either<string, string \| number> =>\n * pipe(\n * parseString(u),\n * E.alt<string, string \| number>(() => parseNumber(u))\n * )\n \n assert.deepStrictEqual(parse(true), E.left('not a number')) // <= last error\n \n const Alt = E.getAltValidation(pipe(string.Semigroup, S.intercalate(', ')))\n \n const parseAll = (u: unknown): E.Either<string, string \| number> =>\n * Alt.alt<string \| number>(parseString(u), () => parseNumber(u))\n \n assert.deepStrictEqual(parseAll(true), E.left('not a string, not a number')) // <= all errors\n \n @category error handling\n * @since 2.7.0\n /\nexport var getAltValidation = function (SE) { return ({\n URI: URI,\n _E: undefined,\n map: _map,\n alt: function (me, that) {\n if (isRight(me)) {\n return me;\n }\n var ea = that();\n return isLeft(ea) ? left(SE.concat(me.left, ea.left)) : ea;\n }\n}); };\n/\n @category mapping\n * @since 2.0.0\n /\nexport var map = function (f) { return function (fa) {\n return isLeft(fa) ? fa : right(f(fa.right));\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 `Either` 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 `Either` to the void constant value.\n \n @category mapping\n * @since 2.16.0\n /\nexport var asUnit = asUnit_(Functor);\n/\n @category constructors\n * @since 2.7.0\n /\nexport var of = right;\n/\n @category instances\n * @since 2.10.0\n /\nexport var Pointed = {\n URI: URI,\n of: of\n};\n/\n Less strict version of [`ap`](#ap).\n \n The `W` suffix (short for Widening) means that the error types will be merged.\n \n @since 2.8.0\n /\nexport var apW = function (fa) { return function (fab) {\n return isLeft(fab) ? fab : isLeft(fa) ? fa : right(fab.right(fa.right));\n}; };\n/\n @since 2.0.0\n /\nexport var ap = apW;\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 @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 Left-associative fold of a structure.\n \n @example\n * import { pipe } from 'fp-ts/function'\n * import * as E from 'fp-ts/Either'\n \n const startWith = 'prefix'\n * const concat = (a: string, b: string) => `${a}:${b}`\n \n assert.deepStrictEqual(\n * pipe(E.right('a'), E.reduce(startWith, concat)),\n * 'prefix:a'\n * )\n \n assert.deepStrictEqual(\n * pipe(E.left('e'), E.reduce(startWith, concat)),\n * 'prefix'\n * )\n \n @category folding\n * @since 2.0.0\n /\nexport var reduce = function (b, f) { return function (fa) {\n return isLeft(fa) ? b : f(b, fa.right);\n}; };\n/\n Map each element of the structure to a monoid, and combine the results.\n \n @example\n * import { pipe } from 'fp-ts/function'\n * import * as E from 'fp-ts/Either'\n * import * as S from 'fp-ts/string'\n \n const yell = (a: string) => `${a}!`\n \n assert.deepStrictEqual(\n * pipe(E.right('a'), E.foldMap(S.Monoid)(yell)),\n * 'a!'\n * )\n \n assert.deepStrictEqual(\n * pipe(E.left('e'), E.foldMap(S.Monoid)(yell)),\n * S.Monoid.empty\n * )\n \n @category folding\n * @since 2.0.0\n /\nexport var foldMap = function (M) { return function (f) { return function (fa) {\n return isLeft(fa) ? M.empty : f(fa.right);\n}; }; };\n/\n Right-associative fold of a structure.\n \n @example\n * import { pipe } from 'fp-ts/function'\n * import * as E from 'fp-ts/Either'\n \n const startWith = 'postfix'\n * const concat = (a: string, b: string) => `${a}:${b}`\n \n assert.deepStrictEqual(\n * pipe(E.right('a'), E.reduceRight(startWith, concat)),\n * 'a:postfix'\n * )\n \n assert.deepStrictEqual(\n * pipe(E.left('e'), E.reduceRight(startWith, concat)),\n * 'postfix'\n * )\n \n @category folding\n * @since 2.0.0\n /\nexport var reduceRight = function (b, f) { return function (fa) {\n return isLeft(fa) ? b : f(fa.right, b);\n}; };\n/\n @category instances\n * @since 2.7.0\n /\nexport var Foldable = {\n URI: URI,\n reduce: _reduce,\n foldMap: _foldMap,\n reduceRight: _reduceRight\n};\n/\n Map each element of a structure to an action, evaluate these actions from left to right, and collect the results.\n \n @example\n * import { pipe } from 'fp-ts/function'\n * import * as RA from 'fp-ts/ReadonlyArray'\n * import * as E from 'fp-ts/Either'\n * import * as O from 'fp-ts/Option'\n \n assert.deepStrictEqual(\n * pipe(E.right(['a']), E.traverse(O.Applicative)(RA.head)),\n * O.some(E.right('a'))\n * )\n \n assert.deepStrictEqual(\n * pipe(E.right([]), E.traverse(O.Applicative)(RA.head)),\n * O.none\n * )\n \n @category traversing\n * @since 2.6.3\n /\nexport var traverse = function (F) {\n return function (f) {\n return function (ta) {\n return isLeft(ta) ? F.of(left(ta.left)) : F.map(f(ta.right), right);\n };\n };\n};\n/\n Evaluate each monadic action in the structure from left to right, and collect the results.\n \n @example\n * import { pipe } from 'fp-ts/function'\n * import * as E from 'fp-ts/Either'\n * import * as O from 'fp-ts/Option'\n \n assert.deepStrictEqual(\n * pipe(E.right(O.some('a')), E.sequence(O.Applicative)),\n * O.some(E.right('a'))\n * )\n \n assert.deepStrictEqual(\n * pipe(E.right(O.none), E.sequence(O.Applicative)),\n * O.none\n * )\n \n @category traversing\n * @since 2.6.3\n /\nexport var sequence = function (F) {\n return function (ma) {\n return isLeft(ma) ? F.of(left(ma.left)) : F.map(ma.right, right);\n };\n};\n/\n @category instances\n * @since 2.7.0\n /\nexport var Traversable = {\n URI: URI,\n map: _map,\n reduce: _reduce,\n foldMap: _foldMap,\n reduceRight: _reduceRight,\n traverse: _traverse,\n sequence: sequence\n};\n/\n Map a pair of functions over the two type arguments of the bifunctor.\n \n @category mapping\n * @since 2.0.0\n /\nexport var bimap = function (f, g) { return function (fa) {\n return isLeft(fa) ? left(f(fa.left)) : right(g(fa.right));\n}; };\n/\n Map a function over the first type argument of a bifunctor.\n \n @category error handling\n * @since 2.0.0\n /\nexport var mapLeft = function (f) { return function (fa) {\n return isLeft(fa) ? left(f(fa.left)) : fa;\n}; };\n/\n @category instances\n * @since 2.7.0\n /\nexport var Bifunctor = {\n URI: URI,\n bimap: _bimap,\n mapLeft: _mapLeft\n};\n/\n Less strict version of [`alt`](#alt).\n \n The `W` suffix (short for Widening) 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 = function (that) { return function (fa) {\n return isLeft(fa) ? that() : fa;\n}; };\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 * In case of `Either` returns the left-most non-`Left` value (or the right-most `Left` value if both values are `Left`).\n \n \| x \| y \| pipe(x, alt(() => y) \|\n * \| -------- \| -------- \| -------------------- \|\n * \| left(a) \| left(b) \| left(b) \|\n * \| left(a) \| right(2) \| right(2) \|\n * \| right(1) \| left(b) \| right(1) \|\n * \| right(1) \| right(2) \| right(1) \|\n \n @example\n * import * as E from 'fp-ts/Either'\n * import { pipe } from 'fp-ts/function'\n \n assert.deepStrictEqual(\n * pipe(\n * E.left('a'),\n * E.alt(() => E.left('b'))\n * ),\n * E.left('b')\n * )\n * assert.deepStrictEqual(\n * pipe(\n * E.left('a'),\n * E.alt(() => E.right(2))\n * ),\n * E.right(2)\n * )\n * assert.deepStrictEqual(\n * pipe(\n * E.right(1),\n * E.alt(() => E.left('b'))\n * ),\n * E.right(1)\n * )\n * assert.deepStrictEqual(\n * pipe(\n * E.right(1),\n * E.alt(() => E.right(2))\n * ),\n * E.right(1)\n * )\n \n @category error handling\n * @since 2.0.0\n /\nexport var alt = altW;\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 @since 2.0.0\n /\nexport var extend = function (f) { return function (wa) {\n return isLeft(wa) ? wa : right(f(wa));\n}; };\n/\n @category instances\n * @since 2.7.0\n /\nexport var Extend = {\n URI: URI,\n map: _map,\n extend: _extend\n};\n/\n @category instances\n * @since 2.7.0\n /\nexport var ChainRec = {\n URI: URI,\n map: _map,\n ap: _ap,\n chain: flatMap,\n chainRec: _chainRec\n};\n/\n @since 2.6.3\n /\nexport var throwError = left;\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 instances\n * @since 2.10.0\n /\nexport var FromEither = {\n URI: URI,\n fromEither: identity\n};\n/\n @example\n * import { fromPredicate, left, right } from 'fp-ts/Either'\n * import { pipe } from 'fp-ts/function'\n \n assert.deepStrictEqual(\n * pipe(\n * 1,\n * fromPredicate(\n * (n) => n > 0,\n * () => 'error'\n * )\n * ),\n * right(1)\n * )\n * assert.deepStrictEqual(\n * pipe(\n * -1,\n * fromPredicate(\n * (n) => n > 0,\n * () => 'error'\n * )\n * ),\n * left('error')\n * )\n \n @category lifting\n * @since 2.0.0\n /\nexport var fromPredicate = /#__PURE__/ fromPredicate_(FromEither);\n// -------------------------------------------------------------------------------------\n// conversions\n// -------------------------------------------------------------------------------------\n/\n @example\n * import * as E from 'fp-ts/Either'\n * import { pipe } from 'fp-ts/function'\n * import * as O from 'fp-ts/Option'\n \n assert.deepStrictEqual(\n * pipe(\n * O.some(1),\n * E.fromOption(() => 'error')\n * ),\n * E.right(1)\n * )\n * assert.deepStrictEqual(\n * pipe(\n * O.none,\n * E.fromOption(() => 'error')\n * ),\n * E.left('error')\n * )\n \n @category conversions\n * @since 2.0.0\n /\nexport var fromOption = \n/#__PURE__/ fromOption_(FromEither);\n// -------------------------------------------------------------------------------------\n// refinements\n// -------------------------------------------------------------------------------------\n/\n Returns `true` if the either is an instance of `Left`, `false` otherwise.\n \n @category refinements\n * @since 2.0.0\n /\nexport var isLeft = _.isLeft;\n/\n Returns `true` if the either is an instance of `Right`, `false` otherwise.\n \n @category refinements\n * @since 2.0.0\n /\nexport var isRight = _.isRight;\n/\n Less strict version of [`match`](#match).\n \n The `W` suffix (short for Widening) means that the handler return types will be merged.\n \n @category pattern matching\n * @since 2.10.0\n /\nexport var matchW = function (onLeft, onRight) {\n return function (ma) {\n return isLeft(ma) ? onLeft(ma.left) : onRight(ma.right);\n };\n};\n/\n Alias of [`matchW`](#matchw).\n \n @category pattern matching\n * @since 2.10.0\n /\nexport var foldW = matchW;\n/\n Takes two functions and an `Either` value, if the value is a `Left` the inner value is applied to the first function,\n * if the value is a `Right` the inner value is applied to the second function.\n \n @example\n * import { match, left, right } from 'fp-ts/Either'\n * import { pipe } from 'fp-ts/function'\n \n function onLeft(errors: Array<string>): string {\n * return `Errors: ${errors.join(', ')}`\n * }\n \n function onRight(value: number): string {\n * return `Ok: ${value}`\n * }\n \n assert.strictEqual(\n * pipe(\n * right(1),\n * match(onLeft, onRight)\n * ),\n * 'Ok: 1'\n * )\n * assert.strictEqual(\n * pipe(\n * left(['error 1', 'error 2']),\n * match(onLeft, onRight)\n * ),\n * 'Errors: error 1, error 2'\n * )\n \n @category pattern matching\n * @since 2.10.0\n /\nexport var match = matchW;\n/\n Alias of [`match`](#match).\n \n @category pattern matching\n * @since 2.0.0\n /\nexport var fold = match;\n/\n Less strict version of [`getOrElse`](#getorelse).\n \n The `W` suffix (short for Widening) means that the handler return type will be merged.\n \n @category error handling\n * @since 2.6.0\n /\nexport var getOrElseW = function (onLeft) {\n return function (ma) {\n return isLeft(ma) ? onLeft(ma.left) : ma.right;\n };\n};\n/\n Returns the wrapped value if it's a `Right` or a default value if is a `Left`.\n \n @example\n * import { getOrElse, left, right } from 'fp-ts/Either'\n * import { pipe } from 'fp-ts/function'\n \n assert.deepStrictEqual(\n * pipe(\n * right(1),\n * getOrElse(() => 0)\n * ),\n * 1\n * )\n * assert.deepStrictEqual(\n * pipe(\n * left('error'),\n * getOrElse(() => 0)\n * ),\n * 0\n * )\n \n @category error handling\n * @since 2.0.0\n /\nexport var getOrElse = getOrElseW;\n// -------------------------------------------------------------------------------------\n// combinators\n// -------------------------------------------------------------------------------------\n/\n @category mapping\n * @since 2.10.0\n /\nexport var flap = /#__PURE__/ flap_(Functor);\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 Widening) 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_(Apply);\n/\n Less strict version of [`apSecond`](#apsecond)\n \n The `W` suffix (short for Widening) means that the error types will be merged.\n \n @since 2.12.0\n /\nexport var apSecondW = apSecond;\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 Less strict version of [`flatten`](#flatten).\n \n The `W` suffix (short for Widening) 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 The `flatten` function is the conventional monad join operator. It is used to remove one level of monadic structure, projecting its bound argument into the outer level.\n \n @example\n * import * as E from 'fp-ts/Either'\n \n assert.deepStrictEqual(E.flatten(E.right(E.right('a'))), E.right('a'))\n * assert.deepStrictEqual(E.flatten(E.right(E.left('e'))), E.left('e'))\n * assert.deepStrictEqual(E.flatten(E.left('e')), E.left('e'))\n \n @category sequencing\n * @since 2.0.0\n /\nexport var flatten = flattenW;\n/\n @since 2.0.0\n /\nexport var duplicate = /#__PURE__/ extend(identity);\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.11.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 = /#__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/\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 @example\n * import * as E from 'fp-ts/Either'\n * import { pipe } from 'fp-ts/function'\n \n assert.deepStrictEqual(\n * pipe(\n * E.right(1),\n * E.filterOrElse(\n * (n) => n > 0,\n * () => 'error'\n * )\n * ),\n * E.right(1)\n * )\n * assert.deepStrictEqual(\n * pipe(\n * E.right(-1),\n * E.filterOrElse(\n * (n) => n > 0,\n * () => 'error'\n * )\n * ),\n * E.left('error')\n * )\n * assert.deepStrictEqual(\n * pipe(\n * E.left('a'),\n * E.filterOrElse(\n * (n) => n > 0,\n * () => 'error'\n * )\n * ),\n * E.left('a')\n * )\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 Widening) means that the error types will be merged.\n \n @category filtering\n * @since 2.9.0\n /\nexport var filterOrElseW = filterOrElse;\n/\n Returns a `Right` if is a `Left` (and vice versa).\n \n @since 2.0.0\n /\nexport var swap = function (ma) { return (isLeft(ma) ? right(ma.left) : left(ma.right)); };\n/\n Less strict version of [`orElse`](#orelse).\n \n The `W` suffix (short for Widening) means that the return types will be merged.\n \n @category error handling\n * @since 2.10.0\n /\nexport var orElseW = function (onLeft) {\n return function (ma) {\n return isLeft(ma) ? onLeft(ma.left) : ma;\n };\n};\n/\n Useful for recovering from errors.\n \n @category error handling\n * @since 2.0.0\n /\nexport var orElse = orElseW;\n/\n Takes a default and a nullable value, if the value is not nully, turn it into a `Right`, if the value is nully use\n * the provided default as a `Left`.\n \n @example\n * import { fromNullable, left, right } from 'fp-ts/Either'\n \n const parse = fromNullable('nully')\n \n assert.deepStrictEqual(parse(1), right(1))\n * assert.deepStrictEqual(parse(null), left('nully'))\n \n @category conversions\n * @since 2.0.0\n /\nexport var fromNullable = function (e) {\n return function (a) {\n return a == null ? left(e) : right(a);\n };\n};\n/\n Constructs a new `Either` from a function that might throw.\n \n See also [`tryCatchK`](#trycatchk).\n \n @example\n * import * as E from 'fp-ts/Either'\n \n const unsafeHead = <A>(as: ReadonlyArray<A>): A => {\n * if (as.length > 0) {\n * return as[0]\n * } else {\n * throw new Error('empty array')\n * }\n * }\n \n const head = <A>(as: ReadonlyArray<A>): E.Either<Error, A> =>\n * E.tryCatch(() => unsafeHead(as), e => (e instanceof Error ? e : new Error('unknown error')))\n \n assert.deepStrictEqual(head([]), E.left(new Error('empty array')))\n * assert.deepStrictEqual(head([1, 2, 3]), E.right(1))\n \n @category interop\n * @since 2.0.0\n /\nexport var tryCatch = function (f, onThrow) {\n try {\n return right(f());\n }\n catch (e) {\n return left(onThrow(e));\n }\n};\n/\n Converts a function that may throw to one returning a `Either`.\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 Use `liftNullable`.\n \n @category legacy\n * @since 2.9.0\n /\nexport var fromNullableK = function (e) {\n var from = fromNullable(e);\n return function (f) { return flow(f, from); };\n};\n/\n Use `flatMapNullable`.\n \n @category legacy\n * @since 2.9.0\n /\nexport var chainNullableK = function (e) {\n var from = fromNullableK(e);\n return function (f) { return flatMap(from(f)); };\n};\n/\n @category conversions\n * @since 2.10.0\n /\nexport var toUnion = /#__PURE__/ foldW(identity, identity);\n// -------------------------------------------------------------------------------------\n// utils\n// -------------------------------------------------------------------------------------\n/\n Default value for the `onError` argument of `tryCatch`\n \n @since 2.0.0\n /\nexport function toError(e) {\n return e instanceof Error ? e : new Error(String(e));\n}\nexport function elem(E) {\n return function (a, ma) {\n if (ma === undefined) {\n var elemE_1 = elem(E);\n return function (ma) { return elemE_1(a, ma); };\n }\n return isLeft(ma) ? false : E.equals(a, ma.right);\n };\n}\n/\n Returns `false` if `Left` or returns the result of the application of the given predicate to the `Right` value.\n \n @example\n * import { exists, left, right } from 'fp-ts/Either'\n \n const gt2 = exists((n: number) => n > 2)\n \n assert.strictEqual(gt2(left('a')), false)\n * assert.strictEqual(gt2(right(1)), false)\n * assert.strictEqual(gt2(right(3)), true)\n \n @since 2.0.0\n /\nexport var exists = function (predicate) {\n return function (ma) {\n return isLeft(ma) ? false : predicate(ma.right);\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 Widening) 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_(Apply);\n/\n Less strict version of [`apS`](#aps).\n \n The `W` suffix (short for Widening) 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(Applicative)`.\n \n @category traversing\n * @since 2.11.0\n /\nexport var traverseReadonlyNonEmptyArrayWithIndex = function (f) {\n return function (as) {\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 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 = \n/#__PURE__/ traverseArray(identity);\n// -------------------------------------------------------------------------------------\n// legacy\n// -------------------------------------------------------------------------------------\n/\n Alias of `flatMap`.\n \n @category legacy\n * @since 2.6.0\n /\nexport var chainW = flatMap;\n/\n Alias of `flatMap`.\n \n @category legacy\n * @since 2.0.0\n /\nexport var chain = 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 Use [`parse`](./Json.ts.html#parse) instead.\n \n @category zone of death\n * @since 2.0.0\n * @deprecated\n /\nexport function parseJSON(s, onError) {\n return tryCatch(function () { return JSON.parse(s); }, onError);\n}\n/\n Use [`stringify`](./Json.ts.html#stringify) instead.\n \n @category zone of death\n * @since 2.0.0\n * @deprecated\n /\nexport var stringifyJSON = function (u, onError) {\n return tryCatch(function () {\n var s = JSON.stringify(u);\n if (typeof s !== 'string') {\n throw new Error('Converting unsupported structure to JSON');\n }\n return s;\n }, onError);\n};\n/\n This instance is deprecated, use small, specific instances instead.\n * For example if a function needs a `Functor` instance, pass `E.Functor` instead of `E.either`\n * (where `E` is from `import E from 'fp-ts/Either'`)\n \n @category zone of death\n * @since 2.0.0\n * @deprecated\n /\nexport var either = {\n URI: URI,\n map: _map,\n of: of,\n ap: _ap,\n chain: flatMap,\n reduce: _reduce,\n foldMap: _foldMap,\n reduceRight: _reduceRight,\n traverse: _traverse,\n sequence: sequence,\n bimap: _bimap,\n mapLeft: _mapLeft,\n alt: _alt,\n extend: _extend,\n chainRec: _chainRec,\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_(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 getValidationSemigroup = function (SE, SA) {\n return getApplySemigroup_(getApplicativeValidation(SE))(SA);\n};\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 getValidationMonoid = function (SE, MA) {\n return getApplicativeMonoid(getApplicativeValidation(SE))(MA);\n};\n/\n Use [`getApplicativeValidation`](#getapplicativevalidation) and [`getAltValidation`](#getaltvalidation) instead.\n \n @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport function getValidation(SE) {\n var ap = getApplicativeValidation(SE).ap;\n var alt = getAltValidation(SE).alt;\n return {\n URI: URI,\n _E: undefined,\n map: _map,\n of: of,\n chain: flatMap,\n bimap: _bimap,\n mapLeft: _mapLeft,\n reduce: _reduce,\n foldMap: _foldMap,\n reduceRight: _reduceRight,\n extend: _extend,\n traverse: _traverse,\n sequence: sequence,\n chainRec: _chainRec,\n throwError: throwError,\n ap: ap,\n alt: alt\n };\n}\n"],"names":["_.left","_.right","dual","pipe","tailRec","separated","witherDefault","wiltDefault","as_","asUnit_","identity","fromPredicate_","fromOption_","_.isLeft","_.isRight","flap_","apFirst_","apSecond_","chainable.tap","fromOptionK_","chainOptionK_","_.liftNullable","_.liftOption","_.flatMapNullable","_.flatMapOption","filterOrElse_","flow","ma","_.emptyRecord","bindTo_","let__","chainable.bind","apS_","_.emptyReadonlyArray","as","_.head","_.isNonEmpty","getApplySemigroup_","getApplicativeMonoid","ap","alt"],"mappings":"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","x_google_ignoreList":[0]}
1	+ {"version":3,"file":"Either.cjs","sources":["../../../../../../node_modules/fp-ts/es6/Either.js"],"sourcesContent":["import { getApplicativeMonoid } from './Applicative';\nimport { apFirst as apFirst_, apS as apS_, apSecond as apSecond_, getApplySemigroup as getApplySemigroup_ } from './Apply';\nimport * as chainable from './Chain';\nimport { tailRec } from './ChainRec';\nimport { chainOptionK as chainOptionK_, filterOrElse as filterOrElse_, fromOption as fromOption_, fromOptionK as fromOptionK_, fromPredicate as fromPredicate_ } from './FromEither';\nimport { dual, flow, identity, pipe } 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 { separated } from './Separated';\nimport { wiltDefault, witherDefault } from './Witherable';\n// -------------------------------------------------------------------------------------\n// constructors\n// -------------------------------------------------------------------------------------\n/*\n Constructs a new `Either` holding a `Left` value. This usually represents a failure, due to the right-bias of this\n * structure.\n \n @category constructors\n * @since 2.0.0\n /\nexport var left = _.left;\n/\n Constructs a new `Either` holding a `Right` value. This usually represents a successful value due to the right bias\n * of this structure.\n \n @category constructors\n * @since 2.0.0\n /\nexport var right = _.right;\n/\n @category sequencing\n * @since 2.14.0\n /\nexport var flatMap = /#__PURE__/ dual(2, function (ma, f) { return (isLeft(ma) ? ma : f(ma.right)); });\nvar _map = function (fa, f) { return pipe(fa, map(f)); };\nvar _ap = function (fab, fa) { return pipe(fab, ap(fa)); };\n/ istanbul ignore next /\nvar _reduce = function (fa, b, f) { return pipe(fa, reduce(b, f)); };\n/ istanbul ignore next /\nvar _foldMap = function (M) { return function (fa, f) {\n var foldMapM = foldMap(M);\n return pipe(fa, foldMapM(f));\n}; };\n/ istanbul ignore next /\nvar _reduceRight = function (fa, b, f) { return pipe(fa, reduceRight(b, f)); };\nvar _traverse = function (F) {\n var traverseF = traverse(F);\n return function (ta, f) { return pipe(ta, traverseF(f)); };\n};\nvar _bimap = function (fa, f, g) { return pipe(fa, bimap(f, g)); };\nvar _mapLeft = function (fa, f) { return pipe(fa, mapLeft(f)); };\n/ istanbul ignore next /\nvar _alt = function (fa, that) { return pipe(fa, alt(that)); };\n/ istanbul ignore next /\nvar _extend = function (wa, f) { return pipe(wa, extend(f)); };\nvar _chainRec = function (a, f) {\n return tailRec(f(a), function (e) {\n return isLeft(e) ? right(left(e.left)) : isLeft(e.right) ? left(f(e.right.left)) : right(right(e.right.right));\n });\n};\n/\n @category type lambdas\n * @since 2.0.0\n /\nexport var URI = 'Either';\n/\n @category instances\n * @since 2.0.0\n /\nexport var getShow = function (SE, SA) { return ({\n show: function (ma) { return (isLeft(ma) ? \"left(\".concat(SE.show(ma.left), \")\") : \"right(\".concat(SA.show(ma.right), \")\")); }\n}); };\n/\n @category instances\n * @since 2.0.0\n /\nexport var getEq = function (EL, EA) { return ({\n equals: function (x, y) {\n return x === y \|\| (isLeft(x) ? isLeft(y) && EL.equals(x.left, y.left) : isRight(y) && EA.equals(x.right, y.right));\n }\n}); };\n/\n Semigroup returning the left-most non-`Left` value. If both operands are `Right`s then the inner values are\n * concatenated using the provided `Semigroup`\n \n @example\n * import { getSemigroup, left, right } from 'fp-ts/Either'\n * import { SemigroupSum } from 'fp-ts/number'\n \n const S = getSemigroup<string, number>(SemigroupSum)\n * assert.deepStrictEqual(S.concat(left('a'), left('b')), left('a'))\n * assert.deepStrictEqual(S.concat(left('a'), right(2)), right(2))\n * assert.deepStrictEqual(S.concat(right(1), left('b')), right(1))\n * assert.deepStrictEqual(S.concat(right(1), right(2)), right(3))\n \n @category instances\n * @since 2.0.0\n /\nexport var getSemigroup = function (S) { return ({\n concat: function (x, y) { return (isLeft(y) ? x : isLeft(x) ? y : right(S.concat(x.right, y.right))); }\n}); };\n/\n Builds a `Compactable` instance for `Either` given `Monoid` for the left side.\n \n @category filtering\n * @since 2.10.0\n /\nexport var getCompactable = function (M) {\n var empty = left(M.empty);\n return {\n URI: URI,\n _E: undefined,\n compact: function (ma) { return (isLeft(ma) ? ma : ma.right._tag === 'None' ? empty : right(ma.right.value)); },\n separate: function (ma) {\n return isLeft(ma)\n ? separated(ma, ma)\n : isLeft(ma.right)\n ? separated(right(ma.right.left), empty)\n : separated(empty, right(ma.right.right));\n }\n };\n};\n/\n Builds a `Filterable` instance for `Either` given `Monoid` for the left side\n \n @category filtering\n * @since 2.10.0\n /\nexport var getFilterable = function (M) {\n var empty = left(M.empty);\n var _a = getCompactable(M), compact = _a.compact, separate = _a.separate;\n var filter = function (ma, predicate) {\n return isLeft(ma) ? ma : predicate(ma.right) ? ma : empty;\n };\n var partition = function (ma, p) {\n return isLeft(ma)\n ? separated(ma, ma)\n : p(ma.right)\n ? separated(empty, right(ma.right))\n : separated(right(ma.right), empty);\n };\n return {\n URI: URI,\n _E: undefined,\n map: _map,\n compact: compact,\n separate: separate,\n filter: filter,\n filterMap: function (ma, f) {\n if (isLeft(ma)) {\n return ma;\n }\n var ob = f(ma.right);\n return ob._tag === 'None' ? empty : right(ob.value);\n },\n partition: partition,\n partitionMap: function (ma, f) {\n if (isLeft(ma)) {\n return separated(ma, ma);\n }\n var e = f(ma.right);\n return isLeft(e) ? separated(right(e.left), empty) : separated(empty, right(e.right));\n }\n };\n};\n/\n Builds `Witherable` instance for `Either` given `Monoid` for the left side\n \n @category filtering\n * @since 2.0.0\n /\nexport var getWitherable = function (M) {\n var F_ = getFilterable(M);\n var C = getCompactable(M);\n return {\n URI: URI,\n _E: undefined,\n map: _map,\n compact: F_.compact,\n separate: F_.separate,\n filter: F_.filter,\n filterMap: F_.filterMap,\n partition: F_.partition,\n partitionMap: F_.partitionMap,\n traverse: _traverse,\n sequence: sequence,\n reduce: _reduce,\n foldMap: _foldMap,\n reduceRight: _reduceRight,\n wither: witherDefault(Traversable, C),\n wilt: wiltDefault(Traversable, C)\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 @example\n * import * as A from 'fp-ts/Apply'\n * import * as E from 'fp-ts/Either'\n * import { pipe } from 'fp-ts/function'\n * import * as S from 'fp-ts/Semigroup'\n * import * as string from 'fp-ts/string'\n \n const parseString = (u: unknown): E.Either<string, string> =>\n * typeof u === 'string' ? E.right(u) : E.left('not a string')\n \n const parseNumber = (u: unknown): E.Either<string, number> =>\n * typeof u === 'number' ? E.right(u) : E.left('not a number')\n \n interface Person {\n * readonly name: string\n * readonly age: number\n * }\n \n const parsePerson = (\n * input: Record<string, unknown>\n * ): E.Either<string, Person> =>\n * pipe(\n * E.Do,\n * E.apS('name', parseString(input.name)),\n * E.apS('age', parseNumber(input.age))\n * )\n \n assert.deepStrictEqual(parsePerson({}), E.left('not a string')) // <= first error\n \n const Applicative = E.getApplicativeValidation(\n * pipe(string.Semigroup, S.intercalate(', '))\n * )\n \n const apS = A.apS(Applicative)\n \n const parsePersonAll = (\n * input: Record<string, unknown>\n * ): E.Either<string, Person> =>\n * pipe(\n * E.Do,\n * apS('name', parseString(input.name)),\n * apS('age', parseNumber(input.age))\n * )\n \n assert.deepStrictEqual(parsePersonAll({}), E.left('not a string, not a number')) // <= all errors\n \n @category error handling\n * @since 2.7.0\n /\nexport var getApplicativeValidation = function (SE) { return ({\n URI: URI,\n _E: undefined,\n map: _map,\n ap: function (fab, fa) {\n return isLeft(fab)\n ? isLeft(fa)\n ? left(SE.concat(fab.left, fa.left))\n : fab\n : isLeft(fa)\n ? fa\n : right(fab.right(fa.right));\n },\n of: of\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 @example\n * import * as E from 'fp-ts/Either'\n * import { pipe } from 'fp-ts/function'\n * import * as S from 'fp-ts/Semigroup'\n * import * as string from 'fp-ts/string'\n \n const parseString = (u: unknown): E.Either<string, string> =>\n * typeof u === 'string' ? E.right(u) : E.left('not a string')\n \n const parseNumber = (u: unknown): E.Either<string, number> =>\n * typeof u === 'number' ? E.right(u) : E.left('not a number')\n \n const parse = (u: unknown): E.Either<string, string \| number> =>\n * pipe(\n * parseString(u),\n * E.alt<string, string \| number>(() => parseNumber(u))\n * )\n \n assert.deepStrictEqual(parse(true), E.left('not a number')) // <= last error\n \n const Alt = E.getAltValidation(pipe(string.Semigroup, S.intercalate(', ')))\n \n const parseAll = (u: unknown): E.Either<string, string \| number> =>\n * Alt.alt<string \| number>(parseString(u), () => parseNumber(u))\n \n assert.deepStrictEqual(parseAll(true), E.left('not a string, not a number')) // <= all errors\n \n @category error handling\n * @since 2.7.0\n /\nexport var getAltValidation = function (SE) { return ({\n URI: URI,\n _E: undefined,\n map: _map,\n alt: function (me, that) {\n if (isRight(me)) {\n return me;\n }\n var ea = that();\n return isLeft(ea) ? left(SE.concat(me.left, ea.left)) : ea;\n }\n}); };\n/\n @category mapping\n * @since 2.0.0\n /\nexport var map = function (f) { return function (fa) {\n return isLeft(fa) ? fa : right(f(fa.right));\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 `Either` 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 `Either` to the void constant value.\n \n @category mapping\n * @since 2.16.0\n /\nexport var asUnit = asUnit_(Functor);\n/\n @category constructors\n * @since 2.7.0\n /\nexport var of = right;\n/\n @category instances\n * @since 2.10.0\n /\nexport var Pointed = {\n URI: URI,\n of: of\n};\n/\n Less strict version of [`ap`](#ap).\n \n The `W` suffix (short for Widening) means that the error types will be merged.\n \n @since 2.8.0\n /\nexport var apW = function (fa) { return function (fab) {\n return isLeft(fab) ? fab : isLeft(fa) ? fa : right(fab.right(fa.right));\n}; };\n/\n @since 2.0.0\n /\nexport var ap = apW;\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 @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 Left-associative fold of a structure.\n \n @example\n * import { pipe } from 'fp-ts/function'\n * import * as E from 'fp-ts/Either'\n \n const startWith = 'prefix'\n * const concat = (a: string, b: string) => `${a}:${b}`\n \n assert.deepStrictEqual(\n * pipe(E.right('a'), E.reduce(startWith, concat)),\n * 'prefix:a'\n * )\n \n assert.deepStrictEqual(\n * pipe(E.left('e'), E.reduce(startWith, concat)),\n * 'prefix'\n * )\n \n @category folding\n * @since 2.0.0\n /\nexport var reduce = function (b, f) { return function (fa) {\n return isLeft(fa) ? b : f(b, fa.right);\n}; };\n/\n Map each element of the structure to a monoid, and combine the results.\n \n @example\n * import { pipe } from 'fp-ts/function'\n * import * as E from 'fp-ts/Either'\n * import * as S from 'fp-ts/string'\n \n const yell = (a: string) => `${a}!`\n \n assert.deepStrictEqual(\n * pipe(E.right('a'), E.foldMap(S.Monoid)(yell)),\n * 'a!'\n * )\n \n assert.deepStrictEqual(\n * pipe(E.left('e'), E.foldMap(S.Monoid)(yell)),\n * S.Monoid.empty\n * )\n \n @category folding\n * @since 2.0.0\n /\nexport var foldMap = function (M) { return function (f) { return function (fa) {\n return isLeft(fa) ? M.empty : f(fa.right);\n}; }; };\n/\n Right-associative fold of a structure.\n \n @example\n * import { pipe } from 'fp-ts/function'\n * import * as E from 'fp-ts/Either'\n \n const startWith = 'postfix'\n * const concat = (a: string, b: string) => `${a}:${b}`\n \n assert.deepStrictEqual(\n * pipe(E.right('a'), E.reduceRight(startWith, concat)),\n * 'a:postfix'\n * )\n \n assert.deepStrictEqual(\n * pipe(E.left('e'), E.reduceRight(startWith, concat)),\n * 'postfix'\n * )\n \n @category folding\n * @since 2.0.0\n /\nexport var reduceRight = function (b, f) { return function (fa) {\n return isLeft(fa) ? b : f(fa.right, b);\n}; };\n/\n @category instances\n * @since 2.7.0\n /\nexport var Foldable = {\n URI: URI,\n reduce: _reduce,\n foldMap: _foldMap,\n reduceRight: _reduceRight\n};\n/\n Map each element of a structure to an action, evaluate these actions from left to right, and collect the results.\n \n @example\n * import { pipe } from 'fp-ts/function'\n * import * as RA from 'fp-ts/ReadonlyArray'\n * import * as E from 'fp-ts/Either'\n * import * as O from 'fp-ts/Option'\n \n assert.deepStrictEqual(\n * pipe(E.right(['a']), E.traverse(O.Applicative)(RA.head)),\n * O.some(E.right('a'))\n * )\n \n assert.deepStrictEqual(\n * pipe(E.right([]), E.traverse(O.Applicative)(RA.head)),\n * O.none\n * )\n \n @category traversing\n * @since 2.6.3\n /\nexport var traverse = function (F) {\n return function (f) {\n return function (ta) {\n return isLeft(ta) ? F.of(left(ta.left)) : F.map(f(ta.right), right);\n };\n };\n};\n/\n Evaluate each monadic action in the structure from left to right, and collect the results.\n \n @example\n * import { pipe } from 'fp-ts/function'\n * import * as E from 'fp-ts/Either'\n * import * as O from 'fp-ts/Option'\n \n assert.deepStrictEqual(\n * pipe(E.right(O.some('a')), E.sequence(O.Applicative)),\n * O.some(E.right('a'))\n * )\n \n assert.deepStrictEqual(\n * pipe(E.right(O.none), E.sequence(O.Applicative)),\n * O.none\n * )\n \n @category traversing\n * @since 2.6.3\n /\nexport var sequence = function (F) {\n return function (ma) {\n return isLeft(ma) ? F.of(left(ma.left)) : F.map(ma.right, right);\n };\n};\n/\n @category instances\n * @since 2.7.0\n /\nexport var Traversable = {\n URI: URI,\n map: _map,\n reduce: _reduce,\n foldMap: _foldMap,\n reduceRight: _reduceRight,\n traverse: _traverse,\n sequence: sequence\n};\n/\n Map a pair of functions over the two type arguments of the bifunctor.\n \n @category mapping\n * @since 2.0.0\n /\nexport var bimap = function (f, g) { return function (fa) {\n return isLeft(fa) ? left(f(fa.left)) : right(g(fa.right));\n}; };\n/\n Map a function over the first type argument of a bifunctor.\n \n @category error handling\n * @since 2.0.0\n /\nexport var mapLeft = function (f) { return function (fa) {\n return isLeft(fa) ? left(f(fa.left)) : fa;\n}; };\n/\n @category instances\n * @since 2.7.0\n /\nexport var Bifunctor = {\n URI: URI,\n bimap: _bimap,\n mapLeft: _mapLeft\n};\n/\n Less strict version of [`alt`](#alt).\n \n The `W` suffix (short for Widening) 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 = function (that) { return function (fa) {\n return isLeft(fa) ? that() : fa;\n}; };\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 * In case of `Either` returns the left-most non-`Left` value (or the right-most `Left` value if both values are `Left`).\n \n \| x \| y \| pipe(x, alt(() => y) \|\n * \| -------- \| -------- \| -------------------- \|\n * \| left(a) \| left(b) \| left(b) \|\n * \| left(a) \| right(2) \| right(2) \|\n * \| right(1) \| left(b) \| right(1) \|\n * \| right(1) \| right(2) \| right(1) \|\n \n @example\n * import * as E from 'fp-ts/Either'\n * import { pipe } from 'fp-ts/function'\n \n assert.deepStrictEqual(\n * pipe(\n * E.left('a'),\n * E.alt(() => E.left('b'))\n * ),\n * E.left('b')\n * )\n * assert.deepStrictEqual(\n * pipe(\n * E.left('a'),\n * E.alt(() => E.right(2))\n * ),\n * E.right(2)\n * )\n * assert.deepStrictEqual(\n * pipe(\n * E.right(1),\n * E.alt(() => E.left('b'))\n * ),\n * E.right(1)\n * )\n * assert.deepStrictEqual(\n * pipe(\n * E.right(1),\n * E.alt(() => E.right(2))\n * ),\n * E.right(1)\n * )\n \n @category error handling\n * @since 2.0.0\n /\nexport var alt = altW;\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 @since 2.0.0\n /\nexport var extend = function (f) { return function (wa) {\n return isLeft(wa) ? wa : right(f(wa));\n}; };\n/\n @category instances\n * @since 2.7.0\n /\nexport var Extend = {\n URI: URI,\n map: _map,\n extend: _extend\n};\n/\n @category instances\n * @since 2.7.0\n /\nexport var ChainRec = {\n URI: URI,\n map: _map,\n ap: _ap,\n chain: flatMap,\n chainRec: _chainRec\n};\n/\n @since 2.6.3\n /\nexport var throwError = left;\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 instances\n * @since 2.10.0\n /\nexport var FromEither = {\n URI: URI,\n fromEither: identity\n};\n/\n @example\n * import { fromPredicate, left, right } from 'fp-ts/Either'\n * import { pipe } from 'fp-ts/function'\n \n assert.deepStrictEqual(\n * pipe(\n * 1,\n * fromPredicate(\n * (n) => n > 0,\n * () => 'error'\n * )\n * ),\n * right(1)\n * )\n * assert.deepStrictEqual(\n * pipe(\n * -1,\n * fromPredicate(\n * (n) => n > 0,\n * () => 'error'\n * )\n * ),\n * left('error')\n * )\n \n @category lifting\n * @since 2.0.0\n /\nexport var fromPredicate = /#__PURE__/ fromPredicate_(FromEither);\n// -------------------------------------------------------------------------------------\n// conversions\n// -------------------------------------------------------------------------------------\n/\n @example\n * import * as E from 'fp-ts/Either'\n * import { pipe } from 'fp-ts/function'\n * import * as O from 'fp-ts/Option'\n \n assert.deepStrictEqual(\n * pipe(\n * O.some(1),\n * E.fromOption(() => 'error')\n * ),\n * E.right(1)\n * )\n * assert.deepStrictEqual(\n * pipe(\n * O.none,\n * E.fromOption(() => 'error')\n * ),\n * E.left('error')\n * )\n \n @category conversions\n * @since 2.0.0\n /\nexport var fromOption = \n/#__PURE__/ fromOption_(FromEither);\n// -------------------------------------------------------------------------------------\n// refinements\n// -------------------------------------------------------------------------------------\n/\n Returns `true` if the either is an instance of `Left`, `false` otherwise.\n \n @category refinements\n * @since 2.0.0\n /\nexport var isLeft = _.isLeft;\n/\n Returns `true` if the either is an instance of `Right`, `false` otherwise.\n \n @category refinements\n * @since 2.0.0\n /\nexport var isRight = _.isRight;\n/\n Less strict version of [`match`](#match).\n \n The `W` suffix (short for Widening) means that the handler return types will be merged.\n \n @category pattern matching\n * @since 2.10.0\n /\nexport var matchW = function (onLeft, onRight) {\n return function (ma) {\n return isLeft(ma) ? onLeft(ma.left) : onRight(ma.right);\n };\n};\n/\n Alias of [`matchW`](#matchw).\n \n @category pattern matching\n * @since 2.10.0\n /\nexport var foldW = matchW;\n/\n Takes two functions and an `Either` value, if the value is a `Left` the inner value is applied to the first function,\n * if the value is a `Right` the inner value is applied to the second function.\n \n @example\n * import { match, left, right } from 'fp-ts/Either'\n * import { pipe } from 'fp-ts/function'\n \n function onLeft(errors: Array<string>): string {\n * return `Errors: ${errors.join(', ')}`\n * }\n \n function onRight(value: number): string {\n * return `Ok: ${value}`\n * }\n \n assert.strictEqual(\n * pipe(\n * right(1),\n * match(onLeft, onRight)\n * ),\n * 'Ok: 1'\n * )\n * assert.strictEqual(\n * pipe(\n * left(['error 1', 'error 2']),\n * match(onLeft, onRight)\n * ),\n * 'Errors: error 1, error 2'\n * )\n \n @category pattern matching\n * @since 2.10.0\n /\nexport var match = matchW;\n/\n Alias of [`match`](#match).\n \n @category pattern matching\n * @since 2.0.0\n /\nexport var fold = match;\n/\n Less strict version of [`getOrElse`](#getorelse).\n \n The `W` suffix (short for Widening) means that the handler return type will be merged.\n \n @category error handling\n * @since 2.6.0\n /\nexport var getOrElseW = function (onLeft) {\n return function (ma) {\n return isLeft(ma) ? onLeft(ma.left) : ma.right;\n };\n};\n/\n Returns the wrapped value if it's a `Right` or a default value if is a `Left`.\n \n @example\n * import { getOrElse, left, right } from 'fp-ts/Either'\n * import { pipe } from 'fp-ts/function'\n \n assert.deepStrictEqual(\n * pipe(\n * right(1),\n * getOrElse(() => 0)\n * ),\n * 1\n * )\n * assert.deepStrictEqual(\n * pipe(\n * left('error'),\n * getOrElse(() => 0)\n * ),\n * 0\n * )\n \n @category error handling\n * @since 2.0.0\n /\nexport var getOrElse = getOrElseW;\n// -------------------------------------------------------------------------------------\n// combinators\n// -------------------------------------------------------------------------------------\n/\n @category mapping\n * @since 2.10.0\n /\nexport var flap = /#__PURE__/ flap_(Functor);\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 Widening) 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_(Apply);\n/\n Less strict version of [`apSecond`](#apsecond)\n \n The `W` suffix (short for Widening) means that the error types will be merged.\n \n @since 2.12.0\n /\nexport var apSecondW = apSecond;\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 Less strict version of [`flatten`](#flatten).\n \n The `W` suffix (short for Widening) 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 The `flatten` function is the conventional monad join operator. It is used to remove one level of monadic structure, projecting its bound argument into the outer level.\n \n @example\n * import * as E from 'fp-ts/Either'\n \n assert.deepStrictEqual(E.flatten(E.right(E.right('a'))), E.right('a'))\n * assert.deepStrictEqual(E.flatten(E.right(E.left('e'))), E.left('e'))\n * assert.deepStrictEqual(E.flatten(E.left('e')), E.left('e'))\n \n @category sequencing\n * @since 2.0.0\n /\nexport var flatten = flattenW;\n/\n @since 2.0.0\n /\nexport var duplicate = /#__PURE__/ extend(identity);\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.11.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 = /#__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/\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 @example\n * import * as E from 'fp-ts/Either'\n * import { pipe } from 'fp-ts/function'\n \n assert.deepStrictEqual(\n * pipe(\n * E.right(1),\n * E.filterOrElse(\n * (n) => n > 0,\n * () => 'error'\n * )\n * ),\n * E.right(1)\n * )\n * assert.deepStrictEqual(\n * pipe(\n * E.right(-1),\n * E.filterOrElse(\n * (n) => n > 0,\n * () => 'error'\n * )\n * ),\n * E.left('error')\n * )\n * assert.deepStrictEqual(\n * pipe(\n * E.left('a'),\n * E.filterOrElse(\n * (n) => n > 0,\n * () => 'error'\n * )\n * ),\n * E.left('a')\n * )\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 Widening) means that the error types will be merged.\n \n @category filtering\n * @since 2.9.0\n /\nexport var filterOrElseW = filterOrElse;\n/\n Returns a `Right` if is a `Left` (and vice versa).\n \n @since 2.0.0\n /\nexport var swap = function (ma) { return (isLeft(ma) ? right(ma.left) : left(ma.right)); };\n/\n Less strict version of [`orElse`](#orelse).\n \n The `W` suffix (short for Widening) means that the return types will be merged.\n \n @category error handling\n * @since 2.10.0\n /\nexport var orElseW = function (onLeft) {\n return function (ma) {\n return isLeft(ma) ? onLeft(ma.left) : ma;\n };\n};\n/\n Useful for recovering from errors.\n \n @category error handling\n * @since 2.0.0\n /\nexport var orElse = orElseW;\n/\n Takes a default and a nullable value, if the value is not nully, turn it into a `Right`, if the value is nully use\n * the provided default as a `Left`.\n \n @example\n * import { fromNullable, left, right } from 'fp-ts/Either'\n \n const parse = fromNullable('nully')\n \n assert.deepStrictEqual(parse(1), right(1))\n * assert.deepStrictEqual(parse(null), left('nully'))\n \n @category conversions\n * @since 2.0.0\n /\nexport var fromNullable = function (e) {\n return function (a) {\n return a == null ? left(e) : right(a);\n };\n};\n/\n Constructs a new `Either` from a function that might throw.\n \n See also [`tryCatchK`](#trycatchk).\n \n @example\n * import * as E from 'fp-ts/Either'\n \n const unsafeHead = <A>(as: ReadonlyArray<A>): A => {\n * if (as.length > 0) {\n * return as[0]\n * } else {\n * throw new Error('empty array')\n * }\n * }\n \n const head = <A>(as: ReadonlyArray<A>): E.Either<Error, A> =>\n * E.tryCatch(() => unsafeHead(as), e => (e instanceof Error ? e : new Error('unknown error')))\n \n assert.deepStrictEqual(head([]), E.left(new Error('empty array')))\n * assert.deepStrictEqual(head([1, 2, 3]), E.right(1))\n \n @category interop\n * @since 2.0.0\n /\nexport var tryCatch = function (f, onThrow) {\n try {\n return right(f());\n }\n catch (e) {\n return left(onThrow(e));\n }\n};\n/\n Converts a function that may throw to one returning a `Either`.\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 Use `liftNullable`.\n \n @category legacy\n * @since 2.9.0\n /\nexport var fromNullableK = function (e) {\n var from = fromNullable(e);\n return function (f) { return flow(f, from); };\n};\n/\n Use `flatMapNullable`.\n \n @category legacy\n * @since 2.9.0\n /\nexport var chainNullableK = function (e) {\n var from = fromNullableK(e);\n return function (f) { return flatMap(from(f)); };\n};\n/\n @category conversions\n * @since 2.10.0\n /\nexport var toUnion = /#__PURE__/ foldW(identity, identity);\n// -------------------------------------------------------------------------------------\n// utils\n// -------------------------------------------------------------------------------------\n/\n Default value for the `onError` argument of `tryCatch`\n \n @since 2.0.0\n /\nexport function toError(e) {\n return e instanceof Error ? e : new Error(String(e));\n}\nexport function elem(E) {\n return function (a, ma) {\n if (ma === undefined) {\n var elemE_1 = elem(E);\n return function (ma) { return elemE_1(a, ma); };\n }\n return isLeft(ma) ? false : E.equals(a, ma.right);\n };\n}\n/\n Returns `false` if `Left` or returns the result of the application of the given predicate to the `Right` value.\n \n @example\n * import { exists, left, right } from 'fp-ts/Either'\n \n const gt2 = exists((n: number) => n > 2)\n \n assert.strictEqual(gt2(left('a')), false)\n * assert.strictEqual(gt2(right(1)), false)\n * assert.strictEqual(gt2(right(3)), true)\n \n @since 2.0.0\n /\nexport var exists = function (predicate) {\n return function (ma) {\n return isLeft(ma) ? false : predicate(ma.right);\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 Widening) 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_(Apply);\n/\n Less strict version of [`apS`](#aps).\n \n The `W` suffix (short for Widening) 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(Applicative)`.\n \n @category traversing\n * @since 2.11.0\n /\nexport var traverseReadonlyNonEmptyArrayWithIndex = function (f) {\n return function (as) {\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 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 = \n/#__PURE__/ traverseArray(identity);\n// -------------------------------------------------------------------------------------\n// legacy\n// -------------------------------------------------------------------------------------\n/\n Alias of `flatMap`.\n \n @category legacy\n * @since 2.6.0\n /\nexport var chainW = flatMap;\n/\n Alias of `flatMap`.\n \n @category legacy\n * @since 2.0.0\n /\nexport var chain = 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 Use [`parse`](./Json.ts.html#parse) instead.\n \n @category zone of death\n * @since 2.0.0\n * @deprecated\n /\nexport function parseJSON(s, onError) {\n return tryCatch(function () { return JSON.parse(s); }, onError);\n}\n/\n Use [`stringify`](./Json.ts.html#stringify) instead.\n \n @category zone of death\n * @since 2.0.0\n * @deprecated\n /\nexport var stringifyJSON = function (u, onError) {\n return tryCatch(function () {\n var s = JSON.stringify(u);\n if (typeof s !== 'string') {\n throw new Error('Converting unsupported structure to JSON');\n }\n return s;\n }, onError);\n};\n/\n This instance is deprecated, use small, specific instances instead.\n * For example if a function needs a `Functor` instance, pass `E.Functor` instead of `E.either`\n * (where `E` is from `import E from 'fp-ts/Either'`)\n \n @category zone of death\n * @since 2.0.0\n * @deprecated\n /\nexport var either = {\n URI: URI,\n map: _map,\n of: of,\n ap: _ap,\n chain: flatMap,\n reduce: _reduce,\n foldMap: _foldMap,\n reduceRight: _reduceRight,\n traverse: _traverse,\n sequence: sequence,\n bimap: _bimap,\n mapLeft: _mapLeft,\n alt: _alt,\n extend: _extend,\n chainRec: _chainRec,\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_(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 getValidationSemigroup = function (SE, SA) {\n return getApplySemigroup_(getApplicativeValidation(SE))(SA);\n};\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 getValidationMonoid = function (SE, MA) {\n return getApplicativeMonoid(getApplicativeValidation(SE))(MA);\n};\n/\n Use [`getApplicativeValidation`](#getapplicativevalidation) and [`getAltValidation`](#getaltvalidation) instead.\n \n @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport function getValidation(SE) {\n var ap = getApplicativeValidation(SE).ap;\n var alt = getAltValidation(SE).alt;\n return {\n URI: URI,\n _E: undefined,\n map: _map,\n of: of,\n chain: flatMap,\n bimap: _bimap,\n mapLeft: _mapLeft,\n reduce: _reduce,\n foldMap: _foldMap,\n reduceRight: _reduceRight,\n extend: _extend,\n traverse: _traverse,\n sequence: sequence,\n chainRec: _chainRec,\n throwError: throwError,\n ap: ap,\n alt: alt\n };\n}\n"],"names":["_.isLeft"],"mappings":";;;AAswBU,IAAC,SAASA,SAAS;AAgBnB,IAAC,SAAS,SAAU,QAAQ,SAAS;AAC3C,SAAO,SAAU,IAAI;AACjB,WAAO,OAAO,EAAE,IAAI,OAAO,GAAG,IAAI,IAAI,QAAQ,GAAG,KAAK;AAAA,EAC9D;AACA;AAOU,IAAC,QAAQ;AAmCT,IAAC,QAAQ;AAOT,IAAC,OAAO;;;;;;","x_google_ignoreList":[0]}