{"version":3,"sources":["../../node_modules/fp-ts-contrib/lib/Zipper.js","../../node_modules/fp-ts/es6/ChainRec.js","../../node_modules/fp-ts/es6/Compactable.js","../../node_modules/fp-ts/es6/Either.js","../../node_modules/fp-ts/es6/Date.js","../../node_modules/fast-deep-equal/react.js","../../node_modules/fp-ts-contrib/es6/Zipper.js","../../node_modules/fp-ts/es6/Eq.js","../../node_modules/fp-ts-routing/es6/index.js","../../node_modules/fp-ts/es6/Apply.js","../../node_modules/fp-ts/es6/Array.js"],"names":["__assign","this","Object","assign","t","s","i","n","arguments","length","p","prototype","hasOwnProperty","call","apply","__importStar","mod","__esModule","result","k","defineProperty","exports","value","A","require","function_1","Option_1","pipeable_1","make","lefts","focus","rights","fromArray","as","focusIndex","isEmpty","isOutOfBound","none","some","pipe","takeLeft","dropLeft","fromNonEmptyArray","nea","empty","slice","index","fa","toArray","snoc","concat","update","a","modify","f","move","newIndex","up","decrement","down","increment","start","end","len","insertLeft","cons","insertRight","deleteLeft","deleteRight","lenl","lenr","map_","map","mapWithIndex_","l","ap_","fab","array","ap","extend_","reduce_","b","reduce","reduceRight_","reduceRight","acc","foldMap_","M","traverse_","F","traverseF","traverse","ta","mapWithIndex","apFirst","fb","_","apSecond","of","extend","wa","duplicate","identity","foldMap","sequence","sequenceF","extract","URI","getShow","S","SA","show","getSemigroup","x","y","getMonoid","Functor","FunctorWithIndex","Applicative","Apply","Foldable","Traversable","Comonad","zipper","tailRec","v","_tag","left","right","getCompactableComposition","G","FC","getFunctorComposition","CC","compact","fga","separate","fge","getLeft","getRight","isLeft","ma","isRight","e","fromNullable","tryCatch","onError","parseJSON","JSON","parse","stringifyJSON","u","stringify","fromOption","onNone","fromPredicate","predicate","onFalse","fold","onLeft","onRight","getOrElseW","getOrElse","fromNullableK","from","_i","chainNullableK","chain","swap","orElse","filterOrElseW","chainW","filterOrElse","chain_","foldMapM","bimap_","g","bimap","mapLeft_","mapLeft","alt_","that","alt","chainRec_","apW","flow","chainFirstW","chainFirst","flatten","altW","throwError","SE","getEq","EL","EA","equals","getApplySemigroup","getApplyMonoid","getFilterable","_E","undefined","filter","filterMap","ob","partition","partitionMap","getWitherable","F_","wither","wilt","getApplicativeValidation","getAltValidation","me","ea","getValidation","applicativeValidation","altValidation","chainRec","getValidationSemigroup","Monad","Bifunctor","Alt","Extend","ChainRec","MonadThrow","getValidationMonoid","either","toError","Error","String","elem","E","exists","Do","bindTo","name","bindTo_","bindW","bind_","bind","apSW","apS","traverseArrayWithIndex","arr","push","traverseArray","sequenceArray","create","Date","now","getTime","eqDate","getDate","eqMonth","getMonth","eqYear","getFullYear","module","equal","constructor","keys","Array","isArray","RegExp","source","flags","valueOf","toString","key","$$typeof","fromEquals","contramap","eqStrict","strictEqual","eqString","eqNumber","eqBoolean","getStructEq","eqs","getTupleEq","every","Contravariant","eq","Route","parts","query","r","decode","route","parseUrl","oparts","option","pathname","split","Boolean","decodeURIComponent","isNone","encode","nonUndefinedQuery","qs","encodeURIComponent","join","Parser","run","tuple","_this","_a","r2","oar","then","zero","parser","oa","mab","fx","pipeable","Formatter","ab","format","formatter","Match","imap","type","head","tail_1","fromEither","singleton","o","Type","Int","is","c","string","validate","isNaN","Number","isInteger","failure","success","lit","literal","tail","curried","combined","tupleConstructors","1","2","3","4","d","5","getTupleConstructor","sequenceT","args","fas","sequenceS","getRecordConstructor","fr","RA","getOrd","makeBy","range","replicate","foldLeft","foldRight","scanLeft","scanRight","isNonEmpty","lookup","last","init","takeRight","takeLeftWhile","spanLeft","dropRight","dropLeftWhile","findIndex","findFirst","findFirstMap","findLast","findLastMap","findLastIndex","copy","insertAt","updateAt","deleteAt","modifyAt","reverse","sort","zipWith","zip","unzip","prependToAll","intersperse","rotate","uniq","sortBy","chop","splitAt","chunksOf","comprehension","input","union","intersection","difference","filter_","filterMap_","partition_","partitionMap_","filterWithIndex_","filterWithIndex","filterMapWithIndex_","filterMapWithIndex","partitionWithIndex_","partitionWithIndex","partitionMapWithIndex_","partitionMapWithIndex","reduceWithIndex_","reduceWithIndex","foldMapWithIndex_","foldMapWithIndex","reduceRightWithIndex_","reduceRightWithIndex","traverseWithIndex_","traverseWithIndex","wither_","wilt_","chainWithIndex","unfold","Unfoldable","Alternative","Compactable","Filterable","FilterableWithIndex","FoldableWithIndex","TraversableWithIndex","Witherable","unsafeInsertAt","unsafeUpdateAt","unsafeDeleteAt"],"mappings":"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","file":"static/js/index~b6b608b6.49a276de.chunk.js","sourcesContent":["\"use strict\";\nvar __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nvar __importStar = (this && this.__importStar) || function (mod) {\n    if (mod && mod.__esModule) return mod;\n    var result = {};\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\n    result[\"default\"] = mod;\n    return result;\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar A = __importStar(require(\"fp-ts/lib/Array\"));\nvar function_1 = require(\"fp-ts/lib/function\");\nvar Option_1 = require(\"fp-ts/lib/Option\");\nvar pipeable_1 = require(\"fp-ts/lib/pipeable\");\n// -------------------------------------------------------------------------------------\n// constructors\n// -------------------------------------------------------------------------------------\n/**\n * Creates a new zipper.\n *\n * @category constructors\n * @since 0.1.6\n */\nexports.make = function (lefts, focus, rights) { return ({\n    lefts: lefts,\n    focus: focus,\n    rights: rights\n}); };\n/**\n * @category constructors\n * @since 0.1.6\n */\nexports.fromArray = function (as, focusIndex) {\n    if (focusIndex === void 0) { focusIndex = 0; }\n    if (A.isEmpty(as) || A.isOutOfBound(focusIndex, as)) {\n        return Option_1.none;\n    }\n    else {\n        return Option_1.some(exports.make(pipeable_1.pipe(as, A.takeLeft(focusIndex)), as[focusIndex], pipeable_1.pipe(as, A.dropLeft(focusIndex + 1))));\n    }\n};\n/**\n * @category constructors\n * @since 0.1.6\n */\nexports.fromNonEmptyArray = function (nea) { return exports.make(A.empty, nea[0], nea.slice(1)); };\n// -------------------------------------------------------------------------------------\n// destructors\n// -------------------------------------------------------------------------------------\n/**\n * @category destructors\n * @since 0.1.18\n */\nexports.isOutOfBound = function (index, fa) {\n    return index < 0 || index >= exports.length(fa);\n};\n/**\n * @category destructors\n * @since 0.1.6\n */\nexports.length = function (fa) { return fa.lefts.length + 1 + fa.rights.length; };\n/**\n * @category destructors\n * @since 0.1.6\n */\nexports.toArray = function (fa) { return A.snoc(fa.lefts, fa.focus).concat(fa.rights); };\n// -------------------------------------------------------------------------------------\n// combinators\n// -------------------------------------------------------------------------------------\n/**\n * Updates the focus of the zipper.\n *\n * @category combinators\n * @since 0.1.6\n */\nexports.update = function (a) { return function (fa) { return exports.make(fa.lefts, a, fa.rights); }; };\n/**\n * Applies `f` to the focus and update with the result.\n *\n * @category combinators\n * @since 0.1.6\n */\nexports.modify = function (f) { return function (fa) { return pipeable_1.pipe(fa, exports.update(f(fa.focus))); }; };\n/**\n * Moves focus in the zipper, or `None` if there is no such element.\n *\n * @category combinators\n * @since 0.1.6\n */\nexports.move = function (f, fa) {\n    var newIndex = f(fa.lefts.length);\n    if (exports.isOutOfBound(newIndex, fa)) {\n        return Option_1.none;\n    }\n    else {\n        return exports.fromArray(exports.toArray(fa), newIndex);\n    }\n};\n/**\n * Moves focus of the zipper up.\n *\n * @category combinators\n * @since 0.1.6\n */\nexports.up = function (fa) { return exports.move(function_1.decrement, fa); };\n/**\n * Moves focus of the zipper down.\n *\n * @category combinators\n * @since 0.1.6\n */\nexports.down = function (fa) { return exports.move(function_1.increment, fa); };\n/**\n * Moves focus to the start of the zipper.\n *\n * @category combinators\n * @since 0.1.6\n */\nexports.start = function (fa) {\n    if (A.isEmpty(fa.lefts)) {\n        return fa;\n    }\n    else {\n        return exports.make(A.empty, fa.lefts[0], A.snoc(pipeable_1.pipe(fa.lefts, A.dropLeft(1)), fa.focus).concat(fa.rights));\n    }\n};\n/**\n * Moves focus to the end of the zipper.\n *\n * @category combinators\n * @since 0.1.6\n */\nexports.end = function (fa) {\n    var len = fa.rights.length;\n    if (len === 0) {\n        return fa;\n    }\n    else {\n        return exports.make(A.snoc(fa.lefts, fa.focus).concat(pipeable_1.pipe(fa.rights, A.takeLeft(len - 1))), fa.rights[len - 1], A.empty);\n    }\n};\n/**\n * Inserts an element to the left of the focus and focuses on the new element.\n *\n * @category combinators\n * @since 0.1.6\n */\nexports.insertLeft = function (a) { return function (fa) {\n    return exports.make(fa.lefts, a, A.cons(fa.focus, fa.rights));\n}; };\n/**\n * Inserts an element to the right of the focus and focuses on the new element.\n *\n * @category combinators\n * @since 0.1.6\n */\nexports.insertRight = function (a) { return function (fa) {\n    return exports.make(A.snoc(fa.lefts, fa.focus), a, fa.rights);\n}; };\n/**\n * Deletes the element at focus and moves the focus to the left. If there is no element on the left,\n * the focus is moved to the right.\n *\n * @category combinators\n * @since 0.1.6\n */\nexports.deleteLeft = function (fa) {\n    var len = fa.lefts.length;\n    return exports.fromArray(fa.lefts.concat(fa.rights), len > 0 ? len - 1 : 0);\n};\n/**\n * Deletes the element at focus and moves the focus to the right. If there is no element on the right,\n * the focus is moved to the left.\n *\n * @category combinators\n * @since 0.1.6\n */\nexports.deleteRight = function (fa) {\n    var lenl = fa.lefts.length;\n    var lenr = fa.rights.length;\n    return exports.fromArray(fa.lefts.concat(fa.rights), lenr > 0 ? lenl : lenl - 1);\n};\n// -------------------------------------------------------------------------------------\n// non-pipeables\n// -------------------------------------------------------------------------------------\nvar map_ = function (fa, f) { return exports.make(fa.lefts.map(f), f(fa.focus), fa.rights.map(f)); };\nvar mapWithIndex_ = function (fa, f) {\n    var l = fa.lefts.length;\n    return exports.make(fa.lefts.map(function (a, i) { return f(i, a); }), f(l, fa.focus), fa.rights.map(function (a, i) { return f(l + 1 + i, a); }));\n};\nvar ap_ = function (fab, fa) {\n    return exports.make(A.array.ap(fab.lefts, fa.lefts), fab.focus(fa.focus), A.array.ap(fab.rights, fa.rights));\n};\nvar extend_ = function (fa, f) {\n    var lefts = fa.lefts.map(function (a, i) {\n        return f(exports.make(pipeable_1.pipe(fa.lefts, A.takeLeft(i)), a, A.snoc(pipeable_1.pipe(fa.lefts, A.dropLeft(i + 1)), fa.focus).concat(fa.rights)));\n    });\n    var rights = fa.rights.map(function (a, i) {\n        return f(exports.make(A.snoc(fa.lefts, fa.focus).concat(pipeable_1.pipe(fa.rights, A.takeLeft(i))), a, pipeable_1.pipe(fa.rights, A.dropLeft(i + 1))));\n    });\n    return exports.make(lefts, f(fa), rights);\n};\nvar reduce_ = function (fa, b, f) { return fa.rights.reduce(f, f(fa.lefts.reduce(f, b), fa.focus)); };\nvar reduceRight_ = function (fa, b, f) {\n    var rights = fa.rights.reduceRight(function (acc, a) { return f(a, acc); }, b);\n    var focus = f(fa.focus, rights);\n    return fa.lefts.reduceRight(function (acc, a) { return f(a, acc); }, focus);\n};\nvar foldMap_ = function (M) { return function (fa, f) {\n    var lefts = fa.lefts.reduce(function (acc, a) { return M.concat(acc, f(a)); }, M.empty);\n    var rights = fa.rights.reduce(function (acc, a) { return M.concat(acc, f(a)); }, M.empty);\n    return M.concat(M.concat(lefts, f(fa.focus)), rights);\n}; };\n// TODO: add pipeable traverse fp-ts version >= 2.6.3\nvar traverse_ = function (F) {\n    var traverseF = A.array.traverse(F);\n    return function (ta, f) {\n        return F.ap(F.ap(F.map(traverseF(ta.lefts, f), function (lefts) { return function (focus) { return function (rights) { return exports.make(lefts, focus, rights); }; }; }), f(ta.focus)), traverseF(ta.rights, f));\n    };\n};\n// -------------------------------------------------------------------------------------\n// pipeables\n// -------------------------------------------------------------------------------------\n/**\n * @category Functor\n * @since 0.1.18\n */\nexports.map = function (f) { return function (fa) { return map_(fa, f); }; };\n/**\n * @category FunctorWithIndex\n * @since 0.1.18\n */\nexports.mapWithIndex = function (f) { return function (fa) {\n    return mapWithIndex_(fa, f);\n}; };\n/**\n * @category Apply\n * @since 0.1.18\n */\nexports.ap = function (fa) { return function (fab) { return ap_(fab, fa); }; };\n/**\n * @category Apply\n * @since 0.1.18\n */\nexports.apFirst = function (fb) { return function (fa) {\n    return pipeable_1.pipe(fa, exports.map(function (a) { return function (_) { return a; }; }), exports.ap(fb));\n}; };\n/**\n * @category Apply\n * @since 0.1.18\n */\nexports.apSecond = function (fb) { return function (fa) {\n    return pipeable_1.pipe(fa, exports.map(function () { return function (b) { return b; }; }), exports.ap(fb));\n}; };\n/**\n * @category Applicative\n * @since 0.1.6\n */\nexports.of = function (focus) { return exports.make(A.empty, focus, A.empty); };\n/**\n * @category Extend\n * @since 0.1.18\n */\nexports.extend = function (f) { return function (wa) { return extend_(wa, f); }; };\n/**\n * @category Extend\n * @since 0.1.18\n */\nexports.duplicate = exports.extend(function_1.identity);\n/**\n * @category Foldable\n * @since 0.1.18\n */\nexports.foldMap = function (M) { return function (f) { return function (fa) {\n    return foldMap_(M)(fa, f);\n}; }; };\n/**\n * @category Foldable\n * @since 0.1.18\n */\nexports.reduce = function (b, f) { return function (fa) { return reduce_(fa, b, f); }; };\n/**\n * @category Foldable\n * @since 0.1.18\n */\nexports.reduceRight = function (b, f) { return function (fa) {\n    return reduceRight_(fa, b, f);\n}; };\n/**\n * @category Traversable\n * @since 0.1.18\n */\nexports.sequence = function (F) {\n    var sequenceF = A.array.sequence(F);\n    return function (ta) {\n        return F.ap(F.ap(F.map(sequenceF(ta.lefts), function (lefts) { return function (focus) { return function (rights) { return exports.make(lefts, focus, rights); }; }; }), ta.focus), sequenceF(ta.rights));\n    };\n};\n/**\n * @category Comonad\n * @since 0.1.18\n */\nexports.extract = function (fa) { return fa.focus; };\n// -------------------------------------------------------------------------------------\n// instances\n// -------------------------------------------------------------------------------------\n/**\n * @category instances\n * @since 0.1.6\n */\nexports.URI = 'Zipper';\n/**\n * @category instances\n * @since 0.1.6\n */\nexports.getShow = function (S) {\n    var SA = A.getShow(S);\n    return {\n        show: function (fa) { return \"Zipper(\" + SA.show(fa.lefts) + \", \" + S.show(fa.focus) + \", \" + SA.show(fa.rights) + \")\"; }\n    };\n};\n/**\n * @category instances\n * @since 0.1.6\n */\nexports.getSemigroup = function (S) { return ({\n    concat: function (x, y) { return exports.make(x.lefts.concat(y.lefts), S.concat(x.focus, y.focus), x.rights.concat(y.rights)); }\n}); };\n/**\n * @category instances\n * @since 0.1.6\n */\nexports.getMonoid = function (M) { return (__assign(__assign({}, exports.getSemigroup(M)), { empty: exports.make(A.empty, M.empty, A.empty) })); };\n/**\n * @category instances\n * @since 0.1.18\n */\nexports.Functor = {\n    URI: exports.URI,\n    map: map_\n};\n/**\n * @category instances\n * @since 0.1.18\n */\nexports.FunctorWithIndex = {\n    URI: exports.URI,\n    map: map_,\n    mapWithIndex: mapWithIndex_\n};\n/**\n * @category instances\n * @since 0.1.18\n */\nexports.Applicative = {\n    URI: exports.URI,\n    map: map_,\n    ap: ap_,\n    of: exports.of\n};\n/**\n * @category instances\n * @since 0.1.18\n */\nexports.Apply = {\n    URI: exports.URI,\n    map: map_,\n    ap: ap_\n};\n/**\n * @category instances\n * @since 0.1.18\n */\nexports.Foldable = {\n    URI: exports.URI,\n    foldMap: foldMap_,\n    reduce: reduce_,\n    reduceRight: reduceRight_\n};\n/**\n * @category instances\n * @since 0.1.18\n */\nexports.Traversable = {\n    URI: exports.URI,\n    map: map_,\n    foldMap: foldMap_,\n    reduce: reduce_,\n    reduceRight: reduceRight_,\n    traverse: traverse_,\n    sequence: exports.sequence\n};\n/**\n * @category instances\n * @since 0.1.18\n */\nexports.Comonad = {\n    URI: exports.URI,\n    map: map_,\n    extend: extend_,\n    extract: exports.extract\n};\n/**\n * @category instances\n * @since 0.1.6\n */\nexports.zipper = {\n    URI: exports.URI,\n    map: map_,\n    of: exports.of,\n    ap: ap_,\n    extend: extend_,\n    extract: exports.extract,\n    reduce: reduce_,\n    reduceRight: reduceRight_,\n    foldMap: foldMap_,\n    traverse: traverse_,\n    sequence: exports.sequence,\n    mapWithIndex: mapWithIndex_\n};\n","/**\n * @since 2.0.0\n */\nexport function tailRec(a, f) {\n    var v = f(a);\n    while (v._tag === 'Left') {\n        v = f(v.left);\n    }\n    return v.right;\n}\n","import { getFunctorComposition } from './Functor';\nimport { getLeft, getRight } from './Option';\nexport function getCompactableComposition(F, G) {\n    var FC = getFunctorComposition(F, G);\n    var CC = {\n        map: FC.map,\n        compact: function (fga) { return F.map(fga, G.compact); },\n        separate: function (fge) {\n            var left = CC.compact(FC.map(fge, getLeft));\n            var right = CC.compact(FC.map(fge, getRight));\n            return { left: left, right: right };\n        }\n    };\n    return CC;\n}\n","import { tailRec } from './ChainRec';\nimport { identity, pipe, bind_, bindTo_, flow } from './function';\n// -------------------------------------------------------------------------------------\n// guards\n// -------------------------------------------------------------------------------------\n/**\n * Returns `true` if the either is an instance of `Left`, `false` otherwise.\n *\n * @category guards\n * @since 2.0.0\n */\nexport var isLeft = function (ma) { return ma._tag === 'Left'; };\n/**\n * Returns `true` if the either is an instance of `Right`, `false` otherwise.\n *\n * @category guards\n * @since 2.0.0\n */\nexport var isRight = function (ma) { return ma._tag === 'Right'; };\n// -------------------------------------------------------------------------------------\n// constructors\n// -------------------------------------------------------------------------------------\n/**\n * Constructs a new `Either` holding a `Left` value. This usually represents a failure, due to the right-bias of this\n * structure.\n *\n * @category constructors\n * @since 2.0.0\n */\nexport var left = function (e) { return ({ _tag: 'Left', left: e }); };\n/**\n * Constructs a new `Either` holding a `Right` value. This usually represents a successful value due to the right bias\n * of this structure.\n *\n * @category constructors\n * @since 2.0.0\n */\nexport var right = function (a) { return ({ _tag: 'Right', right: a }); };\n// TODO: make lazy in v3\n/**\n * Takes a default and a nullable value, if the value is not nully, turn it into a `Right`, if the value is nully use\n * the provided default as a `Left`.\n *\n * @example\n * import { fromNullable, left, right } from 'fp-ts/Either'\n *\n * const parse = fromNullable('nully')\n *\n * assert.deepStrictEqual(parse(1), right(1))\n * assert.deepStrictEqual(parse(null), left('nully'))\n *\n * @category constructors\n * @since 2.0.0\n */\nexport function fromNullable(e) {\n    return function (a) { return (a == null ? left(e) : right(a)); };\n}\n// TODO: `onError => Lazy<A> => Either` in v3\n/**\n * Constructs a new `Either` from a function that might throw.\n *\n * @example\n * import { Either, left, right, tryCatch } from 'fp-ts/Either'\n *\n * const unsafeHead = <A>(as: Array<A>): A => {\n *   if (as.length > 0) {\n *     return as[0]\n *   } else {\n *     throw new Error('empty array')\n *   }\n * }\n *\n * const head = <A>(as: Array<A>): Either<Error, A> => {\n *   return tryCatch(() => unsafeHead(as), e => (e instanceof Error ? e : new Error('unknown error')))\n * }\n *\n * assert.deepStrictEqual(head([]), left(new Error('empty array')))\n * assert.deepStrictEqual(head([1, 2, 3]), right(1))\n *\n * @category constructors\n * @since 2.0.0\n */\nexport function tryCatch(f, onError) {\n    try {\n        return right(f());\n    }\n    catch (e) {\n        return left(onError(e));\n    }\n}\n// TODO curry in v3\n/**\n * Converts a JavaScript Object Notation (JSON) string into an object.\n *\n * @example\n * import { parseJSON, toError, right, left } from 'fp-ts/Either'\n *\n * assert.deepStrictEqual(parseJSON('{\"a\":1}', toError), right({ a: 1 }))\n * assert.deepStrictEqual(parseJSON('{\"a\":}', toError), left(new SyntaxError('Unexpected token } in JSON at position 5')))\n *\n * @category constructors\n * @since 2.0.0\n */\nexport function parseJSON(s, onError) {\n    return tryCatch(function () { return JSON.parse(s); }, onError);\n}\n// TODO curry in v3\n/**\n * Converts a JavaScript value to a JavaScript Object Notation (JSON) string.\n *\n * @example\n * import * as E from 'fp-ts/Either'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(E.stringifyJSON({ a: 1 }, E.toError), E.right('{\"a\":1}'))\n * const circular: any = { ref: null }\n * circular.ref = circular\n * assert.deepStrictEqual(\n *   pipe(\n *     E.stringifyJSON(circular, E.toError),\n *     E.mapLeft(e => e.message.includes('Converting circular structure to JSON'))\n *   ),\n *   E.left(true)\n * )\n *\n * @category constructors\n * @since 2.0.0\n */\nexport function stringifyJSON(u, onError) {\n    return tryCatch(function () { return JSON.stringify(u); }, onError);\n}\n/**\n * Derivable from `MonadThrow`.\n *\n * @example\n * import { fromOption, left, right } from 'fp-ts/Either'\n * import { pipe } from 'fp-ts/function'\n * import { none, some } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     some(1),\n *     fromOption(() => 'error')\n *   ),\n *   right(1)\n * )\n * assert.deepStrictEqual(\n *   pipe(\n *     none,\n *     fromOption(() => 'error')\n *   ),\n *   left('error')\n * )\n *\n * @category constructors\n * @since 2.0.0\n */\nexport var fromOption = function (onNone) { return function (ma) {\n    return ma._tag === 'None' ? left(onNone()) : right(ma.value);\n}; };\n/**\n * Derivable from `MonadThrow`.\n *\n * @example\n * import { fromPredicate, left, right } from 'fp-ts/Either'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     1,\n *     fromPredicate(\n *       (n) => n > 0,\n *       () => 'error'\n *     )\n *   ),\n *   right(1)\n * )\n * assert.deepStrictEqual(\n *   pipe(\n *     -1,\n *     fromPredicate(\n *       (n) => n > 0,\n *       () => 'error'\n *     )\n *   ),\n *   left('error')\n * )\n *\n * @category 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 * Takes two functions and an `Either` value, if the value is a `Left` the inner value is applied to the first function,\n * if the value is a `Right` the inner value is applied to the second function.\n *\n * @example\n * import { fold, left, right } from 'fp-ts/Either'\n * import { pipe } from 'fp-ts/function'\n *\n * function onLeft(errors: Array<string>): string {\n *   return `Errors: ${errors.join(', ')}`\n * }\n *\n * function onRight(value: number): string {\n *   return `Ok: ${value}`\n * }\n *\n * assert.strictEqual(\n *   pipe(\n *     right(1),\n *     fold(onLeft, onRight)\n *   ),\n *   'Ok: 1'\n * )\n * assert.strictEqual(\n *   pipe(\n *     left(['error 1', 'error 2']),\n *     fold(onLeft, onRight)\n *   ),\n *   'Errors: error 1, error 2'\n * )\n *\n * @category destructors\n * @since 2.0.0\n */\nexport function fold(onLeft, onRight) {\n    return function (ma) { return (isLeft(ma) ? onLeft(ma.left) : onRight(ma.right)); };\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) {\n    return isLeft(ma) ? onLeft(ma.left) : ma.right;\n}; };\n/**\n * Returns the wrapped value if it's a `Right` or a default value if is a `Left`.\n *\n * @example\n * import { getOrElse, left, right } from 'fp-ts/Either'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     right(1),\n *     getOrElse(() => 0)\n *   ),\n *   1\n * )\n * assert.deepStrictEqual(\n *   pipe(\n *     left('error'),\n *     getOrElse(() => 0)\n *   ),\n *   0\n * )\n *\n * @category destructors\n * @since 2.0.0\n */\nexport var getOrElse = getOrElseW;\n// -------------------------------------------------------------------------------------\n// combinators\n// -------------------------------------------------------------------------------------\n/**\n * @category combinators\n * @since 2.9.0\n */\nexport function fromNullableK(e) {\n    var from = fromNullable(e);\n    return function (f) { return function () {\n        var a = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            a[_i] = arguments[_i];\n        }\n        return from(f.apply(void 0, a));\n    }; };\n}\n/**\n * @category combinators\n * @since 2.9.0\n */\nexport function chainNullableK(e) {\n    var from = fromNullableK(e);\n    return function (f) { return chain(from(f)); };\n}\n/**\n * Returns a `Right` if is a `Left` (and vice versa).\n *\n * @category combinators\n * @since 2.0.0\n */\nexport function swap(ma) {\n    return isLeft(ma) ? right(ma.left) : left(ma.right);\n}\n/**\n * Useful for recovering from errors.\n *\n * @category combinators\n * @since 2.0.0\n */\nexport function orElse(onLeft) {\n    return function (ma) { return (isLeft(ma) ? onLeft(ma.left) : ma); };\n}\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 * @example\n * import { filterOrElse, left, right } from 'fp-ts/Either'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     right(1),\n *     filterOrElse(\n *       (n) => n > 0,\n *       () => 'error'\n *     )\n *   ),\n *   right(1)\n * )\n * assert.deepStrictEqual(\n *   pipe(\n *     right(-1),\n *     filterOrElse(\n *       (n) => n > 0,\n *       () => 'error'\n *     )\n *   ),\n *   left('error')\n * )\n * assert.deepStrictEqual(\n *   pipe(\n *     left('a'),\n *     filterOrElse(\n *       (n) => n > 0,\n *       () => 'error'\n *     )\n *   ),\n *   left('a')\n * )\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var filterOrElse = filterOrElseW;\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)); };\n/* istanbul ignore next */\nvar chain_ = function (ma, f) { return pipe(ma, chain(f)); };\n/* istanbul ignore next */\nvar reduce_ = function (fa, b, f) { return pipe(fa, reduce(b, f)); };\n/* istanbul ignore next */\nvar foldMap_ = function (M) { return function (fa, f) {\n    var foldMapM = foldMap(M);\n    return pipe(fa, foldMapM(f));\n}; };\n/* istanbul ignore next */\nvar reduceRight_ = function (fa, b, f) { return pipe(fa, reduceRight(b, f)); };\nvar traverse_ = function (F) {\n    var traverseF = traverse(F);\n    return function (ta, f) { return pipe(ta, traverseF(f)); };\n};\nvar bimap_ = function (fa, f, g) { return pipe(fa, bimap(f, g)); };\nvar mapLeft_ = function (fa, f) { return pipe(fa, mapLeft(f)); };\n/* istanbul ignore next */\nvar alt_ = function (fa, that) { return pipe(fa, alt(that)); };\n/* istanbul ignore next */\nvar extend_ = function (wa, f) { return pipe(wa, extend(f)); };\nvar chainRec_ = function (a, f) {\n    return tailRec(f(a), function (e) {\n        return isLeft(e) ? right(left(e.left)) : isLeft(e.right) ? left(f(e.right.left)) : right(right(e.right.right));\n    });\n};\n// -------------------------------------------------------------------------------------\n// 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 isLeft(fa) ? fa : right(f(fa.right));\n}; };\n/**\n * Map a pair of functions over the two 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 (isLeft(fa) ? left(f(fa.left)) : right(g(fa.right))); }; };\n/**\n * Map a function over the first type argument of a bifunctor.\n *\n * @category Bifunctor\n * @since 2.0.0\n */\nexport var mapLeft = function (f) { return function (fa) {\n    return isLeft(fa) ? left(f(fa.left)) : fa;\n}; };\n/**\n * Less strict version of [`ap`](#ap).\n *\n * @category Apply\n * @since 2.8.0\n */\nexport var apW = function (fa) { return function (fab) {\n    return isLeft(fab) ? fab : isLeft(fa) ? fa : right(fab.right(fa.right));\n}; };\n/**\n * 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 * @example\n * import * as E from 'fp-ts/Either'\n *\n * assert.deepStrictEqual(E.of('a'), E.right('a'))\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 (ma) {\n    return isLeft(ma) ? ma : f(ma.right);\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) { return function (ma) {\n    return pipe(ma, 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 * The `flatten` function is the conventional monad join operator. It is used to remove one level of monadic structure, projecting its bound argument into the outer level.\n *\n * Derivable from `Monad`.\n *\n * @example\n * import * as E from 'fp-ts/Either'\n *\n * assert.deepStrictEqual(E.flatten(E.right(E.right('a'))), E.right('a'))\n * assert.deepStrictEqual(E.flatten(E.right(E.left('e'))), E.left('e'))\n * assert.deepStrictEqual(E.flatten(E.left('e')), E.left('e'))\n *\n * @category 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 (isLeft(fa) ? that() : fa); }; };\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 Extend\n * @since 2.0.0\n */\nexport var extend = function (f) { return function (wa) {\n    return isLeft(wa) ? wa : right(f(wa));\n}; };\n/**\n * Derivable from `Extend`.\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var duplicate = \n/*#__PURE__*/\nextend(identity);\n/**\n * Left-associative fold of a structure.\n *\n * @example\n * import { pipe } from 'fp-ts/function'\n * import * as E from 'fp-ts/Either'\n *\n * const startWith = 'prefix'\n * const concat = (a: string, b: string) => `${a}:${b}`\n *\n * assert.deepStrictEqual(\n *   pipe(E.right('a'), E.reduce(startWith, concat)),\n *   'prefix:a',\n * )\n *\n * assert.deepStrictEqual(\n *   pipe(E.left('e'), E.reduce(startWith, concat)),\n *   'prefix',\n * )\n *\n * @category Foldable\n * @since 2.0.0\n */\nexport var reduce = function (b, f) { return function (fa) {\n    return isLeft(fa) ? b : f(b, fa.right);\n}; };\n/**\n * Map each element of the structure to a monoid, and combine the results.\n *\n * @example\n * import { pipe } from 'fp-ts/function';\n * import * as E from 'fp-ts/Either'\n * import { monoidString } from 'fp-ts/Monoid'\n *\n * const yell = (a: string) => `${a}!`\n *\n * assert.deepStrictEqual(\n *   pipe(E.right('a'), E.foldMap(monoidString)(yell)),\n *   'a!',\n * )\n *\n * assert.deepStrictEqual(\n *   pipe(E.left('e'), E.foldMap(monoidString)(yell)),\n *   monoidString.empty,\n * )\n *\n * @category Foldable\n * @since 2.0.0\n */\nexport var foldMap = function (M) { return function (f) { return function (fa) {\n    return isLeft(fa) ? M.empty : f(fa.right);\n}; }; };\n/**\n * Right-associative fold of a structure.\n *\n * @example\n * import { pipe } from 'fp-ts/function'\n * import * as E from 'fp-ts/Either'\n *\n * const startWith = 'postfix'\n * const concat = (a: string, b: string) => `${a}:${b}`\n *\n * assert.deepStrictEqual(\n *   pipe(E.right('a'), E.reduceRight(startWith, concat)),\n *   'a:postfix',\n * )\n *\n * assert.deepStrictEqual(\n *   pipe(E.left('e'), E.reduceRight(startWith, concat)),\n *   'postfix',\n * )\n *\n * @category Foldable\n * @since 2.0.0\n */\nexport var reduceRight = function (b, f) { return function (fa) {\n    return isLeft(fa) ? b : f(fa.right, b);\n}; };\n/**\n * Map each element of a structure to an action, evaluate these actions from left to right, and collect the results.\n *\n * @example\n * import { pipe } from 'fp-ts/function'\n * import * as A from 'fp-ts/Array'\n * import * as E from 'fp-ts/Either'\n * import * as O from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(\n *   pipe(E.right(['a']), E.traverse(O.option)(A.head)),\n *   O.some(E.right('a')),\n *  )\n *\n * assert.deepStrictEqual(\n *   pipe(E.right([]), E.traverse(O.option)(A.head)),\n *   O.none,\n * )\n *\n * @category Traversable\n * @since 2.6.3\n */\nexport var traverse = function (F) { return function (f) { return function (ta) { return (isLeft(ta) ? F.of(left(ta.left)) : F.map(f(ta.right), right)); }; }; };\n/**\n * Evaluate each monadic action in the structure from left to right, and collect the results.\n *\n * @example\n * import { pipe } from 'fp-ts/function'\n * import * as E from 'fp-ts/Either'\n * import * as O from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(\n *   pipe(E.right(O.some('a')), E.sequence(O.option)),\n *   O.some(E.right('a')),\n *  )\n *\n * assert.deepStrictEqual(\n *   pipe(E.right(O.none), E.sequence(O.option)),\n *   O.none\n * )\n *\n * @category Traversable\n * @since 2.6.3\n */\nexport var sequence = function (F) { return function (ma) {\n    return isLeft(ma) ? F.of(left(ma.left)) : F.map(ma.right, right);\n}; };\n/**\n * @category MonadThrow\n * @since 2.6.3\n */\nexport var throwError = left;\n// -------------------------------------------------------------------------------------\n// instances\n// -------------------------------------------------------------------------------------\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var URI = 'Either';\n/**\n * @category instances\n * @since 2.0.0\n */\nexport function getShow(SE, SA) {\n    return {\n        show: function (ma) { return (isLeft(ma) ? \"left(\" + SE.show(ma.left) + \")\" : \"right(\" + SA.show(ma.right) + \")\"); }\n    };\n}\n/**\n * @category instances\n * @since 2.0.0\n */\nexport function getEq(EL, EA) {\n    return {\n        equals: function (x, y) {\n            return x === y || (isLeft(x) ? isLeft(y) && EL.equals(x.left, y.left) : isRight(y) && EA.equals(x.right, y.right));\n        }\n    };\n}\n/**\n * Semigroup returning the left-most non-`Left` value. If both operands are `Right`s then the inner values are\n * concatenated using the provided `Semigroup`\n *\n * @example\n * import { getSemigroup, left, right } from 'fp-ts/Either'\n * import { semigroupSum } from 'fp-ts/Semigroup'\n *\n * const S = getSemigroup<string, number>(semigroupSum)\n * assert.deepStrictEqual(S.concat(left('a'), left('b')), left('a'))\n * assert.deepStrictEqual(S.concat(left('a'), right(2)), right(2))\n * assert.deepStrictEqual(S.concat(right(1), left('b')), right(1))\n * assert.deepStrictEqual(S.concat(right(1), right(2)), right(3))\n *\n * @category instances\n * @since 2.0.0\n */\nexport function getSemigroup(S) {\n    return {\n        concat: function (x, y) { return (isLeft(y) ? x : isLeft(x) ? y : right(S.concat(x.right, y.right))); }\n    };\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 * @example\n * import { getApplySemigroup, left, right } from 'fp-ts/Either'\n * import { semigroupSum } from 'fp-ts/Semigroup'\n *\n * const S = getApplySemigroup<string, number>(semigroupSum)\n * assert.deepStrictEqual(S.concat(left('a'), left('b')), left('a'))\n * assert.deepStrictEqual(S.concat(left('a'), right(2)), left('a'))\n * assert.deepStrictEqual(S.concat(right(1), left('b')), left('b'))\n * assert.deepStrictEqual(S.concat(right(1), right(2)), right(3))\n *\n * @category instances\n * @since 2.0.0\n */\nexport function getApplySemigroup(S) {\n    return {\n        concat: function (x, y) { return (isLeft(x) ? x : isLeft(y) ? y : right(S.concat(x.right, y.right))); }\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: right(M.empty)\n    };\n}\n/**\n * Builds a `Filterable` instance for `Either` given `Monoid` for the left side\n *\n * @category instances\n * @since 3.0.0\n */\nexport function getFilterable(M) {\n    var empty = left(M.empty);\n    var compact = function (ma) {\n        return isLeft(ma) ? ma : ma.right._tag === 'None' ? empty : right(ma.right.value);\n    };\n    var separate = function (ma) {\n        return isLeft(ma)\n            ? { left: ma, right: ma }\n            : isLeft(ma.right)\n                ? { left: right(ma.right.left), right: empty }\n                : { left: empty, right: right(ma.right.right) };\n    };\n    var partitionMap = function (ma, f) {\n        if (isLeft(ma)) {\n            return { left: ma, right: ma };\n        }\n        var e = f(ma.right);\n        return isLeft(e) ? { left: right(e.left), right: empty } : { left: empty, right: right(e.right) };\n    };\n    var partition = function (ma, p) {\n        return isLeft(ma)\n            ? { left: ma, right: ma }\n            : p(ma.right)\n                ? { left: empty, right: right(ma.right) }\n                : { left: right(ma.right), right: empty };\n    };\n    var filterMap = function (ma, f) {\n        if (isLeft(ma)) {\n            return ma;\n        }\n        var ob = f(ma.right);\n        return ob._tag === 'None' ? empty : right(ob.value);\n    };\n    var filter = function (ma, predicate) {\n        return isLeft(ma) ? ma : predicate(ma.right) ? ma : empty;\n    };\n    return {\n        URI: URI,\n        _E: undefined,\n        map: map_,\n        compact: compact,\n        separate: separate,\n        filter: filter,\n        filterMap: filterMap,\n        partition: partition,\n        partitionMap: partitionMap\n    };\n}\n/**\n * Builds `Witherable` instance for `Either` given `Monoid` for the left side\n *\n * @category instances\n * @since 2.0.0\n */\nexport function getWitherable(M) {\n    var F_ = getFilterable(M);\n    var wither = function (F) {\n        var traverseF = traverse_(F);\n        return function (ma, f) { return F.map(traverseF(ma, f), F_.compact); };\n    };\n    var wilt = function (F) {\n        var traverseF = traverse_(F);\n        return function (ma, f) { return F.map(traverseF(ma, f), F_.separate); };\n    };\n    return {\n        URI: URI,\n        _E: undefined,\n        map: map_,\n        compact: F_.compact,\n        separate: F_.separate,\n        filter: F_.filter,\n        filterMap: F_.filterMap,\n        partition: F_.partition,\n        partitionMap: F_.partitionMap,\n        traverse: traverse_,\n        sequence: sequence,\n        reduce: reduce_,\n        foldMap: foldMap_,\n        reduceRight: reduceRight_,\n        wither: wither,\n        wilt: wilt\n    };\n}\n/**\n * @category instances\n * @since 2.7.0\n */\nexport function getApplicativeValidation(SE) {\n    return {\n        URI: URI,\n        _E: undefined,\n        map: map_,\n        ap: function (fab, fa) {\n            return isLeft(fab)\n                ? isLeft(fa)\n                    ? left(SE.concat(fab.left, fa.left))\n                    : fab\n                : isLeft(fa)\n                    ? fa\n                    : right(fab.right(fa.right));\n        },\n        of: of\n    };\n}\n/**\n * @category instances\n * @since 2.7.0\n */\nexport function getAltValidation(SE) {\n    return {\n        URI: URI,\n        _E: undefined,\n        map: map_,\n        alt: function (me, that) {\n            if (isRight(me)) {\n                return me;\n            }\n            var ea = that();\n            return isLeft(ea) ? left(SE.concat(me.left, ea.left)) : ea;\n        }\n    };\n}\n// TODO: remove in v3\n/**\n * @category instances\n * @since 2.0.0\n */\nexport function getValidation(SE) {\n    var applicativeValidation = getApplicativeValidation(SE);\n    var altValidation = getAltValidation(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        reduce: reduce_,\n        foldMap: foldMap_,\n        reduceRight: reduceRight_,\n        extend: extend_,\n        traverse: traverse_,\n        sequence: sequence,\n        chainRec: chainRec_,\n        throwError: throwError,\n        ap: applicativeValidation.ap,\n        alt: altValidation.alt\n    };\n}\n/**\n * @category instances\n * @since 2.0.0\n */\nexport function getValidationSemigroup(SE, SA) {\n    return {\n        concat: function (x, y) {\n            return isLeft(x) ? (isLeft(y) ? left(SE.concat(x.left, y.left)) : x) : isLeft(y) ? y : right(SA.concat(x.right, y.right));\n        }\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 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 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/**\n * @category instances\n * @since 2.7.0\n */\nexport var Extend = {\n    URI: URI,\n    map: map_,\n    extend: extend_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var ChainRec = {\n    URI: URI,\n    map: map_,\n    ap: ap_,\n    chain: chain_,\n    chainRec: chainRec_\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/**\n * @category instances\n * @since 2.0.0\n */\nexport function getValidationMonoid(SE, SA) {\n    return {\n        concat: getValidationSemigroup(SE, SA).concat,\n        empty: right(SA.empty)\n    };\n}\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var either = {\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    bimap: bimap_,\n    mapLeft: mapLeft_,\n    alt: alt_,\n    extend: extend_,\n    chainRec: chainRec_,\n    throwError: throwError\n};\n// -------------------------------------------------------------------------------------\n// utils\n// -------------------------------------------------------------------------------------\n/**\n * Default value for the `onError` argument of `tryCatch`\n *\n * @since 2.0.0\n */\nexport function toError(e) {\n    return e instanceof Error ? e : new Error(String(e));\n}\n/**\n * @since 2.0.0\n */\nexport function elem(E) {\n    return function (a, ma) { return (isLeft(ma) ? false : E.equals(a, ma.right)); };\n}\n/**\n * Returns `false` if `Left` or returns the result of the application of the given predicate to the `Right` value.\n *\n * @example\n * import { exists, left, right } from 'fp-ts/Either'\n *\n * const gt2 = exists((n: number) => n > 2)\n *\n * assert.strictEqual(gt2(left('a')), false)\n * assert.strictEqual(gt2(right(1)), false)\n * assert.strictEqual(gt2(right(3)), true)\n *\n * @since 2.0.0\n */\nexport function exists(predicate) {\n    return function (ma) { return (isLeft(ma) ? false : predicate(ma.right)); };\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) {\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.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) {\n    // tslint:disable-next-line: readonly-array\n    var result = [];\n    for (var i = 0; i < arr.length; i++) {\n        var e = f(i, arr[i]);\n        if (e._tag === 'Left') {\n            return e;\n        }\n        result.push(e.right);\n    }\n    return right(result);\n}; };\n/**\n * map an array using provided function to Either then transform to Either of the array\n * this function have the same behavior of `A.traverse(E.either)` but it's optimized and perform better\n *\n * @example\n *\n *\n * import { traverseArray, left, right, fromPredicate } from 'fp-ts/Either'\n * import { pipe } from 'fp-ts/function'\n * import * as A from 'fp-ts/Array'\n *\n * const arr = A.range(0, 10)\n * assert.deepStrictEqual(\n *   pipe(\n *     arr,\n *     traverseArray((x) => right(x))\n *   ),\n *   right(arr)\n * )\n * assert.deepStrictEqual(\n *   pipe(\n *     arr,\n *     traverseArray(\n *       fromPredicate(\n *         (x) => x > 5,\n *         () => 'a'\n *       )\n *     )\n *   ),\n *   left('a')\n * )\n * @since 2.9.0\n */\nexport var traverseArray = function (f) { return traverseArrayWithIndex(function (_, a) { return f(a); }); };\n/**\n * convert an array of either to an either of array\n * this function have the same behavior of `A.sequence(E.either)` but it's optimized and perform better\n *\n * @example\n *\n * import { sequenceArray, left, right } from 'fp-ts/Either'\n * import { pipe } from 'fp-ts/function'\n * import * as A from 'fp-ts/Array'\n *\n * const arr = A.range(0, 10)\n * assert.deepStrictEqual(pipe(arr, A.map(right), sequenceArray), right(arr))\n * assert.deepStrictEqual(pipe(arr, A.map(right), A.cons(left('Error')), sequenceArray), left('Error'))\n *\n * @since 2.9.0\n */\nexport var sequenceArray = \n/*#__PURE__*/\ntraverseArray(identity);\n","/**\n * Returns the current `Date`\n *\n * @category constructors\n * @since 2.0.0\n */\nexport var create = function () { return new Date(); };\n/**\n * Returns the number of milliseconds elapsed since January 1, 1970, 00:00:00 UTC\n *\n * @since 2.0.0\n */\nexport var now = function () { return new Date().getTime(); };\n/**\n * @category instances\n * @since 2.6.0\n */\nexport var eqDate = {\n    equals: function (x, y) { return x.getDate() === y.getDate(); }\n};\n/**\n * @category instances\n * @since 2.6.0\n */\nexport var eqMonth = {\n    equals: function (x, y) { return x.getMonth() === y.getMonth(); }\n};\n/**\n * @category instances\n * @since 2.6.0\n */\nexport var eqYear = {\n    equals: function (x, y) { return x.getFullYear() === y.getFullYear(); }\n};\n","'use strict';\n\n// do not edit .js files directly - edit src/index.jst\n\n\n\nmodule.exports = function equal(a, b) {\n  if (a === b) return true;\n\n  if (a && b && typeof a == 'object' && typeof b == 'object') {\n    if (a.constructor !== b.constructor) return false;\n\n    var length, i, keys;\n    if (Array.isArray(a)) {\n      length = a.length;\n      if (length != b.length) return false;\n      for (i = length; i-- !== 0;)\n        if (!equal(a[i], b[i])) return false;\n      return true;\n    }\n\n\n\n    if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;\n    if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();\n    if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();\n\n    keys = Object.keys(a);\n    length = keys.length;\n    if (length !== Object.keys(b).length) return false;\n\n    for (i = length; i-- !== 0;)\n      if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;\n\n    for (i = length; i-- !== 0;) {\n      var key = keys[i];\n\n      if (key === '_owner' && a.$$typeof) {\n        // React-specific: avoid traversing React elements' _owner.\n        //  _owner contains circular references\n        // and is not needed when comparing the actual elements (and not their owners)\n        continue;\n      }\n\n      if (!equal(a[key], b[key])) return false;\n    }\n\n    return true;\n  }\n\n  // true if both NaN, false otherwise\n  return a!==a && b!==b;\n};\n","var __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nimport * as A from 'fp-ts/es6/Array';\nimport { decrement, increment, identity } from 'fp-ts/es6/function';\nimport { none, some } from 'fp-ts/es6/Option';\nimport { pipe } from 'fp-ts/es6/pipeable';\n// -------------------------------------------------------------------------------------\n// constructors\n// -------------------------------------------------------------------------------------\n/**\n * Creates a new zipper.\n *\n * @category constructors\n * @since 0.1.6\n */\nexport var make = function (lefts, focus, rights) { return ({\n    lefts: lefts,\n    focus: focus,\n    rights: rights\n}); };\n/**\n * @category constructors\n * @since 0.1.6\n */\nexport var fromArray = function (as, focusIndex) {\n    if (focusIndex === void 0) { focusIndex = 0; }\n    if (A.isEmpty(as) || A.isOutOfBound(focusIndex, as)) {\n        return none;\n    }\n    else {\n        return some(make(pipe(as, A.takeLeft(focusIndex)), as[focusIndex], pipe(as, A.dropLeft(focusIndex + 1))));\n    }\n};\n/**\n * @category constructors\n * @since 0.1.6\n */\nexport var fromNonEmptyArray = function (nea) { return make(A.empty, nea[0], nea.slice(1)); };\n// -------------------------------------------------------------------------------------\n// destructors\n// -------------------------------------------------------------------------------------\n/**\n * @category destructors\n * @since 0.1.18\n */\nexport var isOutOfBound = function (index, fa) {\n    return index < 0 || index >= length(fa);\n};\n/**\n * @category destructors\n * @since 0.1.6\n */\nexport var length = function (fa) { return fa.lefts.length + 1 + fa.rights.length; };\n/**\n * @category destructors\n * @since 0.1.6\n */\nexport var toArray = function (fa) { return A.snoc(fa.lefts, fa.focus).concat(fa.rights); };\n// -------------------------------------------------------------------------------------\n// combinators\n// -------------------------------------------------------------------------------------\n/**\n * Updates the focus of the zipper.\n *\n * @category combinators\n * @since 0.1.6\n */\nexport var update = function (a) { return function (fa) { return make(fa.lefts, a, fa.rights); }; };\n/**\n * Applies `f` to the focus and update with the result.\n *\n * @category combinators\n * @since 0.1.6\n */\nexport var modify = function (f) { return function (fa) { return pipe(fa, update(f(fa.focus))); }; };\n/**\n * Moves focus in the zipper, or `None` if there is no such element.\n *\n * @category combinators\n * @since 0.1.6\n */\nexport var move = function (f, fa) {\n    var newIndex = f(fa.lefts.length);\n    if (isOutOfBound(newIndex, fa)) {\n        return none;\n    }\n    else {\n        return fromArray(toArray(fa), newIndex);\n    }\n};\n/**\n * Moves focus of the zipper up.\n *\n * @category combinators\n * @since 0.1.6\n */\nexport var up = function (fa) { return move(decrement, fa); };\n/**\n * Moves focus of the zipper down.\n *\n * @category combinators\n * @since 0.1.6\n */\nexport var down = function (fa) { return move(increment, fa); };\n/**\n * Moves focus to the start of the zipper.\n *\n * @category combinators\n * @since 0.1.6\n */\nexport var start = function (fa) {\n    if (A.isEmpty(fa.lefts)) {\n        return fa;\n    }\n    else {\n        return make(A.empty, fa.lefts[0], A.snoc(pipe(fa.lefts, A.dropLeft(1)), fa.focus).concat(fa.rights));\n    }\n};\n/**\n * Moves focus to the end of the zipper.\n *\n * @category combinators\n * @since 0.1.6\n */\nexport var end = function (fa) {\n    var len = fa.rights.length;\n    if (len === 0) {\n        return fa;\n    }\n    else {\n        return make(A.snoc(fa.lefts, fa.focus).concat(pipe(fa.rights, A.takeLeft(len - 1))), fa.rights[len - 1], A.empty);\n    }\n};\n/**\n * Inserts an element to the left of the focus and focuses on the new element.\n *\n * @category combinators\n * @since 0.1.6\n */\nexport var insertLeft = function (a) { return function (fa) {\n    return make(fa.lefts, a, A.cons(fa.focus, fa.rights));\n}; };\n/**\n * Inserts an element to the right of the focus and focuses on the new element.\n *\n * @category combinators\n * @since 0.1.6\n */\nexport var insertRight = function (a) { return function (fa) {\n    return make(A.snoc(fa.lefts, fa.focus), a, fa.rights);\n}; };\n/**\n * Deletes the element at focus and moves the focus to the left. If there is no element on the left,\n * the focus is moved to the right.\n *\n * @category combinators\n * @since 0.1.6\n */\nexport var deleteLeft = function (fa) {\n    var len = fa.lefts.length;\n    return fromArray(fa.lefts.concat(fa.rights), len > 0 ? len - 1 : 0);\n};\n/**\n * Deletes the element at focus and moves the focus to the right. If there is no element on the right,\n * the focus is moved to the left.\n *\n * @category combinators\n * @since 0.1.6\n */\nexport var deleteRight = function (fa) {\n    var lenl = fa.lefts.length;\n    var lenr = fa.rights.length;\n    return fromArray(fa.lefts.concat(fa.rights), lenr > 0 ? lenl : lenl - 1);\n};\n// -------------------------------------------------------------------------------------\n// non-pipeables\n// -------------------------------------------------------------------------------------\nvar map_ = function (fa, f) { return make(fa.lefts.map(f), f(fa.focus), fa.rights.map(f)); };\nvar mapWithIndex_ = function (fa, f) {\n    var l = fa.lefts.length;\n    return make(fa.lefts.map(function (a, i) { return f(i, a); }), f(l, fa.focus), fa.rights.map(function (a, i) { return f(l + 1 + i, a); }));\n};\nvar ap_ = function (fab, fa) {\n    return make(A.array.ap(fab.lefts, fa.lefts), fab.focus(fa.focus), A.array.ap(fab.rights, fa.rights));\n};\nvar extend_ = function (fa, f) {\n    var lefts = fa.lefts.map(function (a, i) {\n        return f(make(pipe(fa.lefts, A.takeLeft(i)), a, A.snoc(pipe(fa.lefts, A.dropLeft(i + 1)), fa.focus).concat(fa.rights)));\n    });\n    var rights = fa.rights.map(function (a, i) {\n        return f(make(A.snoc(fa.lefts, fa.focus).concat(pipe(fa.rights, A.takeLeft(i))), a, pipe(fa.rights, A.dropLeft(i + 1))));\n    });\n    return make(lefts, f(fa), rights);\n};\nvar reduce_ = function (fa, b, f) { return fa.rights.reduce(f, f(fa.lefts.reduce(f, b), fa.focus)); };\nvar reduceRight_ = function (fa, b, f) {\n    var rights = fa.rights.reduceRight(function (acc, a) { return f(a, acc); }, b);\n    var focus = f(fa.focus, rights);\n    return fa.lefts.reduceRight(function (acc, a) { return f(a, acc); }, focus);\n};\nvar foldMap_ = function (M) { return function (fa, f) {\n    var lefts = fa.lefts.reduce(function (acc, a) { return M.concat(acc, f(a)); }, M.empty);\n    var rights = fa.rights.reduce(function (acc, a) { return M.concat(acc, f(a)); }, M.empty);\n    return M.concat(M.concat(lefts, f(fa.focus)), rights);\n}; };\n// TODO: add pipeable traverse fp-ts version >= 2.6.3\nvar traverse_ = function (F) {\n    var traverseF = A.array.traverse(F);\n    return function (ta, f) {\n        return F.ap(F.ap(F.map(traverseF(ta.lefts, f), function (lefts) { return function (focus) { return function (rights) { return make(lefts, focus, rights); }; }; }), f(ta.focus)), traverseF(ta.rights, f));\n    };\n};\n// -------------------------------------------------------------------------------------\n// pipeables\n// -------------------------------------------------------------------------------------\n/**\n * @category Functor\n * @since 0.1.18\n */\nexport var map = function (f) { return function (fa) { return map_(fa, f); }; };\n/**\n * @category FunctorWithIndex\n * @since 0.1.18\n */\nexport var mapWithIndex = function (f) { return function (fa) {\n    return mapWithIndex_(fa, f);\n}; };\n/**\n * @category Apply\n * @since 0.1.18\n */\nexport var ap = function (fa) { return function (fab) { return ap_(fab, fa); }; };\n/**\n * @category Apply\n * @since 0.1.18\n */\nexport var apFirst = function (fb) { return function (fa) {\n    return pipe(fa, map(function (a) { return function (_) { return a; }; }), ap(fb));\n}; };\n/**\n * @category Apply\n * @since 0.1.18\n */\nexport var apSecond = function (fb) { return function (fa) {\n    return pipe(fa, map(function () { return function (b) { return b; }; }), ap(fb));\n}; };\n/**\n * @category Applicative\n * @since 0.1.6\n */\nexport var of = function (focus) { return make(A.empty, focus, A.empty); };\n/**\n * @category Extend\n * @since 0.1.18\n */\nexport var extend = function (f) { return function (wa) { return extend_(wa, f); }; };\n/**\n * @category Extend\n * @since 0.1.18\n */\nexport var duplicate = extend(identity);\n/**\n * @category Foldable\n * @since 0.1.18\n */\nexport var foldMap = function (M) { return function (f) { return function (fa) {\n    return foldMap_(M)(fa, f);\n}; }; };\n/**\n * @category Foldable\n * @since 0.1.18\n */\nexport var reduce = function (b, f) { return function (fa) { return reduce_(fa, b, f); }; };\n/**\n * @category Foldable\n * @since 0.1.18\n */\nexport var reduceRight = function (b, f) { return function (fa) {\n    return reduceRight_(fa, b, f);\n}; };\n/**\n * @category Traversable\n * @since 0.1.18\n */\nexport var sequence = function (F) {\n    var sequenceF = A.array.sequence(F);\n    return function (ta) {\n        return F.ap(F.ap(F.map(sequenceF(ta.lefts), function (lefts) { return function (focus) { return function (rights) { return make(lefts, focus, rights); }; }; }), ta.focus), sequenceF(ta.rights));\n    };\n};\n/**\n * @category Comonad\n * @since 0.1.18\n */\nexport var extract = function (fa) { return fa.focus; };\n// -------------------------------------------------------------------------------------\n// instances\n// -------------------------------------------------------------------------------------\n/**\n * @category instances\n * @since 0.1.6\n */\nexport var URI = 'Zipper';\n/**\n * @category instances\n * @since 0.1.6\n */\nexport var getShow = function (S) {\n    var SA = A.getShow(S);\n    return {\n        show: function (fa) { return \"Zipper(\" + SA.show(fa.lefts) + \", \" + S.show(fa.focus) + \", \" + SA.show(fa.rights) + \")\"; }\n    };\n};\n/**\n * @category instances\n * @since 0.1.6\n */\nexport var getSemigroup = function (S) { return ({\n    concat: function (x, y) { return make(x.lefts.concat(y.lefts), S.concat(x.focus, y.focus), x.rights.concat(y.rights)); }\n}); };\n/**\n * @category instances\n * @since 0.1.6\n */\nexport var getMonoid = function (M) { return (__assign(__assign({}, getSemigroup(M)), { empty: make(A.empty, M.empty, A.empty) })); };\n/**\n * @category instances\n * @since 0.1.18\n */\nexport var Functor = {\n    URI: URI,\n    map: map_\n};\n/**\n * @category instances\n * @since 0.1.18\n */\nexport var FunctorWithIndex = {\n    URI: URI,\n    map: map_,\n    mapWithIndex: mapWithIndex_\n};\n/**\n * @category instances\n * @since 0.1.18\n */\nexport var Applicative = {\n    URI: URI,\n    map: map_,\n    ap: ap_,\n    of: of\n};\n/**\n * @category instances\n * @since 0.1.18\n */\nexport var Apply = {\n    URI: URI,\n    map: map_,\n    ap: ap_\n};\n/**\n * @category instances\n * @since 0.1.18\n */\nexport var Foldable = {\n    URI: URI,\n    foldMap: foldMap_,\n    reduce: reduce_,\n    reduceRight: reduceRight_\n};\n/**\n * @category instances\n * @since 0.1.18\n */\nexport var Traversable = {\n    URI: URI,\n    map: map_,\n    foldMap: foldMap_,\n    reduce: reduce_,\n    reduceRight: reduceRight_,\n    traverse: traverse_,\n    sequence: sequence\n};\n/**\n * @category instances\n * @since 0.1.18\n */\nexport var Comonad = {\n    URI: URI,\n    map: map_,\n    extend: extend_,\n    extract: extract\n};\n/**\n * @category instances\n * @since 0.1.6\n */\nexport var zipper = {\n    URI: URI,\n    map: map_,\n    of: of,\n    ap: ap_,\n    extend: extend_,\n    extract: extract,\n    reduce: reduce_,\n    reduceRight: reduceRight_,\n    foldMap: foldMap_,\n    traverse: traverse_,\n    sequence: sequence,\n    mapWithIndex: mapWithIndex_\n};\n","import { pipe } from './function';\n// -------------------------------------------------------------------------------------\n// constructors\n// -------------------------------------------------------------------------------------\n/**\n * @category constructors\n * @since 2.0.0\n */\nexport function fromEquals(equals) {\n    return {\n        equals: function (x, y) { return x === y || equals(x, y); }\n    };\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 fromEquals(function (x, y) { return fa.equals(f(x), f(y)); });\n}; };\n// -------------------------------------------------------------------------------------\n// instances\n// -------------------------------------------------------------------------------------\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var URI = 'Eq';\n/**\n * @category instances\n * @since 2.5.0\n */\nexport var eqStrict = {\n    // tslint:disable-next-line: deprecation\n    equals: strictEqual\n};\n/**\n * Use `eqStrict` instead\n *\n * @since 2.0.0\n * @deprecated\n */\nexport function strictEqual(a, b) {\n    return a === b;\n}\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var eqString = eqStrict;\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var eqNumber = eqStrict;\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var eqBoolean = eqStrict;\n/**\n * @category instances\n * @since 2.0.0\n */\nexport function getStructEq(eqs) {\n    return fromEquals(function (x, y) {\n        for (var k in eqs) {\n            if (!eqs[k].equals(x[k], y[k])) {\n                return false;\n            }\n        }\n        return true;\n    });\n}\n/**\n * Given a tuple of `Eq`s returns a `Eq` for the tuple\n *\n * @example\n * import { getTupleEq, eqString, eqNumber, eqBoolean } from 'fp-ts/Eq'\n *\n * const E = getTupleEq(eqString, eqNumber, eqBoolean)\n * assert.strictEqual(E.equals(['a', 1, true], ['a', 1, true]), true)\n * assert.strictEqual(E.equals(['a', 1, true], ['b', 1, true]), false)\n * assert.strictEqual(E.equals(['a', 1, true], ['a', 2, true]), false)\n * assert.strictEqual(E.equals(['a', 1, true], ['a', 1, false]), false)\n *\n * @category instances\n * @since 2.0.0\n */\nexport function getTupleEq() {\n    var eqs = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        eqs[_i] = arguments[_i];\n    }\n    return fromEquals(function (x, y) { return eqs.every(function (E, i) { return E.equals(x[i], y[i]); }); });\n}\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var eqDate = {\n    equals: function (x, y) { return x.valueOf() === y.valueOf(); }\n};\nvar empty = {\n    equals: function () { return true; }\n};\n/**\n * @category instances\n * @since 2.6.0\n */\nexport function getMonoid() {\n    return {\n        concat: function (x, y) { return fromEquals(function (a, b) { return x.equals(a, b) && y.equals(a, b); }); },\n        empty: empty\n    };\n}\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 eq = Contravariant;\n","import { either } from 'fp-ts/es6/Either';\nimport { identity, tuple } from 'fp-ts/es6/function';\nimport { fromEither, fromNullable, isNone, none, option, some } from 'fp-ts/es6/Option';\nimport { pipe, pipeable } from 'fp-ts/es6/pipeable';\nimport { filter, isEmpty } from 'fp-ts/es6/Record';\nimport { failure, Int, string, success, Type } from 'io-ts';\nimport { stringify } from 'querystring';\nimport { parse as parseUrl } from 'url';\n/**\n * @category routes\n * @since 0.4.0\n */\nvar Route = /** @class */ (function () {\n    function Route(parts, query) {\n        this.parts = parts;\n        this.query = query;\n    }\n    /**\n     * @since 0.4.0\n     */\n    Route.isEmpty = function (r) {\n        return r.parts.length === 0 && isEmpty(r.query);\n    };\n    /**\n     * @since 0.4.0\n     */\n    Route.parse = function (s, decode) {\n        if (decode === void 0) { decode = true; }\n        var route = parseUrl(s, true);\n        var oparts = option.map(fromNullable(route.pathname), function (s) {\n            var r = s.split('/').filter(Boolean);\n            return decode ? r.map(decodeURIComponent) : r;\n        });\n        var parts = isNone(oparts) ? [] : oparts.value;\n        return new Route(parts, Object.assign({}, route.query));\n    };\n    /**\n     * @since 0.4.0\n     */\n    Route.prototype.toString = function (encode) {\n        if (encode === void 0) { encode = true; }\n        var nonUndefinedQuery = pipe(this.query, filter(function (value) { return value !== undefined; }));\n        var qs = stringify(nonUndefinedQuery);\n        var parts = encode ? this.parts.map(encodeURIComponent) : this.parts;\n        return '/' + parts.join('/') + (qs ? '?' + qs : '');\n    };\n    /**\n     * @since 0.4.0\n     */\n    Route.empty = new Route([], {});\n    return Route;\n}());\nexport { Route };\nvar assign = function (a) { return function (b) { return Object.assign({}, a, b); }; };\nvar PARSER_URI = 'fp-ts-routing/Parser';\n/**\n * @category parsers\n * @since 0.4.0\n */\nvar Parser = /** @class */ (function () {\n    function Parser(run) {\n        this.run = run;\n    }\n    /**\n     * @since 0.4.0\n     */\n    Parser.of = function (a) {\n        return new Parser(function (s) { return some(tuple(a, s)); });\n    };\n    /**\n     * @since 0.4.0\n     */\n    Parser.prototype.map = function (f) {\n        return this.chain(function (a) { return Parser.of(f(a)); }); // <= derived\n    };\n    /**\n     * @since 0.4.0\n     */\n    Parser.prototype.ap = function (fab) {\n        var _this = this;\n        return fab.chain(function (f) { return _this.map(f); }); // <= derived\n    };\n    /**\n     * @since 0.4.0\n     */\n    Parser.prototype.chain = function (f) {\n        var _this = this;\n        return new Parser(function (r) { return option.chain(_this.run(r), function (_a) {\n            var a = _a[0], r2 = _a[1];\n            return f(a).run(r2);\n        }); });\n    };\n    /**\n     * @since 0.4.0\n     */\n    Parser.prototype.alt = function (that) {\n        var _this = this;\n        return new Parser(function (r) {\n            var oar = _this.run(r);\n            return isNone(oar) ? that.run(r) : oar;\n        });\n    };\n    /**\n     * @since 0.4.0\n     */\n    Parser.prototype.then = function (that) {\n        return that.ap(this.map(assign));\n    };\n    return Parser;\n}());\nexport { Parser };\n/**\n * @category parsers\n * @since 0.4.0\n */\nexport function zero() {\n    return new Parser(function () { return none; });\n}\n/**\n * @category parsers\n * @since 0.4.0\n */\nexport function parse(parser, r, a) {\n    var oa = option.map(parser.run(r), function (_a) {\n        var a = _a[0];\n        return a;\n    });\n    return isNone(oa) ? a : oa.value;\n}\n/**\n * @category parsers\n * @since 0.5.1\n */\nexport var getParserMonoid = function () { return ({\n    concat: function (x, y) { return x.alt(y); },\n    empty: zero()\n}); };\n/**\n * @category parsers\n * @since 0.5.1\n */\nexport var parser = {\n    URI: PARSER_URI,\n    map: function (ma, f) { return ma.map(f); },\n    of: Parser.of,\n    ap: function (mab, ma) { return ma.ap(mab); },\n    chain: function (ma, f) { return ma.chain(f); },\n    alt: function (fx, f) {\n        return new Parser(function (r) {\n            var oar = fx.run(r);\n            return isNone(oar) ? f().run(r) : oar;\n        });\n    },\n    zero: zero\n};\nvar _a = pipeable(parser), alt = _a.alt, ap = _a.ap, apFirst = _a.apFirst, apSecond = _a.apSecond, chain = _a.chain, chainFirst = _a.chainFirst, flatten = _a.flatten, map = _a.map;\nexport { \n/**\n * @category parsers\n * @since 0.5.1\n */\nalt, \n/**\n * @category parsers\n * @since 0.5.1\n */\nap, \n/**\n * @category parsers\n * @since 0.5.1\n */\napFirst, \n/**\n * @category parsers\n * @since 0.5.1\n */\napSecond, \n/**\n * @category parsers\n * @since 0.5.1\n */\nchain, \n/**\n * @category parsers\n * @since 0.5.1\n */\nchainFirst, \n/**\n * @category parsers\n * @since 0.5.1\n */\nflatten, \n/**\n * @category parsers\n * @since 0.5.1\n */\nmap };\n/**\n * @category formatters\n * @since 0.4.0\n */\nvar Formatter = /** @class */ (function () {\n    function Formatter(run) {\n        this.run = run;\n    }\n    /**\n     * @since 0.4.0\n     */\n    Formatter.prototype.contramap = function (f) {\n        var _this = this;\n        return new Formatter(function (r, b) { return _this.run(r, f(b)); });\n    };\n    /**\n     * @since 0.4.0\n     */\n    Formatter.prototype.then = function (that) {\n        var _this = this;\n        return new Formatter(function (r, ab) { return that.run(_this.run(r, ab), ab); });\n    };\n    return Formatter;\n}());\nexport { Formatter };\n/**\n * @category formatters\n * @since 0.4.0\n */\nexport function format(formatter, a, encode) {\n    if (encode === void 0) { encode = true; }\n    return formatter.run(Route.empty, a).toString(encode);\n}\nvar FORMATTER_URI = 'fp-ts-routing/Formatter';\n/**\n * @category formatters\n * @since 0.5.1\n */\nexport var formatter = {\n    URI: FORMATTER_URI,\n    contramap: function (fa, f) { return fa.contramap(f); }\n};\nvar contramap = pipeable(formatter).contramap;\nexport { \n/**\n * @category formatters\n * @since 0.5.1\n */\ncontramap };\n/**\n * @category matchers\n * @since 0.4.0\n */\nvar Match = /** @class */ (function () {\n    function Match(parser, formatter) {\n        this.parser = parser;\n        this.formatter = formatter;\n    }\n    /**\n     * @since 0.4.0\n     */\n    Match.prototype.imap = function (f, g) {\n        return new Match(this.parser.map(f), this.formatter.contramap(g));\n    };\n    /**\n     * @since 0.4.0\n     */\n    Match.prototype.then = function (that) {\n        var p = this.parser.then(that.parser);\n        var f = this.formatter.then(that.formatter);\n        return new Match(p, f);\n    };\n    return Match;\n}());\nexport { Match };\n/**\n * @category matchers\n * @since 0.5.1\n */\nexport function imap(f, g) {\n    return function (ma) { return ma.imap(f, g); };\n}\n/**\n * @category matchers\n * @since 0.5.1\n */\nexport function then(mb) {\n    return function (ma) { return ma.then(mb); };\n}\nvar singleton = function (k, v) {\n    var _a;\n    return (_a = {}, _a[k] = v, _a);\n};\n/**\n * `succeed` matches everything but consumes nothing\n *\n * @category matchers\n * @since 0.4.0\n */\nexport function succeed(a) {\n    return new Match(new Parser(function (r) { return some(tuple(a, r)); }), new Formatter(identity));\n}\n/**\n * `end` matches the end of a route\n *\n * @category matchers\n * @since 0.4.0\n */\nexport var end = new Match(new Parser(function (r) { return (Route.isEmpty(r) ? some(tuple({}, r)) : none); }), new Formatter(identity));\n/**\n * `type` matches any io-ts type path component\n *\n * @example\n * import * as t from 'io-ts'\n * import { lit, type, Route } from 'fp-ts-routing'\n * import { some, none } from 'fp-ts/es6/Option'\n *\n * const T = t.keyof({\n *   a: null,\n *   b: null\n * })\n *\n * const match = lit('search').then(type('topic', T))\n *\n * assert.deepStrictEqual(match.parser.run(Route.parse('/search/a')), some([{ topic: 'a' }, Route.empty]))\n * assert.deepStrictEqual(match.parser.run(Route.parse('/search/b')), some([{ topic: 'b' }, Route.empty]))\n * assert.deepStrictEqual(match.parser.run(Route.parse('/search/')), none)\n *\n * @category matchers\n * @since 0.4.0\n */\nexport function type(k, type) {\n    return new Match(new Parser(function (r) {\n        if (r.parts.length === 0) {\n            return none;\n        }\n        else {\n            var head = r.parts[0];\n            var tail_1 = r.parts.slice(1);\n            return option.map(fromEither(type.decode(head)), function (a) { return tuple(singleton(k, a), new Route(tail_1, r.query)); });\n        }\n    }), new Formatter(function (r, o) { return new Route(r.parts.concat(type.encode(o[k])), r.query); }));\n}\n/**\n * `str` matches any string path component\n *\n * @example\n * import { str, Route } from 'fp-ts-routing'\n * import { some, none } from 'fp-ts/es6/Option'\n *\n * assert.deepStrictEqual(str('id').parser.run(Route.parse('/abc')), some([{ id: 'abc' }, new Route([], {})]))\n * assert.deepStrictEqual(str('id').parser.run(Route.parse('/')), none)\n *\n * @category matchers\n * @since 0.4.0\n */\nexport function str(k) {\n    return type(k, string);\n}\n/**\n * @internal\n */\nexport var IntegerFromString = new Type('IntegerFromString', function (u) { return Int.is(u); }, function (u, c) {\n    return either.chain(string.validate(u, c), function (s) {\n        var n = +s;\n        return isNaN(n) || !Number.isInteger(n) ? failure(s, c) : success(n);\n    });\n}, String);\n/**\n * `int` matches any integer path component\n *\n * @example\n * import { int, Route } from 'fp-ts-routing'\n * import { some, none } from 'fp-ts/es6/Option'\n *\n * assert.deepStrictEqual(int('id').parser.run(Route.parse('/1')), some([{ id: 1 }, new Route([], {})]))\n * assert.deepStrictEqual(int('id').parser.run(Route.parse('/a')), none)\n *\n * @category matchers\n * @since 0.4.0\n */\nexport function int(k) {\n    return type(k, IntegerFromString);\n}\n/**\n * `lit(x)` will match exactly the path component `x`\n *\n * @example\n * import { lit, Route } from 'fp-ts-routing'\n * import { some, none } from 'fp-ts/es6/Option'\n *\n * assert.deepStrictEqual(lit('subview').parser.run(Route.parse('/subview/')), some([{}, new Route([], {})]))\n * assert.deepStrictEqual(lit('subview').parser.run(Route.parse('/')), none)\n *\n * @category matchers\n * @since 0.4.0\n */\nexport function lit(literal) {\n    return new Match(new Parser(function (r) {\n        if (r.parts.length === 0) {\n            return none;\n        }\n        else {\n            var head = r.parts[0];\n            var tail = r.parts.slice(1);\n            return head === literal ? some(tuple({}, new Route(tail, r.query))) : none;\n        }\n    }), new Formatter(function (r) { return new Route(r.parts.concat(literal), r.query); }));\n}\n/**\n * Will match a querystring.\n *\n *\n * **Note**. Use `io-ts`'s `strict` instead of `type` otherwise excess properties won't be removed.\n *\n * @example\n * import * as t from 'io-ts'\n * import { lit, str, query, Route } from 'fp-ts-routing'\n *\n * const route = lit('accounts')\n *   .then(str('accountId'))\n *   .then(lit('files'))\n *   .then(query(t.strict({ pathparam: t.string })))\n *   .formatter.run(Route.empty, { accountId: 'testId', pathparam: '123' })\n *   .toString()\n * assert.strictEqual(route, '/accounts/testId/files?pathparam=123')\n *\n * @category matchers\n * @since 0.4.0\n */\nexport function query(type) {\n    return new Match(new Parser(function (r) { return option.map(fromEither(type.decode(r.query)), function (query) { return tuple(query, new Route(r.parts, {})); }); }), new Formatter(function (r, query) { return new Route(r.parts, type.encode(query)); }));\n}\n","import { tuple } from './function';\nfunction curried(f, n, acc) {\n    return function (x) {\n        var combined = Array(acc.length + 1);\n        for (var i = 0; i < acc.length; i++) {\n            combined[i] = acc[i];\n        }\n        combined[acc.length] = x;\n        return n === 0 ? f.apply(null, combined) : curried(f, n - 1, combined);\n    };\n}\nvar tupleConstructors = {\n    1: function (a) { return [a]; },\n    2: function (a) { return function (b) { return [a, b]; }; },\n    3: function (a) { return function (b) { return function (c) { return [a, b, c]; }; }; },\n    4: function (a) { return function (b) { return function (c) { return function (d) { return [a, b, c, d]; }; }; }; },\n    5: function (a) { return function (b) { return function (c) { return function (d) { return function (e) { return [a, b, c, d, e]; }; }; }; }; }\n};\nfunction getTupleConstructor(len) {\n    if (!tupleConstructors.hasOwnProperty(len)) {\n        tupleConstructors[len] = curried(tuple, len - 1, []);\n    }\n    return tupleConstructors[len];\n}\nexport function sequenceT(F) {\n    return function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        var len = args.length;\n        var f = getTupleConstructor(len);\n        var fas = F.map(args[0], f);\n        for (var i = 1; i < len; i++) {\n            fas = F.ap(fas, args[i]);\n        }\n        return fas;\n    };\n}\nfunction getRecordConstructor(keys) {\n    var len = keys.length;\n    switch (len) {\n        case 1:\n            return function (a) {\n                var _a;\n                return (_a = {}, _a[keys[0]] = a, _a);\n            };\n        case 2:\n            return function (a) { return function (b) {\n                var _a;\n                return (_a = {}, _a[keys[0]] = a, _a[keys[1]] = b, _a);\n            }; };\n        case 3:\n            return function (a) { return function (b) { return function (c) {\n                var _a;\n                return (_a = {}, _a[keys[0]] = a, _a[keys[1]] = b, _a[keys[2]] = c, _a);\n            }; }; };\n        case 4:\n            return function (a) { return function (b) { return function (c) { return function (d) {\n                var _a;\n                return (_a = {},\n                    _a[keys[0]] = a,\n                    _a[keys[1]] = b,\n                    _a[keys[2]] = c,\n                    _a[keys[3]] = d,\n                    _a);\n            }; }; }; };\n        case 5:\n            return function (a) { return function (b) { return function (c) { return function (d) { return function (e) {\n                var _a;\n                return (_a = {},\n                    _a[keys[0]] = a,\n                    _a[keys[1]] = b,\n                    _a[keys[2]] = c,\n                    _a[keys[3]] = d,\n                    _a[keys[4]] = e,\n                    _a);\n            }; }; }; }; };\n        default:\n            return curried(function () {\n                var args = [];\n                for (var _i = 0; _i < arguments.length; _i++) {\n                    args[_i] = arguments[_i];\n                }\n                var r = {};\n                for (var i = 0; i < len; i++) {\n                    r[keys[i]] = args[i];\n                }\n                return r;\n            }, len - 1, []);\n    }\n}\nexport function sequenceS(F) {\n    return function (r) {\n        var keys = Object.keys(r);\n        var len = keys.length;\n        var f = getRecordConstructor(keys);\n        var fr = F.map(r[keys[0]], f);\n        for (var i = 1; i < len; i++) {\n            fr = F.ap(fr, r[keys[i]]);\n        }\n        return fr;\n    };\n}\n/* tslint:enable:readonly-array */\n","import * as RA from './ReadonlyArray';\n// -------------------------------------------------------------------------------------\n// model\n// -------------------------------------------------------------------------------------\n/* tslint:disable:readonly-array */\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var getShow = RA.getShow;\n/**\n * Returns a `Monoid` for `Array<A>`\n *\n * @example\n * import { getMonoid } from 'fp-ts/Array'\n *\n * const M = getMonoid<number>()\n * assert.deepStrictEqual(M.concat([1, 2], [3, 4]), [1, 2, 3, 4])\n *\n * @category instances\n * @since 2.0.0\n */\nexport var getMonoid = RA.getMonoid;\n/**\n * Derives an `Eq` over the `Array` of a given element type from the `Eq` of that type. The derived `Eq` defines two\n * arrays as equal if all elements of both arrays are compared equal pairwise with the given `E`. In case of arrays of\n * different lengths, the result is non equality.\n *\n * @example\n * import { eqString } from 'fp-ts/Eq'\n * import { getEq } from 'fp-ts/Array'\n *\n * const E = getEq(eqString)\n * assert.strictEqual(E.equals(['a', 'b'], ['a', 'b']), true)\n * assert.strictEqual(E.equals(['a'], []), false)\n *\n * @category instances\n * @since 2.0.0\n */\nexport var getEq = RA.getEq;\n/**\n * Derives an `Ord` over the `Array` of a given element type from the `Ord` of that type. The ordering between two such\n * arrays is equal to: the first non equal comparison of each arrays elements taken pairwise in increasing order, in\n * case of equality over all the pairwise elements; the longest array is considered the greatest, if both arrays have\n * the same length, the result is equality.\n *\n * @example\n * import { getOrd } from 'fp-ts/Array'\n * import { ordString } from 'fp-ts/Ord'\n *\n * const O = getOrd(ordString)\n * assert.strictEqual(O.compare(['b'], ['a']), 1)\n * assert.strictEqual(O.compare(['a'], ['a']), 0)\n * assert.strictEqual(O.compare(['a'], ['b']), -1)\n *\n * @category instances\n * @since 2.0.0\n */\nexport var getOrd = RA.getOrd;\n// -------------------------------------------------------------------------------------\n// constructors\n// -------------------------------------------------------------------------------------\n/**\n * Return a list of length `n` with element `i` initialized with `f(i)`\n *\n * @example\n * import { makeBy } from 'fp-ts/Array'\n *\n * const double = (n: number): number => n * 2\n * assert.deepStrictEqual(makeBy(5, double), [0, 2, 4, 6, 8])\n *\n * @category constructors\n * @since 2.0.0\n */\nexport var makeBy = RA.makeBy;\n/**\n * Create an array containing a range of integers, including both endpoints\n *\n * @example\n * import { range } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(range(1, 5), [1, 2, 3, 4, 5])\n *\n * @category constructors\n * @since 2.0.0\n */\nexport var range = RA.range;\n/**\n * Create an array containing a value repeated the specified number of times\n *\n * @example\n * import { replicate } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(replicate(3, 'a'), ['a', 'a', 'a'])\n *\n * @category constructors\n * @since 2.0.0\n */\nexport var replicate = RA.replicate;\n/**\n * Removes one level of nesting.\n *\n * Derivable from `Monad`.\n *\n * @example\n * import { flatten } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(flatten([[1], [2], [3]]), [1, 2, 3])\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var flatten = RA.flatten;\n/**\n * Break an array into its first element and remaining elements\n *\n * @example\n * import { foldLeft } from 'fp-ts/Array'\n *\n * const len: <A>(as: Array<A>) => number = foldLeft(() => 0, (_, tail) => 1 + len(tail))\n * assert.strictEqual(len([1, 2, 3]), 3)\n *\n * @category destructors\n * @since 2.0.0\n */\nexport var foldLeft = RA.foldLeft;\n/**\n * Break an array into its initial elements and the last element\n *\n * @category destructors\n * @since 2.0.0\n */\nexport var foldRight = RA.foldRight;\n/**\n * Same as `reduce` but it carries over the intermediate steps\n *\n * @example\n * import { scanLeft } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(scanLeft(10, (b, a: number) => b - a)([1, 2, 3]), [10, 9, 7, 4])\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var scanLeft = RA.scanLeft;\n/**\n * Fold an array from the right, keeping all intermediate results instead of only the final result\n *\n * @example\n * import { scanRight } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(scanRight(10, (a: number, b) => b - a)([1, 2, 3]), [4, 5, 7, 10])\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var scanRight = RA.scanRight;\n/**\n * Test whether an array is empty\n *\n * @example\n * import { isEmpty } from 'fp-ts/Array'\n *\n * assert.strictEqual(isEmpty([]), true)\n *\n * @since 2.0.0\n */\nexport var isEmpty = RA.isEmpty;\n/**\n * Test whether an array is non empty narrowing down the type to `NonEmptyArray<A>`\n *\n * @category guards\n * @since 2.0.0\n */\nexport var isNonEmpty = RA.isNonEmpty;\n/**\n * Test whether an array contains a particular index\n *\n * @since 2.0.0\n */\nexport var isOutOfBound = RA.isOutOfBound;\n// TODO: remove non-curried overloading in v3\n/**\n * This function provides a safe way to read a value at a particular index from an array\n *\n * @example\n * import { lookup } from 'fp-ts/Array'\n * import { some, none } from 'fp-ts/Option'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(pipe([1, 2, 3], lookup(1)), some(2))\n * assert.deepStrictEqual(pipe([1, 2, 3], lookup(3)), none)\n *\n * @since 2.0.0\n */\nexport var lookup = RA.lookup;\n// TODO: remove non-curried overloading in v3\n/**\n * Attaches an element to the front of an array, creating a new non empty array\n *\n * @example\n * import { cons } from 'fp-ts/Array'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(pipe([1, 2, 3], cons(0)), [0, 1, 2, 3])\n *\n * @category constructors\n * @since 2.0.0\n */\nexport var cons = RA.cons;\n// TODO: curry in v3\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/Array'\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 = RA.snoc;\n/**\n * Get the first element in an array, or `None` if the array is empty\n *\n * @example\n * import { head } from 'fp-ts/Array'\n * import { some, none } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(head([1, 2, 3]), some(1))\n * assert.deepStrictEqual(head([]), none)\n *\n * @category destructors\n * @since 2.0.0\n */\nexport var head = RA.head;\n/**\n * Get the last element in an array, or `None` if the array is empty\n *\n * @example\n * import { last } from 'fp-ts/Array'\n * import { some, none } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(last([1, 2, 3]), some(3))\n * assert.deepStrictEqual(last([]), none)\n *\n * @category destructors\n * @since 2.0.0\n */\nexport var last = RA.last;\n/**\n * Get all but the first element of an array, creating a new array, or `None` if the array is empty\n *\n * @example\n * import { tail } from 'fp-ts/Array'\n * import { some, none } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(tail([1, 2, 3]), some([2, 3]))\n * assert.deepStrictEqual(tail([]), none)\n *\n * @category destructors\n * @since 2.0.0\n */\nexport var tail = RA.tail;\n/**\n * Get all but the last element of an array, creating a new array, or `None` if the array is empty\n *\n * @example\n * import { init } from 'fp-ts/Array'\n * import { some, none } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(init([1, 2, 3]), some([1, 2]))\n * assert.deepStrictEqual(init([]), none)\n *\n * @category destructors\n * @since 2.0.0\n */\nexport var init = RA.init;\n/**\n * Keep only a number of elements from the start of an array, creating a new array.\n * `n` must be a natural number\n *\n * @example\n * import { takeLeft } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(takeLeft(2)([1, 2, 3]), [1, 2])\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var takeLeft = RA.takeLeft;\n/**\n * Keep only a number of elements from the end of an array, creating a new array.\n * `n` must be a natural number\n *\n * @example\n * import { takeRight } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(takeRight(2)([1, 2, 3, 4, 5]), [4, 5])\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var takeRight = RA.takeRight;\nexport function takeLeftWhile(predicate) {\n    return RA.takeLeftWhile(predicate);\n}\nexport function spanLeft(predicate) {\n    return RA.spanLeft(predicate);\n}\n/* tslint:enable:readonly-keyword */\n/**\n * Drop a number of elements from the start of an array, creating a new array\n *\n * @example\n * import { dropLeft } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(dropLeft(2)([1, 2, 3]), [3])\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var dropLeft = RA.dropLeft;\n/**\n * Drop a number of elements from the end of an array, creating a new array\n *\n * @example\n * import { dropRight } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(dropRight(2)([1, 2, 3, 4, 5]), [1, 2, 3])\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var dropRight = RA.dropRight;\n/**\n * Remove the longest initial subarray for which all element satisfy the specified predicate, creating a new array\n *\n * @example\n * import { dropLeftWhile } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(dropLeftWhile((n: number) => n % 2 === 1)([1, 3, 2, 4, 5]), [2, 4, 5])\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var dropLeftWhile = RA.dropLeftWhile;\n/**\n * Find the first index for which a predicate holds\n *\n * @example\n * import { findIndex } from 'fp-ts/Array'\n * import { some, none } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(findIndex((n: number) => n === 2)([1, 2, 3]), some(1))\n * assert.deepStrictEqual(findIndex((n: number) => n === 2)([]), none)\n *\n * @since 2.0.0\n */\nexport var findIndex = RA.findIndex;\nexport function findFirst(predicate) {\n    return RA.findFirst(predicate);\n}\n/**\n * Find the first element returned by an option based selector function\n *\n * @example\n * import { findFirstMap } from 'fp-ts/Array'\n * import { some, none } from 'fp-ts/Option'\n *\n * interface Person {\n *   name: string\n *   age?: number\n * }\n *\n * const persons: Array<Person> = [{ name: 'John' }, { name: 'Mary', age: 45 }, { name: 'Joey', age: 28 }]\n *\n * // returns the name of the first person that has an age\n * assert.deepStrictEqual(findFirstMap((p: Person) => (p.age === undefined ? none : some(p.name)))(persons), some('Mary'))\n *\n * @category destructors\n * @since 2.0.0\n */\nexport var findFirstMap = RA.findFirstMap;\nexport function findLast(predicate) {\n    return RA.findLast(predicate);\n}\n/**\n * Find the last element returned by an option based selector function\n *\n * @example\n * import { findLastMap } from 'fp-ts/Array'\n * import { some, none } from 'fp-ts/Option'\n *\n * interface Person {\n *   name: string\n *   age?: number\n * }\n *\n * const persons: Array<Person> = [{ name: 'John' }, { name: 'Mary', age: 45 }, { name: 'Joey', age: 28 }]\n *\n * // returns the name of the last person that has an age\n * assert.deepStrictEqual(findLastMap((p: Person) => (p.age === undefined ? none : some(p.name)))(persons), some('Joey'))\n *\n * @category destructors\n * @since 2.0.0\n */\nexport var findLastMap = RA.findLastMap;\n/**\n * Returns the index of the last element of the list which matches the predicate\n *\n * @example\n * import { findLastIndex } from 'fp-ts/Array'\n * import { some, none } from 'fp-ts/Option'\n *\n * interface X {\n *   a: number\n *   b: number\n * }\n * const xs: Array<X> = [{ a: 1, b: 0 }, { a: 1, b: 1 }]\n * assert.deepStrictEqual(findLastIndex((x: { a: number }) => x.a === 1)(xs), some(1))\n * assert.deepStrictEqual(findLastIndex((x: { a: number }) => x.a === 4)(xs), none)\n *\n *\n * @since 2.0.0\n */\nexport var findLastIndex = RA.findLastIndex;\n/**\n * @category combinators\n * @since 2.0.0\n */\nexport var copy = RA.toArray;\n/**\n * Insert an element at the specified index, creating a new array, or returning `None` if the index is out of bounds\n *\n * @example\n * import { insertAt } from 'fp-ts/Array'\n * import { some } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(insertAt(2, 5)([1, 2, 3, 4]), some([1, 2, 5, 3, 4]))\n *\n * @since 2.0.0\n */\nexport var insertAt = RA.insertAt;\n/**\n * Change the element at the specified index, creating a new array, or returning `None` if the index is out of bounds\n *\n * @example\n * import { updateAt } from 'fp-ts/Array'\n * import { some, none } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(updateAt(1, 1)([1, 2, 3]), some([1, 1, 3]))\n * assert.deepStrictEqual(updateAt(1, 1)([]), none)\n *\n * @since 2.0.0\n */\nexport var updateAt = RA.updateAt;\n/**\n * Delete the element at the specified index, creating a new array, or returning `None` if the index is out of bounds\n *\n * @example\n * import { deleteAt } from 'fp-ts/Array'\n * import { some, none } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(deleteAt(0)([1, 2, 3]), some([2, 3]))\n * assert.deepStrictEqual(deleteAt(1)([]), none)\n *\n * @since 2.0.0\n */\nexport var deleteAt = RA.deleteAt;\n/**\n * Apply a function to the element at the specified index, creating a new array, or returning `None` if the index is out\n * of bounds\n *\n * @example\n * import { modifyAt } from 'fp-ts/Array'\n * import { some, none } from 'fp-ts/Option'\n *\n * const double = (x: number): number => x * 2\n * assert.deepStrictEqual(modifyAt(1, double)([1, 2, 3]), some([1, 4, 3]))\n * assert.deepStrictEqual(modifyAt(1, double)([]), none)\n *\n * @since 2.0.0\n */\nexport var modifyAt = RA.modifyAt;\n/**\n * Reverse an array, creating a new array\n *\n * @example\n * import { reverse } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(reverse([1, 2, 3]), [3, 2, 1])\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var reverse = RA.reverse;\n/**\n * Extracts from an array of `Either` all the `Right` elements. All the `Right` elements are extracted in order\n *\n * @example\n * import { rights } from 'fp-ts/Array'\n * import { right, left } from 'fp-ts/Either'\n *\n * assert.deepStrictEqual(rights([right(1), left('foo'), right(2)]), [1, 2])\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var rights = RA.rights;\n/**\n * Extracts from an array of `Either` all the `Left` elements. All the `Left` elements are extracted in order\n *\n * @example\n * import { lefts } from 'fp-ts/Array'\n * import { left, right } from 'fp-ts/Either'\n *\n * assert.deepStrictEqual(lefts([right(1), left('foo'), right(2)]), ['foo'])\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var lefts = RA.lefts;\n/**\n * Sort the elements of an array in increasing order, creating a new array\n *\n * @example\n * import { sort } from 'fp-ts/Array'\n * import { ordNumber } from 'fp-ts/Ord'\n *\n * assert.deepStrictEqual(sort(ordNumber)([3, 2, 1]), [1, 2, 3])\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var sort = RA.sort;\n/**\n * Apply a function to pairs of elements at the same index in two arrays, collecting the results in a new array. If one\n * input array is short, excess elements of the longer array are discarded.\n *\n * @example\n * import { zipWith } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(zipWith([1, 2, 3], ['a', 'b', 'c', 'd'], (n, s) => s + n), ['a1', 'b2', 'c3'])\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var zipWith = RA.zipWith;\n// TODO: remove non-curried overloading in v3\n/**\n * Takes two arrays and returns an array of corresponding pairs. If one input array is short, excess elements of the\n * longer array are discarded\n *\n * @example\n * import { zip } from 'fp-ts/Array'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(pipe([1, 2, 3], zip(['a', 'b', 'c', 'd'])), [[1, 'a'], [2, 'b'], [3, 'c']])\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var zip = RA.zip;\n/**\n * The function is reverse of `zip`. Takes an array of pairs and return two corresponding arrays\n *\n * @example\n * import { unzip } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(unzip([[1, 'a'], [2, 'b'], [3, 'c']]), [[1, 2, 3], ['a', 'b', 'c']])\n *\n * @since 2.0.0\n */\nexport var unzip = RA.unzip;\n/**\n * Prepend an element to every member of an array\n *\n * @example\n * import { prependToAll } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(prependToAll(9)([1, 2, 3, 4]), [9, 1, 9, 2, 9, 3, 9, 4])\n *\n * @category combinators\n * @since 2.9.0\n */\nexport var prependToAll = RA.prependToAll;\n/**\n * Places an element in between members of an array\n *\n * @example\n * import { intersperse } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(intersperse(9)([1, 2, 3, 4]), [1, 9, 2, 9, 3, 9, 4])\n *\n * @category combinators\n * @since 2.9.0\n */\nexport var intersperse = RA.intersperse;\n/**\n * Rotate an array to the right by `n` steps\n *\n * @example\n * import { rotate } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(rotate(2)([1, 2, 3, 4, 5]), [4, 5, 1, 2, 3])\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var rotate = RA.rotate;\n// TODO: remove non-curried overloading in v3\n/**\n * Test if a value is a member of an array. Takes a `Eq<A>` as a single\n * argument which returns the function to use to search for a value of type `A` in\n * an array of type `Array<A>`.\n *\n * @example\n * import { elem } from 'fp-ts/Array'\n * import { eqNumber } from 'fp-ts/Eq'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.strictEqual(pipe([1, 2, 3], elem(eqNumber)(2)), true)\n * assert.strictEqual(pipe([1, 2, 3], elem(eqNumber)(0)), false)\n *\n * @since 2.0.0\n */\nexport var elem = RA.elem;\n/**\n * Remove duplicates from an array, keeping the first occurrence of an element.\n *\n * @example\n * import { uniq } from 'fp-ts/Array'\n * import { eqNumber } from 'fp-ts/Eq'\n *\n * assert.deepStrictEqual(uniq(eqNumber)([1, 2, 1]), [1, 2])\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var uniq = RA.uniq;\n/**\n * Sort the elements of an array in increasing order, where elements are compared using first `ords[0]`, then `ords[1]`,\n * etc...\n *\n * @example\n * import { sortBy } from 'fp-ts/Array'\n * import { ord, ordString, ordNumber } from 'fp-ts/Ord'\n *\n * interface Person {\n *   name: string\n *   age: number\n * }\n * const byName = ord.contramap(ordString, (p: Person) => p.name)\n * const byAge = ord.contramap(ordNumber, (p: Person) => p.age)\n *\n * const sortByNameByAge = sortBy([byName, byAge])\n *\n * const persons = [{ name: 'a', age: 1 }, { name: 'b', age: 3 }, { name: 'c', age: 2 }, { name: 'b', age: 2 }]\n * assert.deepStrictEqual(sortByNameByAge(persons), [\n *   { name: 'a', age: 1 },\n *   { name: 'b', age: 2 },\n *   { name: 'b', age: 3 },\n *   { name: 'c', age: 2 }\n * ])\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var sortBy = RA.sortBy;\n/**\n * A useful recursion pattern for processing an array to produce a new array, often used for \"chopping\" up the input\n * array. Typically chop is called with some function that will consume an initial prefix of the array and produce a\n * value and the rest of the array.\n *\n * @example\n * import { Eq, eqNumber } from 'fp-ts/Eq'\n * import { chop, spanLeft } from 'fp-ts/Array'\n *\n * const group = <A>(S: Eq<A>): ((as: Array<A>) => Array<Array<A>>) => {\n *   return chop(as => {\n *     const { init, rest } = spanLeft((a: A) => S.equals(a, as[0]))(as)\n *     return [init, rest]\n *   })\n * }\n * assert.deepStrictEqual(group(eqNumber)([1, 1, 2, 3, 3, 4]), [[1, 1], [2], [3, 3], [4]])\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var chop = RA.chop;\n/**\n * Splits an array into two pieces, the first piece has `n` elements.\n *\n * @example\n * import { splitAt } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(splitAt(2)([1, 2, 3, 4, 5]), [[1, 2], [3, 4, 5]])\n *\n * @since 2.0.0\n */\nexport var splitAt = RA.splitAt;\n/**\n * Splits an array into length-`n` pieces. The last piece will be shorter if `n` does not evenly divide the length of\n * the array. Note that `chunksOf(n)([])` is `[]`, not `[[]]`. This is intentional, and is consistent with a recursive\n * definition of `chunksOf`; it satisfies the property that\n *\n * ```ts\n * chunksOf(n)(xs).concat(chunksOf(n)(ys)) == chunksOf(n)(xs.concat(ys)))\n * ```\n *\n * whenever `n` evenly divides the length of `xs`.\n *\n * @example\n * import { chunksOf } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(chunksOf(2)([1, 2, 3, 4, 5]), [[1, 2], [3, 4], [5]])\n *\n * @since 2.0.0\n */\nexport var chunksOf = RA.chunksOf;\nexport function comprehension(input, f, g) {\n    if (g === void 0) { g = function () { return true; }; }\n    return RA.comprehension(input, f, g);\n}\n// TODO: remove non-curried overloading in v3\n/**\n * Creates an array of unique values, in order, from all given arrays using a `Eq` for equality comparisons\n *\n * @example\n * import { union } from 'fp-ts/Array'\n * import { eqNumber } from 'fp-ts/Eq'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(pipe([1, 2], union(eqNumber)([2, 3])), [1, 2, 3])\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var union = RA.union;\n// TODO: remove non-curried overloading in v3\n/**\n * Creates an array of unique values that are included in all given arrays using a `Eq` for equality\n * comparisons. The order and references of result values are determined by the first array.\n *\n * @example\n * import { intersection } from 'fp-ts/Array'\n * import { eqNumber } from 'fp-ts/Eq'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(pipe([1, 2], intersection(eqNumber)([2, 3])), [2])\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var intersection = RA.intersection;\n// TODO: remove non-curried overloading in v3\n/**\n * Creates an array of array values not included in the other given array using a `Eq` for equality\n * comparisons. The order and references of result values are determined by the first array.\n *\n * @example\n * import { difference } from 'fp-ts/Array'\n * import { eqNumber } from 'fp-ts/Eq'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(pipe([1, 2], difference(eqNumber)([2, 3])), [1])\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var difference = RA.difference;\n/**\n * Wrap a value into the type constructor.\n *\n * @category Applicative\n * @since 2.0.0\n */\nexport var of = RA.of;\n// -------------------------------------------------------------------------------------\n// non-pipeables\n// -------------------------------------------------------------------------------------\nvar map_ = RA.Monad.map;\nvar ap_ = RA.Monad.ap;\nvar chain_ = RA.Monad.chain;\nvar mapWithIndex_ = RA.FunctorWithIndex.mapWithIndex;\nvar filter_ = RA.Filterable.filter;\nvar filterMap_ = RA.Filterable.filterMap;\nvar partition_ = RA.Filterable.partition;\nvar partitionMap_ = RA.Filterable.partitionMap;\nvar filterWithIndex_ = RA.FilterableWithIndex\n    .filterWithIndex;\nvar filterMapWithIndex_ = RA.FilterableWithIndex\n    .filterMapWithIndex;\nvar partitionWithIndex_ = RA.FilterableWithIndex\n    .partitionWithIndex;\nvar partitionMapWithIndex_ = RA.FilterableWithIndex\n    .partitionMapWithIndex;\nvar reduce_ = RA.Foldable.reduce;\nvar foldMap_ = RA.Foldable.foldMap;\nvar reduceRight_ = RA.Foldable.reduceRight;\nvar traverse_ = RA.Traversable.traverse;\nvar alt_ = RA.Alternative.alt;\nvar reduceWithIndex_ = RA.FoldableWithIndex.reduceWithIndex;\nvar foldMapWithIndex_ = RA.FoldableWithIndex.foldMapWithIndex;\nvar reduceRightWithIndex_ = RA.FoldableWithIndex.reduceRightWithIndex;\nvar traverseWithIndex_ = RA.TraversableWithIndex\n    .traverseWithIndex;\nvar extend_ = RA.Extend.extend;\nvar wither_ = RA.Witherable.wither;\nvar wilt_ = RA.Witherable.wilt;\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 = RA.map;\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 = RA.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 = RA.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 = RA.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 = RA.chain;\n/**\n * @since 2.7.0\n */\nexport var chainWithIndex = RA.chainWithIndex;\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 = RA.chainFirst;\n/**\n * @category FunctorWithIndex\n * @since 2.0.0\n */\nexport var mapWithIndex = RA.mapWithIndex;\n/**\n * @category Compactable\n * @since 2.0.0\n */\nexport var compact = RA.compact;\n/**\n * @category Compactable\n * @since 2.0.0\n */\nexport var separate = RA.separate;\n/**\n * @category Filterable\n * @since 2.0.0\n */\nexport var filter = RA.filter;\n/**\n * @category Filterable\n * @since 2.0.0\n */\nexport var filterMap = RA.filterMap;\n/**\n * @category Filterable\n * @since 2.0.0\n */\nexport var partition = RA.partition;\n/**\n * @category FilterableWithIndex\n * @since 2.0.0\n */\nexport var partitionWithIndex = RA.partitionWithIndex;\n/**\n * @category Filterable\n * @since 2.0.0\n */\nexport var partitionMap = RA.partitionMap;\n/**\n * @category FilterableWithIndex\n * @since 2.0.0\n */\nexport var partitionMapWithIndex = RA.partitionMapWithIndex;\n/**\n * Less strict version of [`alt`](#alt).\n *\n * @category Alt\n * @since 2.9.0\n */\nexport var altW = RA.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.0.0\n */\nexport var alt = RA.alt;\n/**\n * @category FilterableWithIndex\n * @since 2.0.0\n */\nexport var filterMapWithIndex = RA.filterMapWithIndex;\n/**\n * @category FilterableWithIndex\n * @since 2.0.0\n */\nexport var filterWithIndex = RA.filterWithIndex;\n/**\n * @category Extend\n * @since 2.0.0\n */\nexport var extend = RA.extend;\n/**\n * Derivable from `Extend`.\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var duplicate = RA.duplicate;\n/**\n * @category Foldable\n * @since 2.0.0\n */\nexport var foldMap = RA.foldMap;\n/**\n * @category FoldableWithIndex\n * @since 2.0.0\n */\nexport var foldMapWithIndex = RA.foldMapWithIndex;\n/**\n * @category Foldable\n * @since 2.0.0\n */\nexport var reduce = RA.reduce;\n/**\n * @category FoldableWithIndex\n * @since 2.0.0\n */\nexport var reduceWithIndex = RA.reduceWithIndex;\n/**\n * @category Foldable\n * @since 2.0.0\n */\nexport var reduceRight = RA.reduceRight;\n/**\n * @category FoldableWithIndex\n * @since 2.0.0\n */\nexport var reduceRightWithIndex = RA.reduceRightWithIndex;\n/**\n * **for optimized and stack safe version check the data types `traverseArray` function**\n * @category Traversable\n * @since 2.6.3\n */\nexport var traverse = RA.traverse;\n/**\n * **for optimized and stack safe version check the data types `sequenceArray` function**\n * @category Traversable\n * @since 2.6.3\n */\nexport var sequence = RA.sequence;\n/**\n * **for optimized and stack safe version check the data types `traverseArrayWithIndex` function**\n * @category TraversableWithIndex\n * @since 2.6.3\n */\nexport var traverseWithIndex = RA.traverseWithIndex;\n/**\n * @category Witherable\n * @since 2.6.5\n */\nexport var wither = RA.wither;\n/**\n * @category Witherable\n * @since 2.6.5\n */\nexport var wilt = RA.wilt;\n/**\n * @category Unfoldable\n * @since 2.6.6\n */\nexport var unfold = RA.unfold;\n/**\n * @category Alternative\n * @since 2.7.0\n */\nexport var zero = RA.Alternative.zero;\n// -------------------------------------------------------------------------------------\n// instances\n// -------------------------------------------------------------------------------------\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var URI = 'Array';\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 Unfoldable = {\n    URI: URI,\n    unfold: unfold\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 FilterableWithIndex = {\n    URI: URI,\n    map: map_,\n    mapWithIndex: mapWithIndex_,\n    compact: compact,\n    separate: separate,\n    filter: filter_,\n    filterMap: filterMap_,\n    partition: partition_,\n    partitionMap: partitionMap_,\n    partitionMapWithIndex: partitionMapWithIndex_,\n    partitionWithIndex: partitionWithIndex_,\n    filterMapWithIndex: filterMapWithIndex_,\n    filterWithIndex: filterWithIndex_\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    reduceWithIndex: reduceWithIndex_,\n    foldMapWithIndex: foldMapWithIndex_,\n    reduceRightWithIndex: reduceRightWithIndex_,\n    traverse: traverse_,\n    sequence: sequence,\n    traverseWithIndex: traverseWithIndex_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Witherable = {\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    reduce: reduce_,\n    foldMap: foldMap_,\n    reduceRight: reduceRight_,\n    traverse: traverse_,\n    sequence: sequence,\n    wither: wither_,\n    wilt: wilt_\n};\n// TODO: remove in v3\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var array = {\n    URI: URI,\n    compact: compact,\n    separate: separate,\n    map: map_,\n    ap: ap_,\n    of: of,\n    chain: chain_,\n    filter: filter_,\n    filterMap: filterMap_,\n    partition: partition_,\n    partitionMap: partitionMap_,\n    mapWithIndex: mapWithIndex_,\n    partitionMapWithIndex: partitionMapWithIndex_,\n    partitionWithIndex: partitionWithIndex_,\n    filterMapWithIndex: filterMapWithIndex_,\n    filterWithIndex: filterWithIndex_,\n    alt: alt_,\n    zero: zero,\n    unfold: unfold,\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    extend: extend_,\n    wither: wither_,\n    wilt: wilt_\n};\n// -------------------------------------------------------------------------------------\n// unsafe\n// -------------------------------------------------------------------------------------\n/**\n * @category unsafe\n * @since 2.0.0\n */\nexport var unsafeInsertAt = RA.unsafeInsertAt;\n/**\n * @category unsafe\n * @since 2.0.0\n */\nexport var unsafeUpdateAt = RA.unsafeUpdateAt;\n/**\n * @category unsafe\n * @since 2.0.0\n */\nexport var unsafeDeleteAt = RA.unsafeDeleteAt;\n// -------------------------------------------------------------------------------------\n// utils\n// -------------------------------------------------------------------------------------\n/**\n * An empty array\n *\n * @since 2.0.0\n */\nexport var empty = [];\n/**\n * @since 2.9.0\n */\nexport var every = RA.every;\n/**\n * @since 2.9.0\n */\nexport var some = RA.some;\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 = RA.bindTo;\n/**\n * @since 2.8.0\n */\nexport var bind = RA.bind;\n// -------------------------------------------------------------------------------------\n// pipeable sequence S\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.8.0\n */\nexport var apS = RA.apS;\n"],"sourceRoot":""}