{"version":3,"sources":["../../node_modules/fp-ts/es6/Ord.js","../../node_modules/fp-ts/es6/Reader.js","../../node_modules/fp-ts/es6/Option.js","../../node_modules/fp-ts/es6/IO.js","../../node_modules/fp-ts/es6/Ordering.js","../../node_modules/fp-ts/es6/NonEmptyArray.js","../../node_modules/fp-ts/es6/Filterable.js","../../node_modules/fp-ts/es6/Functor.js","../../node_modules/fp-ts/es6/Map.js","../../node_modules/fp-ts/es6/Monoid.js","../../node_modules/fp-ts/es6/Random.js","../../node_modules/fp-ts/es6/ReaderTaskEither.js"],"names":["compare","x","y","strictEqual","a","b","ordString","equals","ordNumber","ordBoolean","lt","O","gt","leq","geq","min","max","clamp","minO","maxO","low","hi","between","lessThanO","greaterThanO","fromCompare","optimizedCompare","getSemigroup","concat","monoidOrdering","getMonoid","empty","getTupleOrd","ords","_i","arguments","length","len","i","r","getDualOrd","contramap","f","fa","URI","ordDate","pipe","date","valueOf","Contravariant","ord","ask","identity","asks","local","ma","q","map_","map","ap_","fab","ap","chain_","chain","compose_","bc","ab","compose","promap_","fea","g","promap","first_","pab","_a","c","second_","pbc","left_","E","right_","apW","apFirst","fb","flow","apSecond","of","constant","chainW","chainFirst","flatten","id","S","e","M","Functor","Applicative","Monad","Profunctor","Category","Strong","first","second","Choice","left","right","reader","bindTo","name","bindTo_","bindW","bind_","bind","Do","apSW","apS","traverseArrayWithIndex","arr","traverseArray","_","sequenceArray","isSome","_tag","isNone","none","some","value","fromNullable","fromPredicate","predicate","tryCatch","getLeft","getRight","fromEither","fold","onNone","onSome","toNullable","toUndefined","undefined","getOrElseW","getOrElse","fromNullableK","apply","mapNullable","chainNullableK","reduce_","reduce","foldMap_","foldMapM","foldMap","reduceRight_","reduceRight","traverse_","F","traverseF","traverse","ta","alt_","that","alt","filter_","filter","filterMap_","filterMap","extend_","wa","extend","partition_","partition","partitionMap_","partitionMap","wither_","witherF","wither","wilt_","wiltF","wilt","altW","zero","throwError","duplicate","compact","defaultSeparate","separate","o","sequence","getShow","show","getEq","getOrd","getApplySemigroup","getApplyMonoid","getFirstMonoid","getLastMonoid","Foldable","Alt","Alternative","Extend","Compactable","Filterable","Traversable","Witherable","MonadThrow","option","elem","exists","getRefinement","getOption","result","push","mab","chainRec_","fromIO","MonadIO","ChainRec","chainRec","io","sign","n","eqOrdering","semigroupOrdering","invert","cons","RNEA","snoc","fromArray","uncons","unsnoc","head","tail","reverse","group","groupSort","groupBy","last","init","sort","insertAt","updateAt","modifyAt","copy","nea","l","as","Array","filterWithIndex","fx","fy","zipWith","zip","unzip","prependToAll","intersperse","mapWithIndex_","mapWithIndex","reduceWithIndex_","reduceWithIndex","foldMapWithIndex_","foldMapWithIndex","reduceRightWithIndex_","reduceRightWithIndex","traverseWithIndex_","traverseWithIndex","extract","FunctorWithIndex","FoldableWithIndex","TraversableWithIndex","Comonad","nonEmptyArray","getFilterableComposition","G","CC","getCompactableComposition","FC","fga","p","ga","getFunctorComposition","RM","size","isEmpty","member","keys","values","collect","toArray","toUnfoldable","U","deleteAt","pop","lookupWithKey","lookup","isSubmap","Map","singleton","fromFoldable","map__","getFilterableWithIndex","getWitherable","monoidAll","monoidAny","monoidSum","monoidProduct","monoidString","monoidVoid","getTupleMonoid","monoids","m","getDualMonoid","getFunctionMonoid","getEndomorphismMonoid","getStructMonoid","Object","key","getMeetMonoid","B","top","getJoinMonoid","bottom","random","Math","randomInt","high","floor","randomRange","randomBool","__awaiter","thisArg","_arguments","P","generator","Promise","resolve","reject","fulfilled","step","next","rejected","done","then","__generator","body","t","label","sent","trys","ops","verb","Symbol","iterator","this","v","op","TypeError","call","fromTaskEither","R","TE","rightTask","leftTask","rightReader","leftReader","me","rightReaderTask","leftReaderTask","fromIOEither","fromReaderEither","rightIO","leftIO","fromOption","onFalse","onLeft","onRight","orElse","swap","filterOrElseW","filterOrElse","fromEitherK","chainEitherKW","chainEitherK","fromIOEitherK","chainIOEitherKW","chainIOEitherK","fromTaskEitherK","chainTaskEitherKW","chainTaskEitherK","apPar_","apSeq_","bimap_","bimap","mapLeft_","mapLeft","chainFirstW","fromTask","getApplicativeReaderTaskValidation","A","SE","AV","_E","gab","getAltReaderTaskValidation","getReaderTaskValidation","applicativeReaderTaskValidation","T","altReaderTaskValidation","ApplicativePar","ApplicativeSeq","Bifunctor","readerTaskEither","readerTaskEitherSeq","run","bracket","aquire","use","release","all","traverseSeqArrayWithIndex","traverseSeqArray","sequenceSeqArray"],"mappings":"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","file":"static/js/index~a1d6d392.eb0aa0a1.chunk.js","sourcesContent":["import { monoidOrdering } from './Ordering';\nimport { pipe } from './function';\n// default compare for primitive types\nfunction compare(x, y) {\n    return x < y ? -1 : x > y ? 1 : 0;\n}\nfunction strictEqual(a, b) {\n    return a === b;\n}\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var ordString = {\n    equals: strictEqual,\n    compare: compare\n};\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var ordNumber = {\n    equals: strictEqual,\n    compare: compare\n};\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var ordBoolean = {\n    equals: strictEqual,\n    compare: compare\n};\n// TODO: curry in v3\n/**\n * Test whether one value is _strictly less than_ another\n *\n * @since 2.0.0\n */\nexport function lt(O) {\n    return function (x, y) { return O.compare(x, y) === -1; };\n}\n// TODO: curry in v3\n/**\n * Test whether one value is _strictly greater than_ another\n *\n * @since 2.0.0\n */\nexport function gt(O) {\n    return function (x, y) { return O.compare(x, y) === 1; };\n}\n// TODO: curry in v3\n/**\n * Test whether one value is _non-strictly less than_ another\n *\n * @since 2.0.0\n */\nexport function leq(O) {\n    return function (x, y) { return O.compare(x, y) !== 1; };\n}\n// TODO: curry in v3\n/**\n * Test whether one value is _non-strictly greater than_ another\n *\n * @since 2.0.0\n */\nexport function geq(O) {\n    return function (x, y) { return O.compare(x, y) !== -1; };\n}\n// TODO: curry in v3\n/**\n * Take the minimum of two values. If they are considered equal, the first argument is chosen\n *\n * @since 2.0.0\n */\nexport function min(O) {\n    return function (x, y) { return (O.compare(x, y) === 1 ? y : x); };\n}\n// TODO: curry in v3\n/**\n * Take the maximum of two values. If they are considered equal, the first argument is chosen\n *\n * @since 2.0.0\n */\nexport function max(O) {\n    return function (x, y) { return (O.compare(x, y) === -1 ? y : x); };\n}\n/**\n * Clamp a value between a minimum and a maximum\n *\n * @since 2.0.0\n */\nexport function clamp(O) {\n    var minO = min(O);\n    var maxO = max(O);\n    return function (low, hi) { return function (x) { return maxO(minO(x, hi), low); }; };\n}\n/**\n * Test whether a value is between a minimum and a maximum (inclusive)\n *\n * @since 2.0.0\n */\nexport function between(O) {\n    var lessThanO = lt(O);\n    var greaterThanO = gt(O);\n    return function (low, hi) { return function (x) { return (lessThanO(x, low) || greaterThanO(x, hi) ? false : true); }; };\n}\n/**\n * @category constructors\n * @since 2.0.0\n */\nexport function fromCompare(compare) {\n    var optimizedCompare = function (x, y) { return (x === y ? 0 : compare(x, y)); };\n    return {\n        equals: function (x, y) { return optimizedCompare(x, y) === 0; },\n        compare: optimizedCompare\n    };\n}\n/**\n * Use `getMonoid` instead\n *\n * @category instances\n * @since 2.0.0\n * @deprecated\n */\nexport function getSemigroup() {\n    return {\n        concat: function (x, y) { return fromCompare(function (a, b) { return monoidOrdering.concat(x.compare(a, b), y.compare(a, b)); }); }\n    };\n}\n/**\n * Returns a `Monoid` such that:\n *\n * - its `concat(ord1, ord2)` operation will order first by `ord1`, and then by `ord2`\n * - its `empty` value is an `Ord` that always considers compared elements equal\n *\n * @example\n * import { sort } from 'fp-ts/Array'\n * import { contramap, getDualOrd, getMonoid, ordBoolean, ordNumber, ordString } from 'fp-ts/Ord'\n * import { pipe } from 'fp-ts/function'\n * import { fold } from 'fp-ts/Monoid'\n *\n * interface User {\n *   id: number\n *   name: string\n *   age: number\n *   rememberMe: boolean\n * }\n *\n * const byName = pipe(\n *   ordString,\n *   contramap((p: User) => p.name)\n * )\n *\n * const byAge = pipe(\n *   ordNumber,\n *   contramap((p: User) => p.age)\n * )\n *\n * const byRememberMe = pipe(\n *   ordBoolean,\n *   contramap((p: User) => p.rememberMe)\n * )\n *\n * const M = getMonoid<User>()\n *\n * const users: Array<User> = [\n *   { id: 1, name: 'Guido', age: 47, rememberMe: false },\n *   { id: 2, name: 'Guido', age: 46, rememberMe: true },\n *   { id: 3, name: 'Giulio', age: 44, rememberMe: false },\n *   { id: 4, name: 'Giulio', age: 44, rememberMe: true }\n * ]\n *\n * // sort by name, then by age, then by `rememberMe`\n * const O1 = fold(M)([byName, byAge, byRememberMe])\n * assert.deepStrictEqual(sort(O1)(users), [\n *   { id: 3, name: 'Giulio', age: 44, rememberMe: false },\n *   { id: 4, name: 'Giulio', age: 44, rememberMe: true },\n *   { id: 2, name: 'Guido', age: 46, rememberMe: true },\n *   { id: 1, name: 'Guido', age: 47, rememberMe: false }\n * ])\n *\n * // now `rememberMe = true` first, then by name, then by age\n * const O2 = fold(M)([getDualOrd(byRememberMe), byName, byAge])\n * assert.deepStrictEqual(sort(O2)(users), [\n *   { id: 4, name: 'Giulio', age: 44, rememberMe: true },\n *   { id: 2, name: 'Guido', age: 46, rememberMe: true },\n *   { id: 3, name: 'Giulio', age: 44, rememberMe: false },\n *   { id: 1, name: 'Guido', age: 47, rememberMe: false }\n * ])\n *\n * @category instances\n * @since 2.4.0\n */\nexport function getMonoid() {\n    return {\n        // tslint:disable-next-line: deprecation\n        concat: getSemigroup().concat,\n        empty: fromCompare(function () { return 0; })\n    };\n}\n/**\n * Given a tuple of `Ord`s returns an `Ord` for the tuple\n *\n * @example\n * import { getTupleOrd, ordString, ordNumber, ordBoolean } from 'fp-ts/Ord'\n *\n * const O = getTupleOrd(ordString, ordNumber, ordBoolean)\n * assert.strictEqual(O.compare(['a', 1, true], ['b', 2, true]), -1)\n * assert.strictEqual(O.compare(['a', 1, true], ['a', 2, true]), -1)\n * assert.strictEqual(O.compare(['a', 1, true], ['a', 1, false]), 1)\n *\n * @category instances\n * @since 2.0.0\n */\nexport function getTupleOrd() {\n    var ords = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        ords[_i] = arguments[_i];\n    }\n    var len = ords.length;\n    return fromCompare(function (x, y) {\n        var i = 0;\n        for (; i < len - 1; i++) {\n            var r = ords[i].compare(x[i], y[i]);\n            if (r !== 0) {\n                return r;\n            }\n        }\n        return ords[i].compare(x[i], y[i]);\n    });\n}\n/**\n * @category combinators\n * @since 2.0.0\n */\nexport function getDualOrd(O) {\n    return fromCompare(function (x, y) { return O.compare(y, x); });\n}\n// -------------------------------------------------------------------------------------\n// non-pipeables\n// -------------------------------------------------------------------------------------\n/* istanbul ignore next */\nvar contramap_ = function (fa, f) { return pipe(fa, contramap(f)); };\n// -------------------------------------------------------------------------------------\n// pipeables\n// -------------------------------------------------------------------------------------\n/**\n * @category Contravariant\n * @since 2.0.0\n */\nexport var contramap = function (f) { return function (fa) {\n    return fromCompare(function (x, y) { return fa.compare(f(x), f(y)); });\n}; };\n// -------------------------------------------------------------------------------------\n// instances\n// -------------------------------------------------------------------------------------\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var URI = 'Ord';\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var ordDate = \n/*#__PURE__*/\npipe(ordNumber, \n/*#__PURE__*/\ncontramap(function (date) { return date.valueOf(); }));\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Contravariant = {\n    URI: URI,\n    contramap: contramap_\n};\n// TODO: remove in v3\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var ord = Contravariant;\n","import * as E from './Either';\nimport { bindTo_, bind_, flow, identity, pipe, constant } from './function';\n// -------------------------------------------------------------------------------------\n// constructors\n// -------------------------------------------------------------------------------------\n/**\n * Reads the current context\n *\n * @category constructors\n * @since 2.0.0\n */\nexport var ask = function () { return identity; };\n/**\n * Projects a value from the global context in a Reader\n *\n * @category constructors\n * @since 2.0.0\n */\nexport var asks = identity;\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 * @category combinators\n * @since 2.0.0\n */\nexport var local = function (f) { return function (ma) { return function (q) { return ma(f(q)); }; }; };\n// -------------------------------------------------------------------------------------\n// non-pipeables\n// -------------------------------------------------------------------------------------\n/* istanbul ignore next */\nvar map_ = function (fa, f) { return pipe(fa, map(f)); };\n/* istanbul ignore next */\nvar ap_ = function (fab, fa) { return pipe(fab, ap(fa)); };\n/* istanbul ignore next */\nvar chain_ = function (ma, f) { return pipe(ma, chain(f)); };\nvar compose_ = function (bc, ab) { return pipe(bc, compose(ab)); };\nvar promap_ = function (fea, f, g) { return pipe(fea, promap(f, g)); };\nvar first_ = function (pab) { return function (_a) {\n    var a = _a[0], c = _a[1];\n    return [pab(a), c];\n}; };\nvar second_ = function (pbc) { return function (_a) {\n    var a = _a[0], b = _a[1];\n    return [a, pbc(b)];\n}; };\nvar left_ = function (pab) {\n    return E.fold(function (a) { return E.left(pab(a)); }, E.right);\n};\nvar right_ = function (pbc) {\n    return E.fold(E.left, function (b) { return E.right(pbc(b)); });\n};\n// -------------------------------------------------------------------------------------\n// pipeables\n// -------------------------------------------------------------------------------------\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 Functor\n * @since 2.0.0\n */\nexport var map = function (f) { return function (fa) { return function (r) { return f(fa(r)); }; }; };\n/**\n * Less strict version of [`ap`](#ap).\n *\n * @category Apply\n * @since 2.8.0\n */\nexport var apW = function (fa) { return function (fab) { return function (r) { return fab(r)(fa(r)); }; }; };\n/**\n * Apply a function to an argument under a type constructor.\n *\n * @category Apply\n * @since 2.0.0\n */\nexport var ap = apW;\n/**\n * Combine two effectful actions, keeping only the result of the first.\n *\n * Derivable from `Apply`.\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var apFirst = function (fb) {\n    return flow(map(function (a) { return function () { return a; }; }), ap(fb));\n};\n/**\n * Combine two effectful actions, keeping only the result of the second.\n *\n * Derivable from `Apply`.\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var apSecond = function (fb) {\n    return flow(map(function () { return function (b) { return b; }; }), ap(fb));\n};\n/**\n * Wrap a value into the type constructor.\n *\n * @category Applicative\n * @since 2.0.0\n */\nexport var of = constant;\n/**\n * Less strict version of [`chain`](#chain).\n *\n * @category Monad\n * @since 2.6.0\n */\nexport var chainW = function (f) { return function (fa) { return function (r) { return f(fa(r))(r); }; }; };\n/**\n * Composes computations in sequence, using the return value of one computation to determine the next computation.\n *\n * @category Monad\n * @since 2.0.0\n */\nexport var chain = chainW;\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 * Derivable from `Monad`.\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var chainFirst = function (f) {\n    return chain(function (a) {\n        return pipe(f(a), map(function () { return a; }));\n    });\n};\n/**\n * Derivable from `Monad`.\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var flatten = \n/*#__PURE__*/\nchain(identity);\n/**\n * @category Semigroupoid\n * @since 2.0.0\n */\nexport var compose = function (ab) { return function (bc) { return flow(ab, bc); }; };\n/**\n * @category Profunctor\n * @since 2.0.0\n */\nexport var promap = function (f, g) { return function (fea) { return function (a) { return g(fea(f(a))); }; }; };\n/**\n * @category Category\n * @since 2.0.0\n */\nexport var id = function () { return identity; };\n// -------------------------------------------------------------------------------------\n// instances\n// -------------------------------------------------------------------------------------\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var URI = 'Reader';\n/**\n * @category instances\n * @since 2.0.0\n */\nexport function getSemigroup(S) {\n    return {\n        concat: function (x, y) { return function (e) { return S.concat(x(e), y(e)); }; }\n    };\n}\n/**\n * @category instances\n * @since 2.0.0\n */\nexport function getMonoid(M) {\n    return {\n        concat: getSemigroup(M).concat,\n        empty: function () { return M.empty; }\n    };\n}\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Functor = {\n    URI: URI,\n    map: map_\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.7.0\n */\nexport var Monad = {\n    URI: URI,\n    map: map_,\n    of: of,\n    ap: ap_,\n    chain: chain_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Profunctor = {\n    URI: URI,\n    map: map_,\n    promap: promap_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Category = {\n    URI: URI,\n    compose: compose_,\n    id: id\n};\n/**\n * @category instances\n * @since 2.8.3\n */\nexport var Strong = {\n    URI: URI,\n    map: map_,\n    promap: promap_,\n    first: first_,\n    second: second_\n};\n/**\n * @category instances\n * @since 2.8.3\n */\nexport var Choice = {\n    URI: URI,\n    map: map_,\n    promap: promap_,\n    left: left_,\n    right: right_\n};\n// TODO: remove in v3\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var reader = {\n    URI: URI,\n    map: map_,\n    of: of,\n    ap: ap_,\n    chain: chain_,\n    promap: promap_,\n    compose: compose_,\n    id: id,\n    first: first_,\n    second: second_,\n    left: left_,\n    right: right_\n};\n// -------------------------------------------------------------------------------------\n// do notation\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.8.0\n */\nexport var bindTo = function (name) {\n    return map(bindTo_(name));\n};\n/**\n * @since 2.8.0\n */\nexport var bindW = function (name, f) {\n    return chainW(function (a) {\n        return pipe(f(a), map(function (b) { return bind_(a, name, b); }));\n    });\n};\n/**\n * @since 2.8.0\n */\nexport var bind = bindW;\n// -------------------------------------------------------------------------------------\n// pipeable sequence S\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.9.0\n */\nexport var Do = \n/*#__PURE__*/\nof({});\n/**\n * @since 2.8.0\n */\nexport var apSW = function (name, fb) {\n    return flow(map(function (a) { return function (b) { return bind_(a, name, b); }; }), apW(fb));\n};\n/**\n * @since 2.8.0\n */\nexport var apS = apSW;\n// -------------------------------------------------------------------------------------\n// array utils\n// -------------------------------------------------------------------------------------\n/**\n *\n * @since 2.9.0\n */\nexport var traverseArrayWithIndex = function (f) { return function (arr) { return function (r) { return arr.map(function (x, i) { return f(i, x)(r); }); }; }; };\n/**\n * this function have the same behavior of `A.traverse(R.reader)` but it's stack safe and optimized\n *\n * @example\n * import * as RA from 'fp-ts/ReadonlyArray'\n * import { traverseArray, Reader } from 'fp-ts/Reader'\n * import { pipe } from 'fp-ts/function'\n *\n * const add: (x: number) => Reader<{value:number}, number> = x => config => x + config.value\n * const arr = RA.range(0, 100)\n *\n * assert.deepStrictEqual(pipe(arr, traverseArray(add))({value: 3}), pipe(arr, RA.map(x => x + 3)))\n *\n * @since 2.9.0\n */\nexport var traverseArray = function (f) { return traverseArrayWithIndex(function (_, a) { return f(a); }); };\n/**\n * this function have the same behavior of `A.sequence(R.reader)` but it's stack safe and optimized\n *\n * @example\n * import * as RA from 'fp-ts/ReadonlyArray'\n * import { sequenceArray, Reader } from 'fp-ts/Reader'\n * import { pipe } from 'fp-ts/function'\n *\n * const add: (x: number) => Reader<{value:number}, number> = x => config => x + config.value\n * const arr = RA.range(0, 100)\n *\n * assert.deepStrictEqual(pipe(arr, RA.map(add), sequenceArray)({value: 3}), pipe(arr, RA.map(x => x + 3)))\n *\n * @since 2.9.0\n */\nexport var sequenceArray = \n/*#__PURE__*/\ntraverseArray(identity);\n","import { identity, pipe, bind_, bindTo_, flow } from './function';\n// -------------------------------------------------------------------------------------\n// guards\n// -------------------------------------------------------------------------------------\n/**\n * Returns `true` if the option is an instance of `Some`, `false` otherwise.\n *\n * @example\n * import { some, none, isSome } from 'fp-ts/Option'\n *\n * assert.strictEqual(isSome(some(1)), true)\n * assert.strictEqual(isSome(none), false)\n *\n * @category guards\n * @since 2.0.0\n */\nexport var isSome = function (fa) { return fa._tag === 'Some'; };\n/**\n * Returns `true` if the option is `None`, `false` otherwise.\n *\n * @example\n * import { some, none, isNone } from 'fp-ts/Option'\n *\n * assert.strictEqual(isNone(some(1)), false)\n * assert.strictEqual(isNone(none), true)\n *\n * @category guards\n * @since 2.0.0\n */\nexport var isNone = function (fa) { return fa._tag === 'None'; };\n// -------------------------------------------------------------------------------------\n// constructors\n// -------------------------------------------------------------------------------------\n/**\n * `None` doesn't have a constructor, instead you can use it directly as a value. Represents a missing value.\n *\n * @category constructors\n * @since 2.0.0\n */\nexport var none = { _tag: 'None' };\n/**\n * Constructs a `Some`. Represents an optional value that exists.\n *\n * @category constructors\n * @since 2.0.0\n */\nexport var some = function (a) { return ({ _tag: 'Some', value: a }); };\n/**\n * Constructs a new `Option` from a nullable type. If the value is `null` or `undefined`, returns `None`, otherwise\n * returns the value wrapped in a `Some`.\n *\n * @example\n * import { none, some, fromNullable } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(fromNullable(undefined), none)\n * assert.deepStrictEqual(fromNullable(null), none)\n * assert.deepStrictEqual(fromNullable(1), some(1))\n *\n * @category constructors\n * @since 2.0.0\n */\nexport function fromNullable(a) {\n    return a == null ? none : some(a);\n}\nexport function fromPredicate(predicate) {\n    return function (a) { return (predicate(a) ? some(a) : none); };\n}\n/**\n * Transforms an exception into an `Option`. If `f` throws, returns `None`, otherwise returns the output wrapped in a\n * `Some`.\n *\n * @example\n * import { none, some, tryCatch } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(\n *   tryCatch(() => {\n *     throw new Error()\n *   }),\n *   none\n * )\n * assert.deepStrictEqual(tryCatch(() => 1), some(1))\n *\n * @category constructors\n * @since 2.0.0\n */\nexport function tryCatch(f) {\n    try {\n        return some(f());\n    }\n    catch (e) {\n        return none;\n    }\n}\n/**\n * Returns the `Left` value of an `Either` if possible.\n *\n * @example\n * import { getLeft, none, some } from 'fp-ts/Option'\n * import { right, left } from 'fp-ts/Either'\n *\n * assert.deepStrictEqual(getLeft(right(1)), none)\n * assert.deepStrictEqual(getLeft(left('a')), some('a'))\n *\n * @category constructors\n * @since 2.0.0\n */\nexport function getLeft(ma) {\n    return ma._tag === 'Right' ? none : some(ma.left);\n}\n/**\n * Returns the `Right` value of an `Either` if possible.\n *\n * @example\n * import { getRight, none, some } from 'fp-ts/Option'\n * import { right, left } from 'fp-ts/Either'\n *\n * assert.deepStrictEqual(getRight(right(1)), some(1))\n * assert.deepStrictEqual(getRight(left('a')), none)\n *\n * @category constructors\n * @since 2.0.0\n */\nexport function getRight(ma) {\n    return ma._tag === 'Left' ? none : some(ma.right);\n}\n/**\n * Transforms an `Either` to an `Option` discarding the error.\n *\n * Alias of [getRight](#getRight)\n *\n * Derivable from `MonadThrow`.\n *\n * @category constructors\n * @since 2.0.0\n */\nexport var fromEither = getRight;\n// -------------------------------------------------------------------------------------\n// destructors\n// -------------------------------------------------------------------------------------\n/**\n * Takes a (lazy) default value, a function, and an `Option` value, if the `Option` value is `None` the default value is\n * returned, otherwise the function is applied to the value inside the `Some` and the result is returned.\n *\n * @example\n * import { some, none, fold } from 'fp-ts/Option'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.strictEqual(\n *   pipe(\n *     some(1),\n *     fold(() => 'a none', a => `a some containing ${a}`)\n *   ),\n *   'a some containing 1'\n * )\n *\n * assert.strictEqual(\n *   pipe(\n *     none,\n *     fold(() => 'a none', a => `a some containing ${a}`)\n *   ),\n *   'a none'\n * )\n *\n * @category destructors\n * @since 2.0.0\n */\nexport function fold(onNone, onSome) {\n    return function (ma) { return (isNone(ma) ? onNone() : onSome(ma.value)); };\n}\n/**\n * Extracts the value out of the structure, if it exists. Otherwise returns `null`.\n *\n * @example\n * import { some, none, toNullable } from 'fp-ts/Option'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.strictEqual(\n *   pipe(\n *     some(1),\n *     toNullable\n *   ),\n *   1\n * )\n * assert.strictEqual(\n *   pipe(\n *     none,\n *     toNullable\n *   ),\n *   null\n * )\n *\n * @category destructors\n * @since 2.0.0\n */\nexport function toNullable(ma) {\n    return isNone(ma) ? null : ma.value;\n}\n/**\n * Extracts the value out of the structure, if it exists. Otherwise returns `undefined`.\n *\n * @example\n * import { some, none, toUndefined } from 'fp-ts/Option'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.strictEqual(\n *   pipe(\n *     some(1),\n *     toUndefined\n *   ),\n *   1\n * )\n * assert.strictEqual(\n *   pipe(\n *     none,\n *     toUndefined\n *   ),\n *   undefined\n * )\n *\n * @category destructors\n * @since 2.0.0\n */\nexport function toUndefined(ma) {\n    return isNone(ma) ? undefined : ma.value;\n}\n/**\n * Less strict version of [`getOrElse`](#getOrElse).\n *\n * @category destructors\n * @since 2.6.0\n */\nexport var getOrElseW = function (onNone) { return function (ma) { return (isNone(ma) ? onNone() : ma.value); }; };\n/**\n * Extracts the value out of the structure, if it exists. Otherwise returns the given default value\n *\n * @example\n * import { some, none, getOrElse } from 'fp-ts/Option'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.strictEqual(\n *   pipe(\n *     some(1),\n *     getOrElse(() => 0)\n *   ),\n *   1\n * )\n * assert.strictEqual(\n *   pipe(\n *     none,\n *     getOrElse(() => 0)\n *   ),\n *   0\n * )\n *\n * @category destructors\n * @since 2.0.0\n */\nexport var getOrElse = getOrElseW;\n// -------------------------------------------------------------------------------------\n// combinators\n// -------------------------------------------------------------------------------------\n/**\n * Returns a *smart constructor* from a function that returns a nullable value.\n *\n * @example\n * import { fromNullableK, none, some } from 'fp-ts/Option'\n *\n * const f = (s: string): number | undefined => {\n *   const n = parseFloat(s)\n *   return isNaN(n) ? undefined : n\n * }\n *\n * const g = fromNullableK(f)\n *\n * assert.deepStrictEqual(g('1'), some(1))\n * assert.deepStrictEqual(g('a'), none)\n *\n * @category combinators\n * @since 2.9.0\n */\nexport function fromNullableK(f) {\n    return function () {\n        var a = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            a[_i] = arguments[_i];\n        }\n        return fromNullable(f.apply(void 0, a));\n    };\n}\n/**\n * @category combinators\n * @since 2.0.0\n * @deprecated\n */\nexport var mapNullable = chainNullableK;\n/**\n * This is `chain` + `fromNullable`, useful when working with optional values.\n *\n * @example\n * import { some, none, fromNullable, chainNullableK } from 'fp-ts/Option'\n * import { pipe } from 'fp-ts/function'\n *\n * interface Employee {\n *   company?: {\n *     address?: {\n *       street?: {\n *         name?: string\n *       }\n *     }\n *   }\n * }\n *\n * const employee1: Employee = { company: { address: { street: { name: 'high street' } } } }\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     fromNullable(employee1.company),\n *     chainNullableK(company => company.address),\n *     chainNullableK(address => address.street),\n *     chainNullableK(street => street.name)\n *   ),\n *   some('high street')\n * )\n *\n * const employee2: Employee = { company: { address: { street: {} } } }\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     fromNullable(employee2.company),\n *     chainNullableK(company => company.address),\n *     chainNullableK(address => address.street),\n *     chainNullableK(street => street.name)\n *   ),\n *   none\n * )\n *\n * @category combinators\n * @since 2.9.0\n */\nexport function chainNullableK(f) {\n    return function (ma) { return (isNone(ma) ? none : fromNullable(f(ma.value))); };\n}\n// -------------------------------------------------------------------------------------\n// non-pipeables\n// -------------------------------------------------------------------------------------\nvar map_ = function (fa, f) { return pipe(fa, map(f)); };\nvar ap_ = function (fab, fa) { return pipe(fab, ap(fa)); };\nvar chain_ = function (ma, f) { return pipe(ma, chain(f)); };\nvar reduce_ = function (fa, b, f) { return pipe(fa, reduce(b, f)); };\nvar foldMap_ = function (M) {\n    var foldMapM = foldMap(M);\n    return function (fa, f) { return pipe(fa, foldMapM(f)); };\n};\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};\n/* istanbul ignore next */\nvar alt_ = function (fa, that) { return pipe(fa, alt(that)); };\nvar filter_ = function (fa, predicate) {\n    return pipe(fa, filter(predicate));\n};\n/* istanbul ignore next */\nvar filterMap_ = function (fa, f) { return pipe(fa, filterMap(f)); };\n/* istanbul ignore next */\nvar extend_ = function (wa, f) { return pipe(wa, extend(f)); };\n/* istanbul ignore next */\nvar partition_ = function (fa, predicate) { return pipe(fa, partition(predicate)); };\n/* istanbul ignore next */\nvar partitionMap_ = function (fa, f) { return pipe(fa, partitionMap(f)); };\n/* istanbul ignore next */\nvar wither_ = function (F) {\n    var witherF = wither(F);\n    return function (fa, f) { return pipe(fa, witherF(f)); };\n};\n/* istanbul ignore next */\nvar wilt_ = function (F) {\n    var wiltF = wilt(F);\n    return function (fa, f) { return pipe(fa, wiltF(f)); };\n};\n// -------------------------------------------------------------------------------------\n// pipeables\n// -------------------------------------------------------------------------------------\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 Functor\n * @since 2.0.0\n */\nexport var map = function (f) { return function (fa) {\n    return isNone(fa) ? none : some(f(fa.value));\n}; };\n/**\n * Apply a function to an argument under a type constructor.\n *\n * @category Apply\n * @since 2.0.0\n */\nexport var ap = function (fa) { return function (fab) {\n    return isNone(fab) ? none : isNone(fa) ? none : some(fab.value(fa.value));\n}; };\n/**\n * Combine two effectful actions, keeping only the result of the first.\n *\n * Derivable from `Apply`.\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var apFirst = function (fb) {\n    return flow(map(function (a) { return function () { return a; }; }), ap(fb));\n};\n/**\n * Combine two effectful actions, keeping only the result of the second.\n *\n * Derivable from `Apply`.\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var apSecond = function (fb) {\n    return flow(map(function () { return function (b) { return b; }; }), ap(fb));\n};\n/**\n * Wrap a value into the type constructor.\n *\n * @category Applicative\n * @since 2.7.0\n */\nexport var of = some;\n/**\n * Composes computations in sequence, using the return value of one computation to determine the next computation.\n *\n * @category Monad\n * @since 2.0.0\n */\nexport var chain = function (f) { return function (ma) {\n    return isNone(ma) ? none : f(ma.value);\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 * Derivable from `Monad`.\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var chainFirst = function (f) {\n    return chain(function (a) {\n        return pipe(f(a), map(function () { return a; }));\n    });\n};\n/**\n * Derivable from `Monad`.\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var flatten = \n/*#__PURE__*/\nchain(identity);\n/**\n * Less strict version of [`alt`](#alt).\n *\n * @category Alt\n * @since 2.9.0\n */\nexport var altW = function (that) { return function (fa) {\n    return isNone(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 `Option` returns the left-most non-`None` value.\n *\n * @example\n * import * as O from 'fp-ts/Option'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     O.some('a'),\n *     O.alt(() => O.some('b'))\n *   ),\n *   O.some('a')\n * )\n * assert.deepStrictEqual(\n *   pipe(\n *     O.none,\n *     O.alt(() => O.some('b'))\n *   ),\n *   O.some('b')\n * )\n *\n * @category Alt\n * @since 2.0.0\n */\nexport var alt = altW;\n/**\n * @category Alternative\n * @since 2.7.0\n */\nexport var zero = function () { return none; };\n/**\n * @category MonadThrow\n * @since 2.7.0\n */\nexport var throwError = function () { return none; };\n/**\n * @category Extend\n * @since 2.0.0\n */\nexport var extend = function (f) { return function (wa) {\n    return isNone(wa) ? none : some(f(wa));\n}; };\n/**\n * Derivable from `Extend`.\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var duplicate = \n/*#__PURE__*/\nextend(identity);\n/**\n * @category Foldable\n * @since 2.0.0\n */\nexport var reduce = function (b, f) { return function (fa) {\n    return isNone(fa) ? b : f(b, fa.value);\n}; };\n/**\n * @category Foldable\n * @since 2.0.0\n */\nexport var foldMap = function (M) { return function (f) { return function (fa) {\n    return isNone(fa) ? M.empty : f(fa.value);\n}; }; };\n/**\n * @category Foldable\n * @since 2.0.0\n */\nexport var reduceRight = function (b, f) { return function (fa) {\n    return isNone(fa) ? b : f(fa.value, b);\n}; };\n/**\n * @category Compactable\n * @since 2.0.0\n */\nexport var compact = flatten;\nvar defaultSeparate = { left: none, right: none };\n/**\n * @category Compactable\n * @since 2.0.0\n */\nexport var separate = function (ma) {\n    var o = pipe(ma, map(function (e) { return ({\n        left: getLeft(e),\n        right: getRight(e)\n    }); }));\n    return isNone(o) ? defaultSeparate : o.value;\n};\n/**\n * @category Filterable\n * @since 2.0.0\n */\nexport var filter = function (predicate) { return function (fa) { return (isNone(fa) ? none : predicate(fa.value) ? fa : none); }; };\n/**\n * @category Filterable\n * @since 2.0.0\n */\nexport var filterMap = function (f) { return function (fa) {\n    return isNone(fa) ? none : f(fa.value);\n}; };\n/**\n * @category Filterable\n * @since 2.0.0\n */\nexport var partition = function (predicate) { return function (fa) {\n    return {\n        left: filter_(fa, function (a) { return !predicate(a); }),\n        right: filter_(fa, predicate)\n    };\n}; };\n/**\n * @category Filterable\n * @since 2.0.0\n */\nexport var partitionMap = function (f) { return flow(map(f), separate); };\n/**\n * @category Traversable\n * @since 2.6.3\n */\nexport var traverse = function (F) { return function (f) { return function (ta) { return (isNone(ta) ? F.of(none) : F.map(f(ta.value), some)); }; }; };\n/**\n * @category Traversable\n * @since 2.6.3\n */\nexport var sequence = function (F) { return function (ta) { return (isNone(ta) ? F.of(none) : F.map(ta.value, some)); }; };\n/**\n * @category Witherable\n * @since 2.6.5\n */\nexport var wither = function (F) { return function (f) { return function (fa) { return (isNone(fa) ? F.of(none) : f(fa.value)); }; }; };\n/**\n * @category Witherable\n * @since 2.6.5\n */\nexport var wilt = function (F) { return function (f) { return function (fa) {\n    return isNone(fa)\n        ? F.of({\n            left: none,\n            right: none\n        })\n        : F.map(f(fa.value), function (e) { return ({\n            left: getLeft(e),\n            right: getRight(e)\n        }); });\n}; }; };\n// -------------------------------------------------------------------------------------\n// instances\n// -------------------------------------------------------------------------------------\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var URI = 'Option';\n/**\n * @category instances\n * @since 2.0.0\n */\nexport function getShow(S) {\n    return {\n        show: function (ma) { return (isNone(ma) ? 'none' : \"some(\" + S.show(ma.value) + \")\"); }\n    };\n}\n/**\n * @example\n * import { none, some, getEq } from 'fp-ts/Option'\n * import { eqNumber } from 'fp-ts/Eq'\n *\n * const E = getEq(eqNumber)\n * assert.strictEqual(E.equals(none, none), true)\n * assert.strictEqual(E.equals(none, some(1)), false)\n * assert.strictEqual(E.equals(some(1), none), false)\n * assert.strictEqual(E.equals(some(1), some(2)), false)\n * assert.strictEqual(E.equals(some(1), some(1)), true)\n *\n * @category instances\n * @since 2.0.0\n */\nexport function getEq(E) {\n    return {\n        equals: function (x, y) { return x === y || (isNone(x) ? isNone(y) : isNone(y) ? false : E.equals(x.value, y.value)); }\n    };\n}\n/**\n * The `Ord` instance allows `Option` values to be compared with\n * `compare`, whenever there is an `Ord` instance for\n * the type the `Option` contains.\n *\n * `None` is considered to be less than any `Some` value.\n *\n *\n * @example\n * import { none, some, getOrd } from 'fp-ts/Option'\n * import { ordNumber } from 'fp-ts/Ord'\n *\n * const O = getOrd(ordNumber)\n * assert.strictEqual(O.compare(none, none), 0)\n * assert.strictEqual(O.compare(none, some(1)), -1)\n * assert.strictEqual(O.compare(some(1), none), 1)\n * assert.strictEqual(O.compare(some(1), some(2)), -1)\n * assert.strictEqual(O.compare(some(1), some(1)), 0)\n *\n * @category instances\n * @since 2.0.0\n */\nexport function getOrd(O) {\n    return {\n        equals: getEq(O).equals,\n        compare: function (x, y) { return (x === y ? 0 : isSome(x) ? (isSome(y) ? O.compare(x.value, y.value) : 1) : -1); }\n    };\n}\n/**\n * `Apply` semigroup\n *\n * | x       | y       | concat(x, y)       |\n * | ------- | ------- | ------------------ |\n * | none    | none    | none               |\n * | some(a) | none    | none               |\n * | none    | some(a) | none               |\n * | some(a) | some(b) | some(concat(a, b)) |\n *\n * @example\n * import { getApplySemigroup, some, none } from 'fp-ts/Option'\n * import { semigroupSum } from 'fp-ts/Semigroup'\n *\n * const S = getApplySemigroup(semigroupSum)\n * assert.deepStrictEqual(S.concat(none, none), none)\n * assert.deepStrictEqual(S.concat(some(1), none), none)\n * assert.deepStrictEqual(S.concat(none, some(1)), none)\n * assert.deepStrictEqual(S.concat(some(1), some(2)), some(3))\n *\n * @category instances\n * @since 2.0.0\n */\nexport function getApplySemigroup(S) {\n    return {\n        concat: function (x, y) { return (isSome(x) && isSome(y) ? some(S.concat(x.value, y.value)) : none); }\n    };\n}\n/**\n * @category instances\n * @since 2.0.0\n */\nexport function getApplyMonoid(M) {\n    return {\n        concat: getApplySemigroup(M).concat,\n        empty: some(M.empty)\n    };\n}\n/**\n * Monoid returning the left-most non-`None` value\n *\n * | x       | y       | concat(x, y) |\n * | ------- | ------- | ------------ |\n * | none    | none    | none         |\n * | some(a) | none    | some(a)      |\n * | none    | some(a) | some(a)      |\n * | some(a) | some(b) | some(a)      |\n *\n * @example\n * import { getFirstMonoid, some, none } from 'fp-ts/Option'\n *\n * const M = getFirstMonoid<number>()\n * assert.deepStrictEqual(M.concat(none, none), none)\n * assert.deepStrictEqual(M.concat(some(1), none), some(1))\n * assert.deepStrictEqual(M.concat(none, some(1)), some(1))\n * assert.deepStrictEqual(M.concat(some(1), some(2)), some(1))\n *\n * @category instances\n * @since 2.0.0\n */\nexport function getFirstMonoid() {\n    return {\n        concat: function (x, y) { return (isNone(x) ? y : x); },\n        empty: none\n    };\n}\n/**\n * Monoid returning the right-most non-`None` value\n *\n * | x       | y       | concat(x, y) |\n * | ------- | ------- | ------------ |\n * | none    | none    | none         |\n * | some(a) | none    | some(a)      |\n * | none    | some(a) | some(a)      |\n * | some(a) | some(b) | some(b)      |\n *\n * @example\n * import { getLastMonoid, some, none } from 'fp-ts/Option'\n *\n * const M = getLastMonoid<number>()\n * assert.deepStrictEqual(M.concat(none, none), none)\n * assert.deepStrictEqual(M.concat(some(1), none), some(1))\n * assert.deepStrictEqual(M.concat(none, some(1)), some(1))\n * assert.deepStrictEqual(M.concat(some(1), some(2)), some(2))\n *\n * @category instances\n * @since 2.0.0\n */\nexport function getLastMonoid() {\n    return {\n        concat: function (x, y) { return (isNone(y) ? x : y); },\n        empty: none\n    };\n}\n/**\n * Monoid returning the left-most non-`None` value. If both operands are `Some`s then the inner values are\n * concatenated using the provided `Semigroup`\n *\n * | x       | y       | concat(x, y)       |\n * | ------- | ------- | ------------------ |\n * | none    | none    | none               |\n * | some(a) | none    | some(a)            |\n * | none    | some(a) | some(a)            |\n * | some(a) | some(b) | some(concat(a, b)) |\n *\n * @example\n * import { getMonoid, some, none } from 'fp-ts/Option'\n * import { semigroupSum } from 'fp-ts/Semigroup'\n *\n * const M = getMonoid(semigroupSum)\n * assert.deepStrictEqual(M.concat(none, none), none)\n * assert.deepStrictEqual(M.concat(some(1), none), some(1))\n * assert.deepStrictEqual(M.concat(none, some(1)), some(1))\n * assert.deepStrictEqual(M.concat(some(1), some(2)), some(3))\n *\n * @category instances\n * @since 2.0.0\n */\nexport function getMonoid(S) {\n    return {\n        concat: function (x, y) { return (isNone(x) ? y : isNone(y) ? x : some(S.concat(x.value, y.value))); },\n        empty: none\n    };\n}\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Functor = {\n    URI: URI,\n    map: map_\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.7.0\n */\nexport var Monad = {\n    URI: URI,\n    map: map_,\n    ap: ap_,\n    of: of,\n    chain: chain_\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 * @category instances\n * @since 2.7.0\n */\nexport var Alt = {\n    URI: URI,\n    map: map_,\n    alt: alt_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Alternative = {\n    URI: URI,\n    map: map_,\n    ap: ap_,\n    of: of,\n    alt: alt_,\n    zero: zero\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 Compactable = {\n    URI: URI,\n    compact: compact,\n    separate: separate\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Filterable = {\n    URI: URI,\n    map: map_,\n    compact: compact,\n    separate: separate,\n    filter: filter_,\n    filterMap: filterMap_,\n    partition: partition_,\n    partitionMap: partitionMap_\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 * @category instances\n * @since 2.7.0\n */\nexport var Witherable = {\n    URI: URI,\n    map: map_,\n    reduce: reduce_,\n    foldMap: foldMap_,\n    reduceRight: reduceRight_,\n    traverse: traverse_,\n    sequence: sequence,\n    compact: compact,\n    separate: separate,\n    filter: filter_,\n    filterMap: filterMap_,\n    partition: partition_,\n    partitionMap: partitionMap_,\n    wither: wither_,\n    wilt: wilt_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var MonadThrow = {\n    URI: URI,\n    map: map_,\n    ap: ap_,\n    of: of,\n    chain: chain_,\n    throwError: throwError\n};\n// TODO: remove in v3\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var option = {\n    URI: URI,\n    map: map_,\n    of: of,\n    ap: ap_,\n    chain: chain_,\n    reduce: reduce_,\n    foldMap: foldMap_,\n    reduceRight: reduceRight_,\n    traverse: traverse_,\n    sequence: sequence,\n    zero: zero,\n    alt: alt_,\n    extend: extend_,\n    compact: compact,\n    separate: separate,\n    filter: filter_,\n    filterMap: filterMap_,\n    partition: partition_,\n    partitionMap: partitionMap_,\n    wither: wither_,\n    wilt: wilt_,\n    throwError: throwError\n};\n// -------------------------------------------------------------------------------------\n// utils\n// -------------------------------------------------------------------------------------\n/**\n * Returns `true` if `ma` contains `a`\n *\n * @example\n * import { some, none, elem } from 'fp-ts/Option'\n * import { eqNumber } from 'fp-ts/Eq'\n *\n * assert.strictEqual(elem(eqNumber)(1, some(1)), true)\n * assert.strictEqual(elem(eqNumber)(2, some(1)), false)\n * assert.strictEqual(elem(eqNumber)(1, none), false)\n *\n * @since 2.0.0\n */\nexport function elem(E) {\n    return function (a, ma) { return (isNone(ma) ? false : E.equals(a, ma.value)); };\n}\n/**\n * Returns `true` if the predicate is satisfied by the wrapped value\n *\n * @example\n * import { some, none, exists } from 'fp-ts/Option'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.strictEqual(\n *   pipe(\n *     some(1),\n *     exists(n => n > 0)\n *   ),\n *   true\n * )\n * assert.strictEqual(\n *   pipe(\n *     some(1),\n *     exists(n => n > 1)\n *   ),\n *   false\n * )\n * assert.strictEqual(\n *   pipe(\n *     none,\n *     exists(n => n > 0)\n *   ),\n *   false\n * )\n *\n * @since 2.0.0\n */\nexport function exists(predicate) {\n    return function (ma) { return (isNone(ma) ? false : predicate(ma.value)); };\n}\n/**\n * Returns a `Refinement` (i.e. a custom type guard) from a `Option` returning function.\n * This function ensures that a custom type guard definition is type-safe.\n *\n * ```ts\n * import { some, none, getRefinement } from 'fp-ts/Option'\n *\n * type A = { type: 'A' }\n * type B = { type: 'B' }\n * type C = A | B\n *\n * const isA = (c: C): c is A => c.type === 'B' // <= typo but typescript doesn't complain\n * const isA = getRefinement<C, A>(c => (c.type === 'B' ? some(c) : none)) // static error: Type '\"B\"' is not assignable to type '\"A\"'\n * ```\n *\n * @since 2.0.0\n */\nexport function getRefinement(getOption) {\n    return function (a) { return isSome(getOption(a)); };\n}\n// -------------------------------------------------------------------------------------\n// do notation\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.9.0\n */\nexport var Do = \n/*#__PURE__*/\nof({});\n/**\n * @since 2.8.0\n */\nexport var bindTo = function (name) { return map(bindTo_(name)); };\n/**\n * @since 2.8.0\n */\nexport var bind = function (name, f) {\n    return chain(function (a) {\n        return pipe(f(a), map(function (b) { return bind_(a, name, b); }));\n    });\n};\n// -------------------------------------------------------------------------------------\n// pipeable sequence S\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.8.0\n */\nexport var apS = function (name, fb) {\n    return flow(map(function (a) { return function (b) { return bind_(a, name, b); }; }), ap(fb));\n};\n// -------------------------------------------------------------------------------------\n// array utils\n// -------------------------------------------------------------------------------------\n/**\n *\n * @since 2.9.0\n */\nexport var traverseArrayWithIndex = function (f) { return function (arr) {\n    // tslint:disable-next-line: readonly-array\n    var result = [];\n    for (var i = 0; i < arr.length; i++) {\n        var b = f(i, arr[i]);\n        if (isNone(b)) {\n            return none;\n        }\n        result.push(b.value);\n    }\n    return some(result);\n}; };\n/**\n * Runs an action for every element in array and accumulates the results in option\n *\n * this function have the same behavior of `A.sequence(O.option)` but it's optimized and perform better\n *\n * @example\n *\n * import * as A from 'fp-ts/Array'\n * import { traverseArray, some, fromPredicate, none } from 'fp-ts/Option'\n * import { pipe } from 'fp-ts/function'\n *\n * const arr = A.range(0, 10)\n * assert.deepStrictEqual(pipe(arr, traverseArray(some)), some(arr))\n * assert.deepStrictEqual(pipe(arr, traverseArray(fromPredicate((x) => x > 5))), none)\n *\n * @since 2.9.0\n */\nexport var traverseArray = function (f) { return traverseArrayWithIndex(function (_, a) { return f(a); }); };\n/**\n * get an array of option and convert it to option of array\n *\n * this function have the same behavior of `A.sequence(O.option)` but it's optimized and perform better\n *\n * @example\n *\n * import * as A from 'fp-ts/Array'\n * import { sequenceArray, some, none, fromPredicate } from 'fp-ts/Option'\n * import { pipe } from 'fp-ts/function'\n *\n * const arr = A.range(0, 10)\n * assert.deepStrictEqual(pipe(arr, A.map(some), sequenceArray), some(arr))\n * assert.deepStrictEqual(pipe(arr, A.map(fromPredicate(x => x > 8)), sequenceArray), none)\n *\n * @since 2.9.0\n */\nexport var sequenceArray = \n/*#__PURE__*/\ntraverseArray(identity);\n","import { identity, pipe, bind_, bindTo_, flow, constant } from './function';\n// -------------------------------------------------------------------------------------\n// non-pipeables\n// -------------------------------------------------------------------------------------\nvar map_ = function (ma, f) { return function () { return f(ma()); }; };\nvar ap_ = function (mab, ma) { return function () { return mab()(ma()); }; };\nvar chain_ = function (ma, f) { return function () { return f(ma())(); }; };\nvar chainRec_ = function (a, f) { return function () {\n    var e = f(a)();\n    while (e._tag === 'Left') {\n        e = f(e.left)();\n    }\n    return e.right;\n}; };\n// -------------------------------------------------------------------------------------\n// pipeables\n// -------------------------------------------------------------------------------------\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 Functor\n * @since 2.0.0\n */\nexport var map = function (f) { return function (fa) { return map_(fa, f); }; };\n/**\n * Apply a function to an argument under a type constructor.\n *\n * @category Apply\n * @since 2.0.0\n */\nexport var ap = function (fa) { return function (fab) { return ap_(fab, fa); }; };\n/**\n * Combine two effectful actions, keeping only the result of the first.\n *\n * Derivable from `Apply`.\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var apFirst = function (fb) {\n    return flow(map(function (a) { return function () { return a; }; }), ap(fb));\n};\n/**\n * Combine two effectful actions, keeping only the result of the second.\n *\n * Derivable from `Apply`.\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var apSecond = function (fb) {\n    return flow(map(function () { return function (b) { return b; }; }), ap(fb));\n};\n/**\n * Wrap a value into the type constructor.\n *\n * @category Applicative\n * @since 2.0.0\n */\nexport var of = constant;\n/**\n * Composes computations in sequence, using the return value of one computation to determine the next computation.\n *\n * @category Monad\n * @since 2.0.0\n */\nexport var chain = function (f) { return function (ma) { return chain_(ma, 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 * Derivable from `Monad`.\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var chainFirst = function (f) {\n    return chain(function (a) {\n        return pipe(f(a), map(function () { return a; }));\n    });\n};\n/**\n * Derivable from `Monad`.\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var flatten = \n/*#__PURE__*/\nchain(identity);\n/**\n * @category MonadIO\n * @since 2.7.0\n */\nexport var fromIO = identity;\n// -------------------------------------------------------------------------------------\n// instances\n// -------------------------------------------------------------------------------------\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var URI = 'IO';\n/**\n * @category instances\n * @since 2.0.0\n */\nexport function getSemigroup(S) {\n    return {\n        concat: function (x, y) { return function () { return S.concat(x(), y()); }; }\n    };\n}\n/**\n * @category instances\n * @since 2.0.0\n */\nexport function getMonoid(M) {\n    return {\n        concat: getSemigroup(M).concat,\n        empty: of(M.empty)\n    };\n}\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Functor = {\n    URI: URI,\n    map: map_\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.7.0\n */\nexport var Monad = {\n    URI: URI,\n    map: map_,\n    ap: ap_,\n    of: of,\n    chain: chain_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var MonadIO = {\n    URI: URI,\n    map: map_,\n    ap: ap_,\n    of: of,\n    chain: chain_,\n    fromIO: fromIO\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: chain_,\n    chainRec: chainRec_\n};\n// TODO: remove in v3\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var io = {\n    URI: URI,\n    map: map_,\n    of: of,\n    ap: ap_,\n    chain: chain_,\n    fromIO: fromIO,\n    chainRec: chainRec_\n};\n// -------------------------------------------------------------------------------------\n// do notation\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.9.0\n */\nexport var Do = \n/*#__PURE__*/\nof({});\n/**\n * @since 2.8.0\n */\nexport var bindTo = function (name) { return map(bindTo_(name)); };\n/**\n * @since 2.8.0\n */\nexport var bind = function (name, f) {\n    return chain(function (a) {\n        return pipe(f(a), map(function (b) { return bind_(a, name, b); }));\n    });\n};\n// -------------------------------------------------------------------------------------\n// pipeable sequence S\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.8.0\n */\nexport var apS = function (name, fb) {\n    return flow(map(function (a) { return function (b) { return bind_(a, name, b); }; }), ap(fb));\n};\n// -------------------------------------------------------------------------------------\n// array utils\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.9.0\n */\nexport var traverseArrayWithIndex = function (f) { return function (arr) { return function () { return arr.map(function (a, i) { return f(i, a)(); }); }; }; };\n/**\n * runs an action for every element in array, and accumulates the results IO in the array.\n *\n * this function have the same behavior of `A.traverse(IO.io)` but it's stack safe\n *\n * @example\n * import * as RA from 'fp-ts/ReadonlyArray'\n * import { traverseArray, IO } from 'fp-ts/IO'\n * import { pipe } from 'fp-ts/function'\n *\n * const logger: Array<unknown> = []\n * const log: <A>(a: A) => IO<void> = (a) => () => { logger.push(a) }\n *\n * pipe(RA.range(0, 100), traverseArray(log))()\n * assert.deepStrictEqual(logger, RA.range(0, 100))\n *\n * @since 2.9.0\n */\nexport var traverseArray = function (f) {\n    return traverseArrayWithIndex(function (_, a) { return f(a); });\n};\n/**\n * transform Array of IO to IO of Array\n *\n * this function have the same behavior of `A.sequence(IO.io)` but it's stack safe\n *\n * @example\n * import * as RA from 'fp-ts/ReadonlyArray'\n * import { sequenceArray, IO } from 'fp-ts/IO'\n * import { pipe } from 'fp-ts/function'\n *\n * const logger: Array<unknown> = []\n * const log: <A>(a: A) => IO<void> = (a) => () => { logger.push(a) }\n *\n * pipe(RA.range(0, 100), RA.map(log), sequenceArray)()\n * assert.deepStrictEqual(logger, RA.range(0, 100))\n *\n * @since 2.9.0\n */\nexport var sequenceArray = \n/*#__PURE__*/\ntraverseArray(identity);\n","/**\n * @since 2.0.0\n */\nexport function sign(n) {\n    return n <= -1 ? -1 : n >= 1 ? 1 : 0;\n}\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var eqOrdering = {\n    equals: function (x, y) { return x === y; }\n};\n/**\n * Use `monoidOrdering` instead\n *\n * @category instances\n * @since 2.0.0\n * @deprecated\n */\nexport var semigroupOrdering = {\n    concat: function (x, y) { return (x !== 0 ? x : y); }\n};\n/**\n * @category instances\n * @since 2.4.0\n */\nexport var monoidOrdering = {\n    // tslint:disable-next-line: deprecation\n    concat: semigroupOrdering.concat,\n    empty: 0\n};\n/**\n * @since 2.0.0\n */\nexport function invert(O) {\n    switch (O) {\n        case -1:\n            return 1;\n        case 1:\n            return -1;\n        default:\n            return 0;\n    }\n}\n","import * as RNEA from './ReadonlyNonEmptyArray';\n/* tslint:enable:readonly-keyword */\n/**\n * Append an element to the front of an array, creating a new non empty array\n *\n * @example\n * import { cons } from 'fp-ts/NonEmptyArray'\n *\n * assert.deepStrictEqual(cons(1, [2, 3, 4]), [1, 2, 3, 4])\n *\n * @category constructors\n * @since 2.0.0\n */\nexport var cons = RNEA.cons;\n/**\n * Append an element to the end of an array, creating a new non empty array\n *\n * @example\n * import { snoc } from 'fp-ts/NonEmptyArray'\n *\n * assert.deepStrictEqual(snoc([1, 2, 3], 4), [1, 2, 3, 4])\n *\n * @category constructors\n * @since 2.0.0\n */\nexport var snoc = RNEA.snoc;\n/**\n * Builds a `NonEmptyArray` from an `Array` returning `none` if `as` is an empty array\n *\n * @category constructors\n * @since 2.0.0\n */\nexport var fromArray = RNEA.fromArray;\n/**\n * Produces a couple of the first element of the array, and a new array of the remaining elements, if any\n *\n * @example\n * import { cons, uncons } from 'fp-ts/NonEmptyArray'\n *\n * assert.deepStrictEqual(uncons(cons(1, [2, 3, 4])), [1, [2, 3, 4]])\n *\n * @category destructors\n * @since 2.9.0\n */\nexport var uncons = RNEA.uncons;\n/**\n * Produces a couple of a copy of the array without its last element, and that last element\n *\n * @example\n * import { snoc, unsnoc } from 'fp-ts/NonEmptyArray'\n *\n * assert.deepStrictEqual(unsnoc(snoc([1, 2, 3], 4)), [[1, 2, 3], 4])\n *\n * @category destructors\n * @since 2.9.0\n */\nexport var unsnoc = RNEA.unsnoc;\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var getShow = RNEA.getShow;\n/**\n * @since 2.0.0\n */\nexport var head = RNEA.head;\n/**\n * @since 2.0.0\n */\nexport var tail = RNEA.tail;\n/**\n * @category combinators\n * @since 2.0.0\n */\nexport var reverse = RNEA.reverse;\n/**\n * @since 2.0.0\n */\nexport var min = RNEA.min;\n/**\n * @since 2.0.0\n */\nexport var max = RNEA.max;\n/**\n * Builds a `Semigroup` instance for `NonEmptyArray`\n *\n * @category instances\n * @since 2.0.0\n */\nexport var getSemigroup = RNEA.getSemigroup;\n/**\n * @example\n * import { getEq, cons } from 'fp-ts/NonEmptyArray'\n * import { eqNumber } from 'fp-ts/Eq'\n *\n * const E = getEq(eqNumber)\n * assert.strictEqual(E.equals(cons(1, [2]), [1, 2]), true)\n * assert.strictEqual(E.equals(cons(1, [2]), [1, 3]), false)\n *\n * @category instances\n * @since 2.0.0\n */\nexport var getEq = RNEA.getEq;\nexport function group(E) {\n    return RNEA.group(E);\n}\n/**\n * Sort and then group the elements of an array into non empty arrays.\n *\n * @example\n * import { cons, groupSort } from 'fp-ts/NonEmptyArray'\n * import { ordNumber } from 'fp-ts/Ord'\n *\n * assert.deepStrictEqual(groupSort(ordNumber)([1, 2, 1, 1]), [cons(1, [1, 1]), cons(2, [])])\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var groupSort = RNEA.groupSort;\n/**\n * Splits an array into sub-non-empty-arrays stored in an object, based on the result of calling a `string`-returning\n * function on each element, and grouping the results according to values returned\n *\n * @example\n * import { cons, groupBy } from 'fp-ts/NonEmptyArray'\n *\n * assert.deepStrictEqual(groupBy((s: string) => String(s.length))(['foo', 'bar', 'foobar']), {\n *   '3': cons('foo', ['bar']),\n *   '6': cons('foobar', [])\n * })\n *\n * @category constructors\n * @since 2.0.0\n */\nexport var groupBy = RNEA.groupBy;\n/**\n * @since 2.0.0\n */\nexport var last = RNEA.last;\n/**\n * Get all but the last element of a non empty array, creating a new array.\n *\n * @example\n * import { init } from 'fp-ts/NonEmptyArray'\n *\n * assert.deepStrictEqual(init([1, 2, 3]), [1, 2])\n * assert.deepStrictEqual(init([1]), [])\n *\n * @since 2.2.0\n */\nexport var init = RNEA.init;\n/**\n * @category combinators\n * @since 2.0.0\n */\nexport var sort = RNEA.sort;\n/**\n * @since 2.0.0\n */\nexport var insertAt = RNEA.insertAt;\n/**\n * @since 2.0.0\n */\nexport var updateAt = RNEA.updateAt;\n/**\n * @since 2.0.0\n */\nexport var modifyAt = RNEA.modifyAt;\n/**\n * @category combinators\n * @since 2.0.0\n */\nexport function copy(nea) {\n    var l = nea.length;\n    var as = Array(l);\n    for (var i = 0; i < l; i++) {\n        as[i] = nea[i];\n    }\n    return as;\n}\nexport function filter(predicate) {\n    return RNEA.filter(predicate);\n}\n/**\n * @since 2.0.0\n */\nexport var filterWithIndex = RNEA.filterWithIndex;\n/**\n * Wrap a value into the type constructor.\n *\n * @category Applicative\n * @since 2.0.0\n */\nexport var of = RNEA.of;\nexport function concat(fx, fy) {\n    return RNEA.concat(fx, fy);\n}\n/**\n * @since 2.5.0\n */\nexport var fold = RNEA.fold;\n/**\n * @category combinators\n * @since 2.5.1\n */\nexport var zipWith = RNEA.zipWith;\n/**\n * @category combinators\n * @since 2.5.1\n */\nexport var zip = RNEA.zip;\n/**\n * @since 2.5.1\n */\nexport var unzip = RNEA.unzip;\n/**\n * Prepend an element to every member of an array\n *\n * @example\n * import { cons, prependToAll } from 'fp-ts/NonEmptyArray'\n *\n * assert.deepStrictEqual(prependToAll(9)(cons(1, [2, 3, 4])), cons(9, [1, 9, 2, 9, 3, 9, 4]))\n *\n * @category combinators\n * @since 2.9.0\n */\nexport var prependToAll = RNEA.prependToAll;\n/**\n * Places an element in between members of an array\n *\n * @example\n * import { cons, intersperse } from 'fp-ts/NonEmptyArray'\n *\n * assert.deepStrictEqual(intersperse(9)(cons(1, [2, 3, 4])), cons(1, [9, 2, 9, 3, 9, 4]))\n *\n * @category combinators\n * @since 2.9.0\n */\nexport var intersperse = RNEA.intersperse;\n// -------------------------------------------------------------------------------------\n// non-pipeables\n// -------------------------------------------------------------------------------------\nvar map_ = RNEA.Functor.map;\nvar mapWithIndex_ = RNEA.FunctorWithIndex.mapWithIndex;\nvar ap_ = RNEA.Applicative.ap;\nvar chain_ = RNEA.Monad.chain;\nvar extend_ = RNEA.Comonad.extend;\nvar reduce_ = RNEA.Foldable.reduce;\nvar foldMap_ = RNEA.Foldable.foldMap;\nvar reduceRight_ = RNEA.Foldable.reduceRight;\nvar traverse_ = RNEA.Traversable.traverse;\nvar alt_ = RNEA.Alt.alt;\nvar reduceWithIndex_ = RNEA.FoldableWithIndex\n    .reduceWithIndex;\nvar foldMapWithIndex_ = RNEA.FoldableWithIndex\n    .foldMapWithIndex;\nvar reduceRightWithIndex_ = RNEA.FoldableWithIndex\n    .reduceRightWithIndex;\nvar traverseWithIndex_ = RNEA.TraversableWithIndex\n    .traverseWithIndex;\n// -------------------------------------------------------------------------------------\n// pipeables\n// -------------------------------------------------------------------------------------\n/**\n * @category FoldableWithIndex\n * @since 2.0.0\n */\nexport var foldMapWithIndex = RNEA.foldMapWithIndex;\n/**\n * @category Foldable\n * @since 2.0.0\n */\nexport var foldMap = RNEA.foldMap;\n/**\n * Less strict version of [`alt`](#alt).\n *\n * @category Alt\n * @since 2.9.0\n */\nexport var altW = RNEA.altW;\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 Alt\n * @since 2.6.2\n */\nexport var alt = RNEA.alt;\n/**\n * Apply a function to an argument under a type constructor.\n *\n * @category Apply\n * @since 2.0.0\n */\nexport var ap = RNEA.ap;\n/**\n * Combine two effectful actions, keeping only the result of the first.\n *\n * Derivable from `Apply`.\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var apFirst = RNEA.apFirst;\n/**\n * Combine two effectful actions, keeping only the result of the second.\n *\n * Derivable from `Apply`.\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var apSecond = RNEA.apSecond;\n/**\n * Composes computations in sequence, using the return value of one computation to determine the next computation.\n *\n * @category Monad\n * @since 2.0.0\n */\nexport var chain = RNEA.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 * Derivable from `Monad`.\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var chainFirst = RNEA.chainFirst;\n/**\n * Derivable from `Extend`.\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var duplicate = RNEA.duplicate;\n/**\n * @category Extend\n * @since 2.0.0\n */\nexport var extend = RNEA.extend;\n/**\n * Derivable from `Monad`.\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var flatten = RNEA.flatten;\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 Functor\n * @since 2.0.0\n */\nexport var map = RNEA.map;\n/**\n * @category FunctorWithIndex\n * @since 2.0.0\n */\nexport var mapWithIndex = RNEA.mapWithIndex;\n/**\n * @category Foldable\n * @since 2.0.0\n */\nexport var reduce = RNEA.reduce;\n/**\n * @category FoldableWithIndex\n * @since 2.0.0\n */\nexport var reduceWithIndex = RNEA.reduceWithIndex;\n/**\n * @category Foldable\n * @since 2.0.0\n */\nexport var reduceRight = RNEA.reduceRight;\n/**\n * @category FoldableWithIndex\n * @since 2.0.0\n */\nexport var reduceRightWithIndex = RNEA.reduceRightWithIndex;\n/**\n * @since 2.6.3\n */\nexport var traverse = RNEA.traverse;\n/**\n * @since 2.6.3\n */\nexport var sequence = RNEA.sequence;\n/**\n * @since 2.6.3\n */\nexport var traverseWithIndex = RNEA.traverseWithIndex;\n/**\n * @since 2.7.0\n */\nexport var extract = head;\n// -------------------------------------------------------------------------------------\n// instances\n// -------------------------------------------------------------------------------------\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var URI = 'NonEmptyArray';\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Functor = {\n    URI: URI,\n    map: map_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var FunctorWithIndex = {\n    URI: URI,\n    map: map_,\n    mapWithIndex: mapWithIndex_\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.7.0\n */\nexport var Monad = {\n    URI: URI,\n    map: map_,\n    ap: ap_,\n    of: of,\n    chain: chain_\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 * @category instances\n * @since 2.7.0\n */\nexport var FoldableWithIndex = {\n    URI: URI,\n    reduce: reduce_,\n    foldMap: foldMap_,\n    reduceRight: reduceRight_,\n    reduceWithIndex: reduceWithIndex_,\n    foldMapWithIndex: foldMapWithIndex_,\n    reduceRightWithIndex: reduceRightWithIndex_\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 * @category instances\n * @since 2.7.0\n */\nexport var TraversableWithIndex = {\n    URI: URI,\n    map: map_,\n    mapWithIndex: mapWithIndex_,\n    reduce: reduce_,\n    foldMap: foldMap_,\n    reduceRight: reduceRight_,\n    traverse: traverse_,\n    sequence: sequence,\n    reduceWithIndex: reduceWithIndex_,\n    foldMapWithIndex: foldMapWithIndex_,\n    reduceRightWithIndex: reduceRightWithIndex_,\n    traverseWithIndex: traverseWithIndex_\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 * @category instances\n * @since 2.7.0\n */\nexport var Comonad = {\n    URI: URI,\n    map: map_,\n    extend: extend_,\n    extract: extract\n};\n// TODO: remove in v3\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var nonEmptyArray = {\n    URI: URI,\n    of: of,\n    map: map_,\n    mapWithIndex: mapWithIndex_,\n    ap: ap_,\n    chain: chain_,\n    extend: extend_,\n    extract: extract,\n    reduce: reduce_,\n    foldMap: foldMap_,\n    reduceRight: reduceRight_,\n    traverse: traverse_,\n    sequence: sequence,\n    reduceWithIndex: reduceWithIndex_,\n    foldMapWithIndex: foldMapWithIndex_,\n    reduceRightWithIndex: reduceRightWithIndex_,\n    traverseWithIndex: traverseWithIndex_,\n    alt: alt_\n};\n// -------------------------------------------------------------------------------------\n// do notation\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.9.0\n */\nexport var Do = \n/*#__PURE__*/\nof({});\n/**\n * @since 2.8.0\n */\nexport var bindTo = RNEA.bindTo;\n/**\n * @since 2.8.0\n */\nexport var bind = RNEA.bind;\n// -------------------------------------------------------------------------------------\n// pipeable sequence S\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.8.0\n */\nexport var apS = RNEA.apS;\n","/**\n * `Filterable` represents data structures which can be _partitioned_/_filtered_.\n *\n * Adapted from https://github.com/LiamGoodacre/purescript-filterable/blob/master/src/Data/Filterable.purs\n *\n * @since 2.0.0\n */\nimport { getCompactableComposition } from './Compactable';\nimport { getLeft, getRight } from './Option';\nexport function getFilterableComposition(F, G) {\n    var CC = getCompactableComposition(F, G);\n    var FC = {\n        map: CC.map,\n        compact: CC.compact,\n        separate: CC.separate,\n        partitionMap: function (fga, f) {\n            var left = FC.filterMap(fga, function (a) { return getLeft(f(a)); });\n            var right = FC.filterMap(fga, function (a) { return getRight(f(a)); });\n            return { left: left, right: right };\n        },\n        partition: function (fga, p) {\n            var left = FC.filter(fga, function (a) { return !p(a); });\n            var right = FC.filter(fga, p);\n            return { left: left, right: right };\n        },\n        filterMap: function (fga, f) { return F.map(fga, function (ga) { return G.filterMap(ga, f); }); },\n        filter: function (fga, f) { return F.map(fga, function (ga) { return G.filter(ga, f); }); }\n    };\n    return FC;\n}\n","export function getFunctorComposition(F, G) {\n    return {\n        map: function (fa, f) { return F.map(fa, function (ga) { return G.map(ga, f); }); }\n    };\n}\n","import * as RM from './ReadonlyMap';\n/* tslint:disable:readonly-array */\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var getShow = RM.getShow;\n/**\n * Calculate the number of key/value pairs in a map\n *\n * @since 2.0.0\n */\nexport var size = RM.size;\n/**\n * Test whether or not a map is empty\n *\n * @since 2.0.0\n */\nexport var isEmpty = RM.isEmpty;\n// TODO: remove non-curried overloading in v3\n/**\n * Test whether or not a key exists in a map\n *\n * @since 2.0.0\n */\nexport var member = RM.member;\n// TODO: remove non-curried overloading in v3\n/**\n * Test whether or not a value is a member of a map\n *\n * @since 2.0.0\n */\nexport var elem = RM.elem;\n/**\n * Get a sorted array of the keys contained in a map\n *\n * @since 2.0.0\n */\nexport var keys = RM.keys;\n/**\n * Get a sorted array of the values contained in a map\n *\n * @since 2.0.0\n */\nexport var values = RM.values;\n/**\n * @since 2.0.0\n */\nexport var collect = RM.collect;\n/**\n * Get a sorted of the key/value pairs contained in a map\n *\n * @since 2.0.0\n */\nexport var toArray = RM.toReadonlyArray;\nexport function toUnfoldable(O, U) {\n    return RM.toUnfoldable(O, U);\n}\n/**\n * Insert or replace a key/value pair in a map\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var insertAt = RM.insertAt;\n/**\n * Delete a key and value from a map\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var deleteAt = RM.deleteAt;\n/**\n * @since 2.0.0\n */\nexport var updateAt = RM.updateAt;\n/**\n * @since 2.0.0\n */\nexport var modifyAt = RM.modifyAt;\n/**\n * Delete a key and value from a map, returning the value as well as the subsequent map\n *\n * @since 2.0.0\n */\nexport var pop = RM.pop;\n// TODO: remove non-curried overloading in v3\n/**\n * Lookup the value for a key in a `Map`.\n * If the result is a `Some`, the existing key is also returned.\n *\n * @since 2.0.0\n */\nexport var lookupWithKey = RM.lookupWithKey;\n// TODO: remove non-curried overloading in v3\n/**\n * Lookup the value for a key in a `Map`.\n *\n * @since 2.0.0\n */\nexport var lookup = RM.lookup;\n// TODO: remove non-curried overloading in v3\n/**\n * Test whether or not one `Map` contains all of the keys and values contained in another `Map`\n *\n * @since 2.0.0\n */\nexport var isSubmap = RM.isSubmap;\n/**\n * @since 2.0.0\n */\nexport var empty = new Map();\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var getEq = RM.getEq;\n/**\n * Gets `Monoid` instance for Maps given `Semigroup` instance for their values\n *\n * @category instances\n * @since 2.0.0\n */\nexport var getMonoid = RM.getMonoid;\n/**\n * Create a map with one key/value pair\n *\n * @since 2.0.0\n */\nexport var singleton = RM.singleton;\nexport function fromFoldable(E, M, F) {\n    return RM.fromFoldable(E, M, F);\n}\n// -------------------------------------------------------------------------------------\n// non-pipeables\n// -------------------------------------------------------------------------------------\nvar map__ = RM.Functor.map;\nvar filter_ = RM.Filterable.filter;\nvar filterMap_ = RM.Filterable.filterMap;\nvar partition_ = RM.Filterable.partition;\nvar partitionMap_ = RM.Filterable.partitionMap;\n// -------------------------------------------------------------------------------------\n// pipeables\n// -------------------------------------------------------------------------------------\n/**\n * @category Compactable\n * @since 2.0.0\n */\nexport var compact = RM.compact;\n/**\n * @category Filterable\n * @since 2.0.0\n */\nexport var filter = RM.filter;\n/**\n * @category Filterable\n * @since 2.0.0\n */\nexport var filterMap = RM.filterMap;\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 Functor\n * @since 2.0.0\n */\nexport var map = RM.map;\n/**\n * @category FunctorWithIndex\n * @since 2.7.1\n */\nexport var mapWithIndex = RM.mapWithIndex;\n/**\n * @category Filterable\n * @since 2.0.0\n */\nexport var partition = RM.partition;\n/**\n * @category Filterable\n * @since 2.0.0\n */\nexport var partitionMap = RM.partitionMap;\n/**\n * @category Compactable\n * @since 2.0.0\n */\nexport var separate = RM.separate;\n// -------------------------------------------------------------------------------------\n// instances\n// -------------------------------------------------------------------------------------\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var URI = 'Map';\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var getFilterableWithIndex = RM.getFilterableWithIndex;\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var getWitherable = RM.getWitherable;\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Functor = {\n    URI: URI,\n    map: map__\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Compactable = {\n    URI: URI,\n    compact: compact,\n    separate: separate\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Filterable = {\n    URI: URI,\n    map: map__,\n    compact: compact,\n    separate: separate,\n    filter: filter_,\n    filterMap: filterMap_,\n    partition: partition_,\n    partitionMap: partitionMap_\n};\n// TODO: remove in v3\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var map_ = Filterable;\n","import { identity } from './function';\nimport * as S from './Semigroup';\n/**\n * `boolean` monoid under conjunction.\n *\n * The `empty` value is `true`.\n *\n * @example\n * import * as M from 'fp-ts/Monoid'\n *\n * assert.deepStrictEqual(M.monoidAll.concat(true, true), true)\n * assert.deepStrictEqual(M.monoidAll.concat(true, false), false)\n *\n * @category instances\n * @since 2.0.0\n */\nexport var monoidAll = {\n    concat: S.semigroupAll.concat,\n    empty: true\n};\n/**\n * `boolean` monoid under disjunction.\n *\n * The `empty` value is `false`.\n *\n * @example\n * import * as M from 'fp-ts/Monoid'\n *\n * assert.deepStrictEqual(M.monoidAny.concat(true, true), true)\n * assert.deepStrictEqual(M.monoidAny.concat(true, false), true)\n * assert.deepStrictEqual(M.monoidAny.concat(false, false), false)\n *\n * @category instances\n * @since 2.0.0\n */\nexport var monoidAny = {\n    concat: S.semigroupAny.concat,\n    empty: false\n};\n/**\n * `number` monoid under addition.\n *\n * The `empty` value is `0`.\n *\n * @example\n * import * as M from 'fp-ts/Monoid'\n *\n * assert.deepStrictEqual(M.monoidSum.concat(2, 3), 5)\n *\n * @category instances\n * @since 2.0.0\n */\nexport var monoidSum = {\n    concat: S.semigroupSum.concat,\n    empty: 0\n};\n/**\n * `number` monoid under multiplication.\n *\n * The `empty` value is `1`.\n *\n * @example\n * import * as M from 'fp-ts/Monoid'\n *\n * assert.deepStrictEqual(M.monoidProduct.concat(2, 3), 6)\n *\n * @category instances\n * @since 2.0.0\n */\nexport var monoidProduct = {\n    concat: S.semigroupProduct.concat,\n    empty: 1\n};\n/**\n * `string` monoid under concatenation.\n *\n * The `empty` value is `''`.\n *\n * @example\n * import * as M from 'fp-ts/Monoid'\n *\n * assert.deepStrictEqual(M.monoidString.concat('a', 'b'), 'ab')\n *\n * @category instances\n * @since 2.0.0\n */\nexport var monoidString = {\n    concat: S.semigroupString.concat,\n    empty: ''\n};\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var monoidVoid = {\n    concat: S.semigroupVoid.concat,\n    empty: undefined\n};\n/**\n * Given a sequence of `as`, concat them and return the total.\n *\n * If `as` is empty, return the monoid `empty` value.\n *\n * @example\n * import * as M from 'fp-ts/Monoid'\n *\n * assert.deepStrictEqual(M.fold(M.monoidSum)([1, 2, 3]), 6)\n * assert.deepStrictEqual(M.fold(M.monoidSum)([]), 0)\n *\n * @since 2.0.0\n */\nexport function fold(M) {\n    return S.fold(M)(M.empty);\n}\n/**\n * Given a tuple of monoids returns a monoid for the tuple\n *\n * @example\n * import { getTupleMonoid, monoidString, monoidSum, monoidAll } from 'fp-ts/Monoid'\n *\n * const M1 = getTupleMonoid(monoidString, monoidSum)\n * assert.deepStrictEqual(M1.concat(['a', 1], ['b', 2]), ['ab', 3])\n *\n * const M2 = getTupleMonoid(monoidString, monoidSum, monoidAll)\n * assert.deepStrictEqual(M2.concat(['a', 1, true], ['b', 2, false]), ['ab', 3, false])\n *\n * @category instances\n * @since 2.0.0\n */\nexport function getTupleMonoid() {\n    var monoids = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        monoids[_i] = arguments[_i];\n    }\n    return {\n        concat: S.getTupleSemigroup.apply(S, monoids).concat,\n        empty: monoids.map(function (m) { return m.empty; })\n    };\n}\n/**\n * The dual of a `Monoid`, obtained by swapping the arguments of `concat`.\n *\n * @example\n * import { getDualMonoid, monoidString } from 'fp-ts/Monoid'\n *\n * assert.deepStrictEqual(getDualMonoid(monoidString).concat('a', 'b'), 'ba')\n *\n * @category combinators\n * @since 2.0.0\n */\nexport function getDualMonoid(M) {\n    return {\n        concat: S.getDualSemigroup(M).concat,\n        empty: M.empty\n    };\n}\n/**\n * Unary functions form a monoid as long as you can provide a monoid for the codomain.\n *\n * @example\n * import { Predicate } from 'fp-ts/function'\n * import * as M from 'fp-ts/Monoid'\n *\n * const f: Predicate<number> = (n) => n <= 2\n * const g: Predicate<number> = (n) => n >= 0\n *\n * const M1 = M.getFunctionMonoid(M.monoidAll)<number>()\n *\n * assert.deepStrictEqual(M1.concat(f, g)(1), true)\n * assert.deepStrictEqual(M1.concat(f, g)(3), false)\n *\n * const M2 = M.getFunctionMonoid(M.monoidAny)<number>()\n *\n * assert.deepStrictEqual(M2.concat(f, g)(1), true)\n * assert.deepStrictEqual(M2.concat(f, g)(3), true)\n *\n * @category instances\n * @since 2.0.0\n */\nexport function getFunctionMonoid(M) {\n    return function () { return ({\n        concat: S.getFunctionSemigroup(M)().concat,\n        empty: function () { return M.empty; }\n    }); };\n}\n// TODO: swap execution order in v3\n/**\n * Endomorphism form a monoid where the `empty` value is the identity function.\n *\n * @category instances\n * @since 2.0.0\n */\nexport function getEndomorphismMonoid() {\n    return {\n        concat: function (x, y) { return function (a) { return x(y(a)); }; },\n        empty: identity\n    };\n}\n/**\n * Given a struct of monoids returns a monoid for the struct.\n *\n * @example\n * import * as M from 'fp-ts/Monoid'\n *\n * interface Point {\n *   readonly x: number\n *   readonly y: number\n * }\n *\n * const monoidPoint = M.getStructMonoid<Point>({\n *   x: M.monoidSum,\n *   y: M.monoidSum\n * })\n *\n * assert.deepStrictEqual(monoidPoint.concat({ x: 1, y: 2 }, { x: 3, y: 4 }), { x: 4, y: 6 })\n *\n * @category instances\n * @since 2.0.0\n */\nexport function getStructMonoid(monoids) {\n    var empty = {};\n    for (var _i = 0, _a = Object.keys(monoids); _i < _a.length; _i++) {\n        var key = _a[_i];\n        empty[key] = monoids[key].empty;\n    }\n    return {\n        concat: S.getStructSemigroup(monoids).concat,\n        empty: empty\n    };\n}\n/**\n * Get a monoid where `concat` will return the minimum, based on the provided bounded order.\n *\n * The `empty` value is the `top` value.\n *\n * @example\n * import * as B from 'fp-ts/Bounded'\n * import * as M from 'fp-ts/Monoid'\n *\n * const M1 = M.getMeetMonoid(B.boundedNumber)\n *\n * assert.deepStrictEqual(M1.concat(1, 2), 1)\n *\n * @category instances\n * @since 2.0.0\n */\nexport function getMeetMonoid(B) {\n    return {\n        concat: S.getMeetSemigroup(B).concat,\n        empty: B.top\n    };\n}\n/**\n * Get a monoid where `concat` will return the maximum, based on the provided bounded order.\n *\n * The `empty` value is the `bottom` value.\n *\n * @example\n * import * as B from 'fp-ts/Bounded'\n * import * as M from 'fp-ts/Monoid'\n *\n * const M1 = M.getJoinMonoid(B.boundedNumber)\n *\n * assert.deepStrictEqual(M1.concat(1, 2), 2)\n *\n * @category instances\n * @since 2.0.0\n */\nexport function getJoinMonoid(B) {\n    return {\n        concat: S.getJoinSemigroup(B).concat,\n        empty: B.bottom\n    };\n}\n","/**\n * @since 2.0.0\n */\nimport { map } from './IO';\nimport { pipe } from './function';\n/**\n * Returns a random number between 0 (inclusive) and 1 (exclusive). This is a direct wrapper around JavaScript's\n * `Math.random()`.\n *\n * @since 2.0.0\n */\nexport var random = function () { return Math.random(); };\n/**\n * Takes a range specified by `low` (the first argument) and `high` (the second), and returns a random integer uniformly\n * distributed in the closed interval `[low, high]`. It is unspecified what happens if `low > high`, or if either of\n * `low` or `high` is not an integer.\n *\n * @since 2.0.0\n */\nexport function randomInt(low, high) {\n    return pipe(random, map(function (n) { return Math.floor((high - low + 1) * n + low); }));\n}\n/**\n * Returns a random number between a minimum value (inclusive) and a maximum value (exclusive). It is unspecified what\n * happens if `maximum < minimum`.\n *\n * @since 2.0.0\n */\nexport function randomRange(min, max) {\n    return pipe(random, map(function (n) { return (max - min) * n + min; }));\n}\n/**\n * Returns a random boolean value with an equal chance of being `true` or `false`\n *\n * @since 2.0.0\n */\nexport var randomBool = \n/*#__PURE__*/\npipe(random, map(function (n) { return n < 0.5; }));\n","var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nvar __generator = (this && this.__generator) || function (thisArg, body) {\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n    function verb(n) { return function (v) { return step([n, v]); }; }\n    function step(op) {\n        if (f) throw new TypeError(\"Generator is already executing.\");\n        while (_) try {\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n            if (y = 0, t) op = [op[0] & 2, t.value];\n            switch (op[0]) {\n                case 0: case 1: t = op; break;\n                case 4: _.label++; return { value: op[1], done: false };\n                case 5: _.label++; y = op[1]; op = [0]; continue;\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\n                default:\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                    if (t[2]) _.ops.pop();\n                    _.trys.pop(); continue;\n            }\n            op = body.call(thisArg, _);\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n    }\n};\nimport * as E from './Either';\nimport { bindTo_, bind_, flow, identity, pipe } from './function';\nimport * as R from './Reader';\nimport * as T from './Task';\nimport * as TE from './TaskEither';\n// -------------------------------------------------------------------------------------\n// constructors\n// -------------------------------------------------------------------------------------\n/**\n * @category constructors\n * @since 2.0.0\n */\nexport var fromTaskEither = \n/*#__PURE__*/\nR.of;\n/**\n * @category constructors\n * @since 2.0.0\n */\nexport var left = \n/*#__PURE__*/\nflow(TE.left, fromTaskEither);\n/**\n * @category constructors\n * @since 2.0.0\n */\nexport var right = \n/*#__PURE__*/\nflow(TE.right, fromTaskEither);\n/**\n * @category constructors\n * @since 2.0.0\n */\nexport var rightTask = \n/*#__PURE__*/\nflow(TE.rightTask, fromTaskEither);\n/**\n * @category constructors\n * @since 2.0.0\n */\nexport var leftTask = \n/*#__PURE__*/\nflow(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 = function (ma) {\n    return flow(ma, TE.rightTask);\n};\n/**\n * @category constructors\n * @since 2.5.0\n */\nexport var leftReaderTask = function (me) {\n    return flow(me, TE.leftTask);\n};\n/**\n * @category constructors\n * @since 2.0.0\n */\nexport var fromIOEither = \n/*#__PURE__*/\nflow(TE.fromIOEither, fromTaskEither);\n/**\n * @category constructors\n * @since 2.0.0\n */\nexport var fromReaderEither = function (ma) {\n    return flow(ma, TE.fromEither);\n};\n/**\n * @category constructors\n * @since 2.0.0\n */\nexport var rightIO = \n/*#__PURE__*/\nflow(TE.rightIO, fromTaskEither);\n/**\n * @category constructors\n * @since 2.0.0\n */\nexport var leftIO = \n/*#__PURE__*/\nflow(TE.leftIO, fromTaskEither);\n/**\n * @category constructors\n * @since 2.0.0\n */\nexport var ask = function () { return TE.right; };\n/**\n * @category constructors\n * @since 2.0.0\n */\nexport var asks = function (f) {\n    return flow(TE.right, TE.map(f));\n};\n/**\n * Derivable from `MonadThrow`.\n *\n * @category constructors\n * @since 2.0.0\n */\nexport var fromEither = \n/*#__PURE__*/\nE.fold(left, function (a) { return right(a); });\n/**\n * Derivable from `MonadThrow`.\n *\n * @category constructors\n * @since 2.0.0\n */\nexport var fromOption = function (onNone) { return function (ma) { return (ma._tag === 'None' ? left(onNone()) : right(ma.value)); }; };\n/**\n * Derivable from `MonadThrow`.\n *\n * @category constructors\n * @since 2.0.0\n */\nexport var fromPredicate = function (predicate, onFalse) { return function (a) { return (predicate(a) ? right(a) : left(onFalse(a))); }; };\n// -------------------------------------------------------------------------------------\n// destructors\n// -------------------------------------------------------------------------------------\n/**\n * @category destructors\n * @since 2.0.0\n */\nexport function fold(onLeft, onRight) {\n    return function (ma) { return function (r) {\n        return pipe(ma(r), TE.fold(function (e) { return onLeft(e)(r); }, function (a) { return onRight(a)(r); }));\n    }; };\n}\n/**\n * Less strict version of [`getOrElse`](#getOrElse).\n *\n * @category destructors\n * @since 2.6.0\n */\nexport var getOrElseW = function (onLeft) { return function (ma) { return function (r) {\n    return TE.getOrElseW(function (e) { return onLeft(e)(r); })(ma(r));\n}; }; };\n/**\n * @category destructors\n * @since 2.0.0\n */\nexport var getOrElse = getOrElseW;\n// -------------------------------------------------------------------------------------\n// combinators\n// -------------------------------------------------------------------------------------\n/**\n * @category combinators\n * @since 2.0.0\n */\nexport function orElse(onLeft) {\n    return function (ma) { return function (r) { return TE.orElse(function (e) { return onLeft(e)(r); })(ma(r)); }; };\n}\n/**\n * @category combinators\n * @since 2.0.0\n */\nexport var swap = function (ma) { return flow(ma, TE.swap); };\n// TODO: remove in v3\n/**\n * @category combinators\n * @since 2.0.0\n */\nexport var local = R.local;\n/**\n * Less strict version of [`filterOrElse`](#filterOrElse).\n *\n * @since 2.9.0\n */\nexport var filterOrElseW = function (predicate, onFalse) {\n    return chainW(function (a) { return (predicate(a) ? right(a) : left(onFalse(a))); });\n};\n/**\n * Derivable from `MonadThrow`.\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var filterOrElse = filterOrElseW;\n/**\n * @category combinators\n * @since 2.4.0\n */\nexport function fromEitherK(f) {\n    return function () {\n        var a = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            a[_i] = arguments[_i];\n        }\n        return fromEither(f.apply(void 0, a));\n    };\n}\n/**\n * Less strict version of [`chainEitherK`](#chainEitherK).\n *\n * @category combinators\n * @since 2.6.1\n */\nexport var chainEitherKW = function (f) { return chainW(fromEitherK(f)); };\n/**\n * @category combinators\n * @since 2.4.0\n */\nexport var chainEitherK = chainEitherKW;\n/**\n * @category combinators\n * @since 2.4.0\n */\nexport function fromIOEitherK(f) {\n    return function () {\n        var a = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            a[_i] = arguments[_i];\n        }\n        return fromIOEither(f.apply(void 0, a));\n    };\n}\n/**\n * Less strict version of [`chainIOEitherK`](#chainIOEitherK).\n *\n * @category combinators\n * @since 2.6.1\n */\nexport var chainIOEitherKW = function (f) { return chainW(fromIOEitherK(f)); };\n/**\n * @category combinators\n * @since 2.4.0\n */\nexport var chainIOEitherK = chainIOEitherKW;\n/**\n * @category combinators\n * @since 2.4.0\n */\nexport function fromTaskEitherK(f) {\n    return function () {\n        var a = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            a[_i] = arguments[_i];\n        }\n        return fromTaskEither(f.apply(void 0, a));\n    };\n}\n/**\n * Less strict version of [`chainTaskEitherK`](#chainTaskEitherK).\n *\n * @category combinators\n * @since 2.6.1\n */\nexport var chainTaskEitherKW = function (f) { return chainW(fromTaskEitherK(f)); };\n/**\n * @category combinators\n * @since 2.4.0\n */\nexport var chainTaskEitherK = chainTaskEitherKW;\n// -------------------------------------------------------------------------------------\n// non-pipeables\n// -------------------------------------------------------------------------------------\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) {\n    return pipe(fab, chain(function (f) { return pipe(fa, map(f)); }));\n};\n/* istanbul ignore next */\nvar chain_ = function (ma, f) { return pipe(ma, chain(f)); };\n/* istanbul ignore next */\nvar alt_ = function (fa, that) { return pipe(fa, alt(that)); };\n/* istanbul ignore next */\nvar bimap_ = function (fa, f, g) { return pipe(fa, bimap(f, g)); };\n/* istanbul ignore next */\nvar mapLeft_ = function (fa, f) { return pipe(fa, mapLeft(f)); };\n// -------------------------------------------------------------------------------------\n// pipeables\n// -------------------------------------------------------------------------------------\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 Functor\n * @since 2.0.0\n */\nexport var map = function (f) { return function (fa) { return flow(fa, TE.map(f)); }; };\n/**\n * Map a pair of functions over the two last type arguments of the bifunctor.\n *\n * @category Bifunctor\n * @since 2.0.0\n */\nexport var bimap = function (f, g) { return function (fa) { return function (r) {\n    return pipe(fa(r), TE.bimap(f, g));\n}; }; };\n/**\n * Map a function over the second type argument of a bifunctor.\n *\n * @category Bifunctor\n * @since 2.0.0\n */\nexport var mapLeft = function (f) { return function (fa) { return function (r) { return pipe(fa(r), TE.mapLeft(f)); }; }; };\n/**\n * Less strict version of [`ap`](#ap).\n *\n * @category Apply\n * @since 2.8.0\n */\nexport var apW = function (fa) { return function (fab) { return function (r) { return pipe(fab(r), TE.apW(fa(r))); }; }; };\n/**\n * Apply a function to an argument under a type constructor.\n *\n * @category Apply\n * @since 2.0.0\n */\nexport var ap = apW;\n/**\n * Combine two effectful actions, keeping only the result of the first.\n *\n * Derivable from `Apply`.\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var apFirst = function (fb) {\n    return flow(map(function (a) { return function () { return a; }; }), ap(fb));\n};\n/**\n * Combine two effectful actions, keeping only the result of the second.\n *\n * Derivable from `Apply`.\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var apSecond = function (fb) {\n    return flow(map(function () { return function (b) { return b; }; }), ap(fb));\n};\n/**\n * Wrap a value into the type constructor.\n *\n * Equivalent to [`right`](#right).\n *\n * @category Applicative\n * @since 2.7.0\n */\nexport var of = right;\n/**\n * Less strict version of [`chain`](#chain).\n *\n * @category Monad\n * @since 2.6.0\n */\nexport var chainW = function (f) { return function (fa) { return function (r) {\n    return pipe(fa(r), TE.chainW(function (a) { return f(a)(r); }));\n}; }; };\n/**\n * Composes computations in sequence, using the return value of one computation to determine the next computation.\n *\n * @category Monad\n * @since 2.0.0\n */\nexport var chain = chainW;\n/**\n * Less strict version of [`chainFirst`](#chainFirst).\n *\n * Derivable from `Monad`.\n *\n * @category combinators\n * @since 2.8.0\n */\nexport var chainFirstW = function (f) {\n    return chainW(function (a) {\n        return pipe(f(a), map(function () { return a; }));\n    });\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 * Derivable from `Monad`.\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var chainFirst = chainFirstW;\n/**\n * Derivable from `Monad`.\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var flatten = \n/*#__PURE__*/\nchain(identity);\n/**\n * Less strict version of [`alt`](#alt).\n *\n * @category Alt\n * @since 2.9.0\n */\nexport var altW = function (that) { return function (fa) { return function (r) {\n    return pipe(fa(r), TE.altW(function () { return that()(r); }));\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 * @category Alt\n * @since 2.0.0\n */\nexport var alt = altW;\n/**\n * @category MonadIO\n * @since 2.0.0\n */\nexport var fromIO = rightIO;\n/**\n * @category MonadTask\n * @since 2.0.0\n */\nexport var fromTask = rightTask;\n/**\n * @category MonadThrow\n * @since 2.0.0\n */\nexport var throwError = left;\n// -------------------------------------------------------------------------------------\n// instances\n// -------------------------------------------------------------------------------------\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var URI = 'ReaderTaskEither';\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 * @category instances\n * @since 2.0.0\n */\nexport function getSemigroup(S) {\n    return R.getSemigroup(TE.getSemigroup(S));\n}\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 instances\n * @since 2.0.0\n */\nexport function getApplySemigroup(S) {\n    return R.getSemigroup(TE.getApplySemigroup(S));\n}\n/**\n * @category instances\n * @since 2.0.0\n */\nexport function getApplyMonoid(M) {\n    return {\n        concat: getApplySemigroup(M).concat,\n        empty: right(M.empty)\n    };\n}\n/**\n * @category instances\n * @since 2.7.0\n */\nexport function getApplicativeReaderTaskValidation(A, SE) {\n    var AV = TE.getApplicativeTaskValidation(A, SE);\n    var ap = function (fga) {\n        return flow(R.map(function (gab) { return function (ga) { return AV.ap(gab, ga); }; }), R.ap(fga));\n    };\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 * @category instances\n * @since 2.7.0\n */\nexport function getAltReaderTaskValidation(SE) {\n    var A = TE.getAltTaskValidation(SE);\n    return {\n        URI: URI,\n        _E: undefined,\n        map: map_,\n        alt: function (me, that) { return function (r) { return A.alt(me(r), function () { return that()(r); }); }; }\n    };\n}\n// TODO: remove in v3\n/**\n * @category instances\n * @since 2.3.0\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: chain_,\n        bimap: bimap_,\n        mapLeft: mapLeft_,\n        ap: applicativeReaderTaskValidation.ap,\n        alt: altReaderTaskValidation.alt,\n        fromIO: fromIO,\n        fromTask: fromTask,\n        throwError: throwError\n    };\n}\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Functor = {\n    URI: URI,\n    map: map_\n};\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 * @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.7.0\n */\nexport var Bifunctor = {\n    URI: URI,\n    bimap: bimap_,\n    mapLeft: mapLeft_\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// TODO: remove in v3\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var readerTaskEither = {\n    URI: URI,\n    map: map_,\n    of: of,\n    ap: apPar_,\n    chain: chain_,\n    alt: alt_,\n    bimap: bimap_,\n    mapLeft: mapLeft_,\n    fromIO: fromIO,\n    fromTask: fromTask,\n    throwError: throwError\n};\n// TODO: remove in v3\n/**\n * Like `readerTaskEither` but `ap` is sequential\n *\n * @category instances\n * @since 2.0.0\n */\nexport var readerTaskEitherSeq = {\n    URI: URI,\n    map: map_,\n    of: of,\n    ap: apSeq_,\n    chain: chain_,\n    alt: alt_,\n    bimap: bimap_,\n    mapLeft: mapLeft_,\n    fromIO: fromIO,\n    fromTask: fromTask,\n    throwError: throwError\n};\n// -------------------------------------------------------------------------------------\n// utils\n// -------------------------------------------------------------------------------------\n// TODO: remove in v3\n/**\n * @since 2.0.0\n */\n/* istanbul ignore next */\nexport function run(ma, r) {\n    return ma(r)();\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 * Derivable from `MonadThrow`.\n *\n * @since 2.0.4\n */\nexport function bracket(aquire, use, release) {\n    return function (r) {\n        return TE.bracket(aquire(r), function (a) { return use(a)(r); }, function (a, e) { return release(a, e)(r); });\n    };\n}\n// -------------------------------------------------------------------------------------\n// do notation\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.9.0\n */\nexport var Do = \n/*#__PURE__*/\nof({});\n/**\n * @since 2.8.0\n */\nexport var bindTo = function (name) { return map(bindTo_(name)); };\n/**\n * @since 2.8.0\n */\nexport var bindW = function (name, f) {\n    return chainW(function (a) {\n        return pipe(f(a), map(function (b) { return bind_(a, name, b); }));\n    });\n};\n/**\n * @since 2.8.0\n */\nexport var bind = bindW;\n// -------------------------------------------------------------------------------------\n// pipeable sequence S\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.8.0\n */\nexport var apSW = function (name, fb) {\n    return flow(map(function (a) { return function (b) { return bind_(a, name, b); }; }), apW(fb));\n};\n/**\n * @since 2.8.0\n */\nexport var apS = apSW;\n// -------------------------------------------------------------------------------------\n// array utils\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.9.0\n */\nexport var traverseArrayWithIndex = function (f) { return function (arr) { return function (r) { return function () {\n    return Promise.all(arr.map(function (x, i) { return f(i, x)(r)(); })).then(E.sequenceArray);\n}; }; }; };\n/**\n * @since 2.9.0\n */\nexport var traverseArray = function (f) { return traverseArrayWithIndex(function (_, a) { return f(a); }); };\n/**\n * @since 2.9.0\n */\nexport var sequenceArray = \n/*#__PURE__*/\ntraverseArray(identity);\n/**\n * @since 2.9.0\n */\nexport var traverseSeqArrayWithIndex = function (f) { return function (arr) { return function (r) { return function () { return __awaiter(void 0, void 0, void 0, function () {\n    var result, i, b;\n    return __generator(this, function (_a) {\n        switch (_a.label) {\n            case 0:\n                result = [];\n                i = 0;\n                _a.label = 1;\n            case 1:\n                if (!(i < arr.length)) return [3 /*break*/, 4];\n                return [4 /*yield*/, f(i, arr[i])(r)()];\n            case 2:\n                b = _a.sent();\n                if (E.isLeft(b)) {\n                    return [2 /*return*/, b];\n                }\n                result.push(b.right);\n                _a.label = 3;\n            case 3:\n                i++;\n                return [3 /*break*/, 1];\n            case 4: return [2 /*return*/, E.right(result)];\n        }\n    });\n}); }; }; }; };\n/**\n * @since 2.9.0\n */\nexport var traverseSeqArray = function (f) {\n    return traverseSeqArrayWithIndex(function (_, a) { return f(a); });\n};\n/**\n * @since 2.9.0\n */\nexport var sequenceSeqArray = \n/*#__PURE__*/\ntraverseSeqArray(identity);\n"],"sourceRoot":""}