{"version":3,"sources":["../../node_modules/fp-ts/lib/function.js","../../node_modules/fp-ts/lib/Set.js","../../node_modules/fp-ts/lib/ReadonlySet.js","../../node_modules/fp-ts/lib/Option.js","../../node_modules/fp-ts/lib/ReadonlyArray.js","../../node_modules/fp-ts/lib/Ord.js","../../node_modules/fp-ts/lib/NonEmptyArray.js","../../node_modules/fp-ts/lib/ReadonlyNonEmptyArray.js","../../node_modules/fp-ts/lib/Ordering.js","../../node_modules/fp-ts/lib/Semigroup.js","../../node_modules/fp-ts/lib/pipeable.js"],"names":["identity","a","constant","absurd","_","Error","Object","defineProperty","exports","value","bindTo_","bind_","hole","pipe","untupled","tupled","decrement","increment","tuple","flow","flip","constVoid","constUndefined","constNull","constFalse","constTrue","not","unsafeCoerce","predicate","undefined","f","b","ab","bc","cd","de","ef","fg","gh","hi","ij","arguments","length","apply","this","t","_i","n","jk","kl","lm","mn","no","op","pq","qr","rs","st","name","_a","assign","__createBinding","create","o","m","k","k2","enumerable","get","__setModuleDefault","v","__importStar","mod","__esModule","result","prototype","hasOwnProperty","call","filterMap","separate","compact","fromArray","toggle","remove","insert","singleton","foldMap","reduce","getIntersectionSemigroup","getUnionMonoid","difference","partitionMap","intersection","union","elem","partition","filter","subset","chain","every","map","some","getEq","toArray","empty","getShow","RS","require","Set","toReadonlyArray","isSubset","E","elemE","removeE","insertE","set","toSet","fromSet","Eq_1","function_1","O","x","r","forEach","e","push","sort","compare","values","found","next","done","me","that","isSubsetE_1","add","elemE_1","equals","unionE_1","intersectionE_1","fa","ob","_tag","s","S","show","elements","substring","subsetE","fromEquals","y","right","left","EB","EC","hasB","hasC","differenceE_1","concat","toArrayO","M","ax","as","len","has","i","EE","EA","elemEE","elemEA","getApplySemigroup","getOrd","URI","wilt","wither","sequence","traverse","reduceRight","duplicate","extend","throwError","zero","alt","altW","flatten","chainFirst","of","apSecond","apFirst","ap","chainNullableK","mapNullable","fromNullableK","getOrElse","getOrElseW","toUndefined","toNullable","fold","fromEither","getRight","getLeft","tryCatch","fromPredicate","fromNullable","none","isNone","isSome","sequenceArray","traverseArray","traverseArrayWithIndex","apS","bind","bindTo","Do","getRefinement","exists","option","MonadThrow","Witherable","Traversable","Filterable","Compactable","Extend","Alternative","Alt","Foldable","Monad","Applicative","Functor","getMonoid","getLastMonoid","getFirstMonoid","getApplyMonoid","ma","onNone","onSome","map_","ap_","fab","chain_","reduce_","foldMap_","foldMapM","reduceRight_","traverse_","F","traverseF","ta","alt_","filter_","filterMap_","extend_","wa","partition_","partitionMap_","wither_","witherF","wilt_","wiltF","fb","defaultSeparate","getOption","arr","intersperse","prependToAll","unzip","zip","zipWith","lefts","rights","reverse","modifyAt","deleteAt","updateAt","insertAt","findLastIndex","findLastMap","findLast","findFirstMap","findFirst","findIndex","dropLeftWhile","dropRight","dropLeft","spanLeft","takeLeftWhile","takeRight","takeLeft","init","tail","last","head","snoc","cons","lookup","isOutOfBound","isNonEmpty","isEmpty","scanRight","scanLeft","foldRight","foldLeft","replicate","range","makeBy","FunctorWithIndex","unfold","traverseWithIndex","reduceRightWithIndex","reduceWithIndex","foldMapWithIndex","filterWithIndex","partitionMapWithIndex","partitionWithIndex","filterMapWithIndex","mapWithIndex","chainWithIndex","comprehension","chunksOf","splitAt","chop","sortBy","uniq","rotate","unsafeDeleteAt","unsafeUpdateAt","unsafeInsertAt","readonlyArray","TraversableWithIndex","FoldableWithIndex","FilterableWithIndex","Unfoldable","Ord_1","l","ras","Array","join","lenx","leny","end","xs","ys","fromCompare","aLen","bLen","Math","min","ordering","ordNumber","start","mma","rLen","j","onEmpty","onCons","slice","spanIndexUncurry","rest","fc","bs","element","xs_1","abs","elemS","ords","cs","c","input","g","go","scope","mapWithIndex_","partitionWithIndex_","predicateWithIndex","partitionMapWithIndex_","reduceWithIndex_","foldMapWithIndex_","reduceRightWithIndex_","filterMapWithIndex_","filterWithIndex_","traverseWithIndex_","traverseWithIndexF","outLen","temp","out","l_1","fa_1","optionB","foldMapWithIndexM","fas","fbs","splice","ret","bb","mt","b_1","ord","Contravariant","ordDate","contramap","getDualOrd","getTupleOrd","getSemigroup","between","clamp","max","geq","leq","gt","lt","ordBoolean","ordString","Ordering_1","strictEqual","optimizedCompare","monoidOrdering","minO","maxO","low","lessThanO","greaterThanO","date","valueOf","copy","groupBy","groupSort","group","unsnoc","uncons","nonEmptyArray","Comonad","extract","RNEA","nea","fx","fy","fromReadonlyArray","readonlyNonEmptyArray","Option_1","RA","Semigroup_1","getMeetSemigroup","getJoinSemigroup","sortO","groupO","as_1","invert","semigroupOrdering","eqOrdering","sign","getIntercalateSemigroup","semigroupVoid","semigroupString","semigroupProduct","semigroupSum","semigroupAny","semigroupAll","getObjectSemigroup","getStructSemigroup","getFunctionSemigroup","getDualSemigroup","getTupleSemigroup","getLastSemigroup","getFirstSemigroup","startWith","foldS_1","semigroups","keys","key","pipeable","I","isFunctor","isContravariant","isFunctorWithIndex","isApply","isChain","bimap","isBifunctor","mapLeft","isExtend","isFoldable","isFoldableWithIndex","isAlt","isCompactable","isFilterable","isFilterableWithIndex","promap","isProfunctor","compose","isSemigroupoid","isMonadThrow","fromOption","onFalse","filterOrElse"],"mappings":"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","file":"static/js/index~4f36dcf7.fb5f7fa8.chunk.js","sourcesContent":["\"use strict\";\n/**\n * @since 2.0.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.bindTo_ = exports.bind_ = exports.hole = exports.pipe = exports.untupled = exports.tupled = exports.absurd = exports.decrement = exports.increment = exports.tuple = exports.flow = exports.flip = exports.constVoid = exports.constUndefined = exports.constNull = exports.constFalse = exports.constTrue = exports.constant = exports.not = exports.unsafeCoerce = exports.identity = void 0;\n/**\n * @since 2.0.0\n */\nfunction identity(a) {\n    return a;\n}\nexports.identity = identity;\n/**\n * @since 2.0.0\n */\nexports.unsafeCoerce = identity;\n/**\n * @since 2.0.0\n */\nfunction not(predicate) {\n    return function (a) { return !predicate(a); };\n}\nexports.not = not;\n/**\n * @since 2.0.0\n */\nfunction constant(a) {\n    return function () { return a; };\n}\nexports.constant = constant;\n/**\n * A thunk that returns always `true`.\n *\n * @since 2.0.0\n */\nexports.constTrue = \n/*#__PURE__*/\nconstant(true);\n/**\n * A thunk that returns always `false`.\n *\n * @since 2.0.0\n */\nexports.constFalse = \n/*#__PURE__*/\nconstant(false);\n/**\n * A thunk that returns always `null`.\n *\n * @since 2.0.0\n */\nexports.constNull = \n/*#__PURE__*/\nconstant(null);\n/**\n * A thunk that returns always `undefined`.\n *\n * @since 2.0.0\n */\nexports.constUndefined = \n/*#__PURE__*/\nconstant(undefined);\n/**\n * A thunk that returns always `void`.\n *\n * @since 2.0.0\n */\nexports.constVoid = exports.constUndefined;\n// TODO: remove in v3\n/**\n * Flips the order of the arguments of a function of two arguments.\n *\n * @since 2.0.0\n */\nfunction flip(f) {\n    return function (b, a) { return f(a, b); };\n}\nexports.flip = flip;\nfunction flow(ab, bc, cd, de, ef, fg, gh, hi, ij) {\n    switch (arguments.length) {\n        case 1:\n            return ab;\n        case 2:\n            return function () {\n                return bc(ab.apply(this, arguments));\n            };\n        case 3:\n            return function () {\n                return cd(bc(ab.apply(this, arguments)));\n            };\n        case 4:\n            return function () {\n                return de(cd(bc(ab.apply(this, arguments))));\n            };\n        case 5:\n            return function () {\n                return ef(de(cd(bc(ab.apply(this, arguments)))));\n            };\n        case 6:\n            return function () {\n                return fg(ef(de(cd(bc(ab.apply(this, arguments))))));\n            };\n        case 7:\n            return function () {\n                return gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))));\n            };\n        case 8:\n            return function () {\n                return hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments))))))));\n            };\n        case 9:\n            return function () {\n                return ij(hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))))));\n            };\n    }\n    return;\n}\nexports.flow = flow;\n/**\n * @since 2.0.0\n */\nfunction tuple() {\n    var t = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        t[_i] = arguments[_i];\n    }\n    return t;\n}\nexports.tuple = tuple;\n/**\n * @since 2.0.0\n */\nfunction increment(n) {\n    return n + 1;\n}\nexports.increment = increment;\n/**\n * @since 2.0.0\n */\nfunction decrement(n) {\n    return n - 1;\n}\nexports.decrement = decrement;\n/**\n * @since 2.0.0\n */\nfunction absurd(_) {\n    throw new Error('Called `absurd` function which should be uncallable');\n}\nexports.absurd = absurd;\n/**\n * Creates a tupled version of this function: instead of `n` arguments, it accepts a single tuple argument.\n *\n * @example\n * import { tupled } from 'fp-ts/function'\n *\n * const add = tupled((x: number, y: number): number => x + y)\n *\n * assert.strictEqual(add([1, 2]), 3)\n *\n * @since 2.4.0\n */\nfunction tupled(f) {\n    return function (a) { return f.apply(void 0, a); };\n}\nexports.tupled = tupled;\n/**\n * Inverse function of `tupled`\n *\n * @since 2.4.0\n */\nfunction untupled(f) {\n    return function () {\n        var a = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            a[_i] = arguments[_i];\n        }\n        return f(a);\n    };\n}\nexports.untupled = untupled;\nfunction pipe(a, ab, bc, cd, de, ef, fg, gh, hi, ij, jk, kl, lm, mn, no, op, pq, qr, rs, st) {\n    switch (arguments.length) {\n        case 1:\n            return a;\n        case 2:\n            return ab(a);\n        case 3:\n            return bc(ab(a));\n        case 4:\n            return cd(bc(ab(a)));\n        case 5:\n            return de(cd(bc(ab(a))));\n        case 6:\n            return ef(de(cd(bc(ab(a)))));\n        case 7:\n            return fg(ef(de(cd(bc(ab(a))))));\n        case 8:\n            return gh(fg(ef(de(cd(bc(ab(a)))))));\n        case 9:\n            return hi(gh(fg(ef(de(cd(bc(ab(a))))))));\n        case 10:\n            return ij(hi(gh(fg(ef(de(cd(bc(ab(a)))))))));\n        case 11:\n            return jk(ij(hi(gh(fg(ef(de(cd(bc(ab(a))))))))));\n        case 12:\n            return kl(jk(ij(hi(gh(fg(ef(de(cd(bc(ab(a)))))))))));\n        case 13:\n            return lm(kl(jk(ij(hi(gh(fg(ef(de(cd(bc(ab(a))))))))))));\n        case 14:\n            return mn(lm(kl(jk(ij(hi(gh(fg(ef(de(cd(bc(ab(a)))))))))))));\n        case 15:\n            return no(mn(lm(kl(jk(ij(hi(gh(fg(ef(de(cd(bc(ab(a))))))))))))));\n        case 16:\n            return op(no(mn(lm(kl(jk(ij(hi(gh(fg(ef(de(cd(bc(ab(a)))))))))))))));\n        case 17:\n            return pq(op(no(mn(lm(kl(jk(ij(hi(gh(fg(ef(de(cd(bc(ab(a))))))))))))))));\n        case 18:\n            return qr(pq(op(no(mn(lm(kl(jk(ij(hi(gh(fg(ef(de(cd(bc(ab(a)))))))))))))))));\n        case 19:\n            return rs(qr(pq(op(no(mn(lm(kl(jk(ij(hi(gh(fg(ef(de(cd(bc(ab(a))))))))))))))))));\n        case 20:\n            return st(rs(qr(pq(op(no(mn(lm(kl(jk(ij(hi(gh(fg(ef(de(cd(bc(ab(a)))))))))))))))))));\n    }\n    return;\n}\nexports.pipe = pipe;\n/**\n * Type hole simulation\n *\n * @since 2.7.0\n */\nexports.hole = absurd;\n/**\n * @internal\n */\nvar bind_ = function (a, name, b) {\n    var _a;\n    return Object.assign({}, a, (_a = {}, _a[name] = b, _a));\n};\nexports.bind_ = bind_;\n/**\n * @internal\n */\nvar bindTo_ = function (name) { return function (b) {\n    var _a;\n    return (_a = {}, _a[name] = b, _a);\n}; };\nexports.bindTo_ = bindTo_;\n","\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n    o[\"default\"] = v;\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 (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n    __setModuleDefault(result, mod);\n    return result;\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.filterMap = exports.separate = exports.compact = exports.fromArray = exports.toggle = exports.remove = exports.insert = exports.singleton = exports.foldMap = exports.reduce = exports.getIntersectionSemigroup = exports.getUnionMonoid = exports.difference = exports.partitionMap = exports.intersection = exports.union = exports.elem = exports.partition = exports.filter = exports.subset = exports.chain = exports.every = exports.map = exports.some = exports.getEq = exports.toArray = exports.empty = exports.getShow = void 0;\nvar RS = __importStar(require(\"./ReadonlySet\"));\n/**\n * @category instances\n * @since 2.0.0\n */\nexports.getShow = RS.getShow;\n/**\n * @since 2.0.0\n */\nexports.empty = new Set();\n/**\n * @category constructors\n * @since 2.0.0\n */\n// tslint:disable-next-line: readonly-array\nexports.toArray = RS.toReadonlyArray;\n/**\n * @category instances\n * @since 2.0.0\n */\nexports.getEq = RS.getEq;\n/**\n * @since 2.0.0\n */\nexports.some = RS.some;\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 combinators\n * @since 2.0.0\n */\nexports.map = RS.map;\n/**\n * @since 2.0.0\n */\nexports.every = RS.every;\n/**\n * Composes computations in sequence, using the return value of one computation to determine the next computation.\n *\n * @category combinators\n * @since 2.0.0\n */\nexports.chain = RS.chain;\n// TODO: remove non-curried overloading in v3\n/**\n * `true` if and only if every element in the first set is an element of the second set\n *\n * @since 2.0.0\n */\nexports.subset = RS.isSubset;\nfunction filter(predicate) {\n    return RS.filter(predicate);\n}\nexports.filter = filter;\nfunction partition(predicate) {\n    return RS.partition(predicate);\n}\nexports.partition = partition;\n// TODO: remove non-curried overloading in v3\n/**\n * Test if a value is a member of a set\n *\n * @since 2.0.0\n */\nexports.elem = RS.elem;\n// TODO: remove non-curried overloading in v3\n/**\n * Form the union of two sets\n *\n * @category combinators\n * @since 2.0.0\n */\nexports.union = RS.union;\n// TODO: remove non-curried overloading in v3\n/**\n * The set of elements which are in both the first and second set\n *\n * @category combinators\n * @since 2.0.0\n */\nexports.intersection = RS.intersection;\n/**\n * @since 2.0.0\n */\nexports.partitionMap = RS.partitionMap;\n// TODO: remove non-curried overloading in v3\n/**\n * Form the set difference (`x` - `y`)\n *\n * @example\n * import { difference } from 'fp-ts/Set'\n * import { eqNumber } from 'fp-ts/Eq'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(pipe(new Set([1, 2]), difference(eqNumber)(new Set([1, 3]))), new Set([2]))\n *\n * @category combinators\n * @since 2.0.0\n */\nexports.difference = RS.difference;\n/**\n * @category instances\n * @since 2.0.0\n */\nexports.getUnionMonoid = RS.getUnionMonoid;\n/**\n * @category instances\n * @since 2.0.0\n */\nexports.getIntersectionSemigroup = RS.getIntersectionSemigroup;\n/**\n * @since 2.0.0\n */\nexports.reduce = RS.reduce;\n/**\n * @since 2.0.0\n */\nexports.foldMap = RS.foldMap;\n/**\n * Create a set with one element\n *\n * @category constructors\n * @since 2.0.0\n */\nexports.singleton = RS.singleton;\n/**\n * Insert a value into a set\n *\n * @category combinators\n * @since 2.0.0\n */\nexports.insert = RS.insert;\n/**\n * Delete a value from a set\n *\n * @category combinators\n * @since 2.0.0\n */\nexports.remove = RS.remove;\n/**\n * Checks an element is a member of a set;\n * If yes, removes the value from the set\n * If no, inserts the value to the set\n *\n * @category combinators\n * @since 2.5.0\n */\nfunction toggle(E) {\n    var elemE = exports.elem(E);\n    var removeE = exports.remove(E);\n    var insertE = exports.insert(E);\n    return function (a) { return function (set) { return (elemE(a, set) ? removeE : insertE)(a)(set); }; };\n}\nexports.toggle = toggle;\n/**\n * Create a set from an array\n *\n * @category constructors\n * @since 2.0.0\n */\n// tslint:disable-next-line: readonly-array\nexports.fromArray = RS.fromArray;\n/**\n * @category combinators\n * @since 2.0.0\n */\nexports.compact = RS.compact;\n/**\n * @since 2.0.0\n */\nexports.separate = RS.separate;\n/**\n * @category combinators\n * @since 2.0.0\n */\nexports.filterMap = RS.filterMap;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.filterMap = exports.separate = exports.compact = exports.fromArray = exports.remove = exports.insert = exports.singleton = exports.foldMap = exports.reduce = exports.getIntersectionSemigroup = exports.getUnionMonoid = exports.difference = exports.partitionMap = exports.intersection = exports.union = exports.elem = exports.partition = exports.filter = exports.isSubset = exports.chain = exports.every = exports.map = exports.some = exports.getEq = exports.toReadonlyArray = exports.empty = exports.getShow = exports.toSet = exports.fromSet = void 0;\nvar Eq_1 = require(\"./Eq\");\nvar function_1 = require(\"./function\");\n/**\n * @category constructors\n * @since 2.5.0\n */\nfunction fromSet(s) {\n    return new Set(s);\n}\nexports.fromSet = fromSet;\n/**\n * @category destructors\n * @since 2.5.0\n */\nfunction toSet(s) {\n    return new Set(s);\n}\nexports.toSet = toSet;\n/**\n * @category instances\n * @since 2.5.0\n */\nfunction getShow(S) {\n    return {\n        show: function (s) {\n            var elements = '';\n            s.forEach(function (a) {\n                elements += S.show(a) + ', ';\n            });\n            if (elements !== '') {\n                elements = elements.substring(0, elements.length - 2);\n            }\n            return \"new Set([\" + elements + \"])\";\n        }\n    };\n}\nexports.getShow = getShow;\n/**\n * @since 2.5.0\n */\nexports.empty = new Set();\n/**\n * @category destructors\n * @since 2.5.0\n */\nfunction toReadonlyArray(O) {\n    return function (x) {\n        // tslint:disable-next-line: readonly-array\n        var r = [];\n        x.forEach(function (e) { return r.push(e); });\n        return r.sort(O.compare);\n    };\n}\nexports.toReadonlyArray = toReadonlyArray;\n/**\n * @category instances\n * @since 2.5.0\n */\nfunction getEq(E) {\n    var subsetE = isSubset(E);\n    return Eq_1.fromEquals(function (x, y) { return subsetE(x, y) && subsetE(y, x); });\n}\nexports.getEq = getEq;\n/**\n * @since 2.5.0\n */\nfunction some(predicate) {\n    return function (set) {\n        var values = set.values();\n        var e;\n        var found = false;\n        // tslint:disable-next-line: strict-boolean-expressions\n        while (!found && !(e = values.next()).done) {\n            found = predicate(e.value);\n        }\n        return found;\n    };\n}\nexports.some = some;\n/**\n * Projects a Set through a function\n *\n * @category combinators\n * @since 2.5.0\n */\nfunction map(E) {\n    var elemE = elem(E);\n    return function (f) { return function (set) {\n        var r = new Set();\n        set.forEach(function (e) {\n            var v = f(e);\n            if (!elemE(v, r)) {\n                r.add(v);\n            }\n        });\n        return r;\n    }; };\n}\nexports.map = map;\n/**\n * @since 2.5.0\n */\nfunction every(predicate) {\n    return function_1.not(some(function_1.not(predicate)));\n}\nexports.every = every;\n/**\n * @category combinators\n * @since 2.5.0\n */\nfunction chain(E) {\n    var elemE = elem(E);\n    return function (f) { return function (set) {\n        var r = new Set();\n        set.forEach(function (e) {\n            f(e).forEach(function (e) {\n                if (!elemE(e, r)) {\n                    r.add(e);\n                }\n            });\n        });\n        return r;\n    }; };\n}\nexports.chain = chain;\nfunction isSubset(E) {\n    var elemE = elem(E);\n    return function (me, that) {\n        if (that === undefined) {\n            var isSubsetE_1 = isSubset(E);\n            return function (that) { return isSubsetE_1(that, me); };\n        }\n        return every(function (a) { return elemE(a, that); })(me);\n    };\n}\nexports.isSubset = isSubset;\nfunction filter(predicate) {\n    return function (set) {\n        var values = set.values();\n        var e;\n        var r = new Set();\n        // tslint:disable-next-line: strict-boolean-expressions\n        while (!(e = values.next()).done) {\n            var value = e.value;\n            if (predicate(value)) {\n                r.add(value);\n            }\n        }\n        return r;\n    };\n}\nexports.filter = filter;\nfunction partition(predicate) {\n    return function (set) {\n        var values = set.values();\n        var e;\n        var right = new Set();\n        var left = new Set();\n        // tslint:disable-next-line: strict-boolean-expressions\n        while (!(e = values.next()).done) {\n            var value = e.value;\n            if (predicate(value)) {\n                right.add(value);\n            }\n            else {\n                left.add(value);\n            }\n        }\n        return { left: left, right: right };\n    };\n}\nexports.partition = partition;\nfunction elem(E) {\n    return function (a, set) {\n        if (set === undefined) {\n            var elemE_1 = elem(E);\n            return function (set) { return elemE_1(a, set); };\n        }\n        var values = set.values();\n        var e;\n        var found = false;\n        // tslint:disable-next-line: strict-boolean-expressions\n        while (!found && !(e = values.next()).done) {\n            found = E.equals(a, e.value);\n        }\n        return found;\n    };\n}\nexports.elem = elem;\nfunction union(E) {\n    var elemE = elem(E);\n    return function (me, that) {\n        if (that === undefined) {\n            var unionE_1 = union(E);\n            return function (that) { return unionE_1(me, that); };\n        }\n        if (me === exports.empty) {\n            return that;\n        }\n        if (that === exports.empty) {\n            return me;\n        }\n        var r = new Set(me);\n        that.forEach(function (e) {\n            if (!elemE(e, r)) {\n                r.add(e);\n            }\n        });\n        return r;\n    };\n}\nexports.union = union;\nfunction intersection(E) {\n    var elemE = elem(E);\n    return function (me, that) {\n        if (that === undefined) {\n            var intersectionE_1 = intersection(E);\n            return function (that) { return intersectionE_1(that, me); };\n        }\n        if (me === exports.empty || that === exports.empty) {\n            return exports.empty;\n        }\n        var r = new Set();\n        me.forEach(function (e) {\n            if (elemE(e, that)) {\n                r.add(e);\n            }\n        });\n        return r;\n    };\n}\nexports.intersection = intersection;\n/**\n * @since 2.5.0\n */\nfunction partitionMap(EB, EC) {\n    return function (f) { return function (set) {\n        var values = set.values();\n        var e;\n        var left = new Set();\n        var right = new Set();\n        var hasB = elem(EB);\n        var hasC = elem(EC);\n        // tslint:disable-next-line: strict-boolean-expressions\n        while (!(e = values.next()).done) {\n            var v = f(e.value);\n            switch (v._tag) {\n                case 'Left':\n                    if (!hasB(v.left, left)) {\n                        left.add(v.left);\n                    }\n                    break;\n                case 'Right':\n                    if (!hasC(v.right, right)) {\n                        right.add(v.right);\n                    }\n                    break;\n            }\n        }\n        return { left: left, right: right };\n    }; };\n}\nexports.partitionMap = partitionMap;\nfunction difference(E) {\n    var elemE = elem(E);\n    return function (me, that) {\n        if (that === undefined) {\n            var differenceE_1 = difference(E);\n            return function (that) { return differenceE_1(that, me); };\n        }\n        return filter(function (a) { return !elemE(a, that); })(me);\n    };\n}\nexports.difference = difference;\n/**\n * @category instances\n * @since 2.5.0\n */\nfunction getUnionMonoid(E) {\n    return {\n        concat: union(E),\n        empty: exports.empty\n    };\n}\nexports.getUnionMonoid = getUnionMonoid;\n/**\n * @category instances\n * @since 2.5.0\n */\nfunction getIntersectionSemigroup(E) {\n    return {\n        concat: intersection(E)\n    };\n}\nexports.getIntersectionSemigroup = getIntersectionSemigroup;\n/**\n * @since 2.5.0\n */\nfunction reduce(O) {\n    var toArrayO = toReadonlyArray(O);\n    return function (b, f) { return function (fa) { return toArrayO(fa).reduce(f, b); }; };\n}\nexports.reduce = reduce;\n/**\n * @since 2.5.0\n */\nfunction foldMap(O, M) {\n    var toArrayO = toReadonlyArray(O);\n    return function (f) { return function (fa) { return toArrayO(fa).reduce(function (b, a) { return M.concat(b, f(a)); }, M.empty); }; };\n}\nexports.foldMap = foldMap;\n/**\n * Create a set with one element\n *\n * @category constructors\n * @since 2.5.0\n */\nfunction singleton(a) {\n    return new Set([a]);\n}\nexports.singleton = singleton;\n/**\n * Insert a value into a set\n *\n * @category combinators\n * @since 2.5.0\n */\nfunction insert(E) {\n    var elemE = elem(E);\n    return function (a) { return function (set) {\n        if (!elemE(a)(set)) {\n            var r = new Set(set);\n            r.add(a);\n            return r;\n        }\n        else {\n            return set;\n        }\n    }; };\n}\nexports.insert = insert;\n/**\n * Delete a value from a set\n *\n * @category combinators\n * @since 2.5.0\n */\nfunction remove(E) {\n    return function (a) { return function (set) { return filter(function (ax) { return !E.equals(a, ax); })(set); }; };\n}\nexports.remove = remove;\n/**\n * Create a set from an array\n *\n * @category constructors\n * @since 2.5.0\n */\nfunction fromArray(E) {\n    return function (as) {\n        var len = as.length;\n        var r = new Set();\n        var has = elem(E);\n        for (var i = 0; i < len; i++) {\n            var a = as[i];\n            if (!has(a, r)) {\n                r.add(a);\n            }\n        }\n        return r;\n    };\n}\nexports.fromArray = fromArray;\n/**\n * @category combinators\n * @since 2.5.0\n */\nfunction compact(E) {\n    return filterMap(E)(function_1.identity);\n}\nexports.compact = compact;\n/**\n * @since 2.5.0\n */\nfunction separate(EE, EA) {\n    return function (fa) {\n        var elemEE = elem(EE);\n        var elemEA = elem(EA);\n        var left = new Set();\n        var right = new Set();\n        fa.forEach(function (e) {\n            switch (e._tag) {\n                case 'Left':\n                    if (!elemEE(e.left, left)) {\n                        left.add(e.left);\n                    }\n                    break;\n                case 'Right':\n                    if (!elemEA(e.right, right)) {\n                        right.add(e.right);\n                    }\n                    break;\n            }\n        });\n        return { left: left, right: right };\n    };\n}\nexports.separate = separate;\n/**\n * @category combinators\n * @since 2.5.0\n */\nfunction filterMap(E) {\n    var elemE = elem(E);\n    return function (f) { return function (fa) {\n        var r = new Set();\n        fa.forEach(function (a) {\n            var ob = f(a);\n            if (ob._tag === 'Some' && !elemE(ob.value, r)) {\n                r.add(ob.value);\n            }\n        });\n        return r;\n    }; };\n}\nexports.filterMap = filterMap;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.getApplySemigroup = exports.getOrd = exports.getEq = exports.getShow = exports.URI = exports.wilt = exports.wither = exports.sequence = exports.traverse = exports.partitionMap = exports.partition = exports.filterMap = exports.filter = exports.separate = exports.compact = exports.reduceRight = exports.foldMap = exports.reduce = exports.duplicate = exports.extend = exports.throwError = exports.zero = exports.alt = exports.altW = exports.flatten = exports.chainFirst = exports.chain = exports.of = exports.apSecond = exports.apFirst = exports.ap = exports.map = exports.chainNullableK = exports.mapNullable = exports.fromNullableK = exports.getOrElse = exports.getOrElseW = exports.toUndefined = exports.toNullable = exports.fold = exports.fromEither = exports.getRight = exports.getLeft = exports.tryCatch = exports.fromPredicate = exports.fromNullable = exports.some = exports.none = exports.isNone = exports.isSome = void 0;\nexports.sequenceArray = exports.traverseArray = exports.traverseArrayWithIndex = exports.apS = exports.bind = exports.bindTo = exports.Do = exports.getRefinement = exports.exists = exports.elem = exports.option = exports.MonadThrow = exports.Witherable = exports.Traversable = exports.Filterable = exports.Compactable = exports.Extend = exports.Alternative = exports.Alt = exports.Foldable = exports.Monad = exports.Applicative = exports.Functor = exports.getMonoid = exports.getLastMonoid = exports.getFirstMonoid = exports.getApplyMonoid = void 0;\nvar function_1 = require(\"./function\");\n// -------------------------------------------------------------------------------------\n// guards\n// -------------------------------------------------------------------------------------\n/**\n * Returns `true` if the option is an instance of `Some`, `false` otherwise.\n *\n * @example\n * import { some, none, isSome } from 'fp-ts/Option'\n *\n * assert.strictEqual(isSome(some(1)), true)\n * assert.strictEqual(isSome(none), false)\n *\n * @category guards\n * @since 2.0.0\n */\nvar isSome = function (fa) { return fa._tag === 'Some'; };\nexports.isSome = isSome;\n/**\n * Returns `true` if the option is `None`, `false` otherwise.\n *\n * @example\n * import { some, none, isNone } from 'fp-ts/Option'\n *\n * assert.strictEqual(isNone(some(1)), false)\n * assert.strictEqual(isNone(none), true)\n *\n * @category guards\n * @since 2.0.0\n */\nvar isNone = function (fa) { return fa._tag === 'None'; };\nexports.isNone = isNone;\n// -------------------------------------------------------------------------------------\n// constructors\n// -------------------------------------------------------------------------------------\n/**\n * `None` doesn't have a constructor, instead you can use it directly as a value. Represents a missing value.\n *\n * @category constructors\n * @since 2.0.0\n */\nexports.none = { _tag: 'None' };\n/**\n * Constructs a `Some`. Represents an optional value that exists.\n *\n * @category constructors\n * @since 2.0.0\n */\nvar some = function (a) { return ({ _tag: 'Some', value: a }); };\nexports.some = some;\n/**\n * Constructs a new `Option` from a nullable type. If the value is `null` or `undefined`, returns `None`, otherwise\n * returns the value wrapped in a `Some`.\n *\n * @example\n * import { none, some, fromNullable } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(fromNullable(undefined), none)\n * assert.deepStrictEqual(fromNullable(null), none)\n * assert.deepStrictEqual(fromNullable(1), some(1))\n *\n * @category constructors\n * @since 2.0.0\n */\nfunction fromNullable(a) {\n    return a == null ? exports.none : exports.some(a);\n}\nexports.fromNullable = fromNullable;\nfunction fromPredicate(predicate) {\n    return function (a) { return (predicate(a) ? exports.some(a) : exports.none); };\n}\nexports.fromPredicate = fromPredicate;\n/**\n * Transforms an exception into an `Option`. If `f` throws, returns `None`, otherwise returns the output wrapped in a\n * `Some`.\n *\n * @example\n * import { none, some, tryCatch } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(\n *   tryCatch(() => {\n *     throw new Error()\n *   }),\n *   none\n * )\n * assert.deepStrictEqual(tryCatch(() => 1), some(1))\n *\n * @category constructors\n * @since 2.0.0\n */\nfunction tryCatch(f) {\n    try {\n        return exports.some(f());\n    }\n    catch (e) {\n        return exports.none;\n    }\n}\nexports.tryCatch = tryCatch;\n/**\n * Returns the `Left` value of an `Either` if possible.\n *\n * @example\n * import { getLeft, none, some } from 'fp-ts/Option'\n * import { right, left } from 'fp-ts/Either'\n *\n * assert.deepStrictEqual(getLeft(right(1)), none)\n * assert.deepStrictEqual(getLeft(left('a')), some('a'))\n *\n * @category constructors\n * @since 2.0.0\n */\nfunction getLeft(ma) {\n    return ma._tag === 'Right' ? exports.none : exports.some(ma.left);\n}\nexports.getLeft = getLeft;\n/**\n * Returns the `Right` value of an `Either` if possible.\n *\n * @example\n * import { getRight, none, some } from 'fp-ts/Option'\n * import { right, left } from 'fp-ts/Either'\n *\n * assert.deepStrictEqual(getRight(right(1)), some(1))\n * assert.deepStrictEqual(getRight(left('a')), none)\n *\n * @category constructors\n * @since 2.0.0\n */\nfunction getRight(ma) {\n    return ma._tag === 'Left' ? exports.none : exports.some(ma.right);\n}\nexports.getRight = getRight;\n/**\n * Transforms an `Either` to an `Option` discarding the error.\n *\n * Alias of [getRight](#getRight)\n *\n * Derivable from `MonadThrow`.\n *\n * @category constructors\n * @since 2.0.0\n */\nexports.fromEither = getRight;\n// -------------------------------------------------------------------------------------\n// destructors\n// -------------------------------------------------------------------------------------\n/**\n * Takes a (lazy) default value, a function, and an `Option` value, if the `Option` value is `None` the default value is\n * returned, otherwise the function is applied to the value inside the `Some` and the result is returned.\n *\n * @example\n * import { some, none, fold } from 'fp-ts/Option'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.strictEqual(\n *   pipe(\n *     some(1),\n *     fold(() => 'a none', a => `a some containing ${a}`)\n *   ),\n *   'a some containing 1'\n * )\n *\n * assert.strictEqual(\n *   pipe(\n *     none,\n *     fold(() => 'a none', a => `a some containing ${a}`)\n *   ),\n *   'a none'\n * )\n *\n * @category destructors\n * @since 2.0.0\n */\nfunction fold(onNone, onSome) {\n    return function (ma) { return (exports.isNone(ma) ? onNone() : onSome(ma.value)); };\n}\nexports.fold = fold;\n/**\n * Extracts the value out of the structure, if it exists. Otherwise returns `null`.\n *\n * @example\n * import { some, none, toNullable } from 'fp-ts/Option'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.strictEqual(\n *   pipe(\n *     some(1),\n *     toNullable\n *   ),\n *   1\n * )\n * assert.strictEqual(\n *   pipe(\n *     none,\n *     toNullable\n *   ),\n *   null\n * )\n *\n * @category destructors\n * @since 2.0.0\n */\nfunction toNullable(ma) {\n    return exports.isNone(ma) ? null : ma.value;\n}\nexports.toNullable = toNullable;\n/**\n * Extracts the value out of the structure, if it exists. Otherwise returns `undefined`.\n *\n * @example\n * import { some, none, toUndefined } from 'fp-ts/Option'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.strictEqual(\n *   pipe(\n *     some(1),\n *     toUndefined\n *   ),\n *   1\n * )\n * assert.strictEqual(\n *   pipe(\n *     none,\n *     toUndefined\n *   ),\n *   undefined\n * )\n *\n * @category destructors\n * @since 2.0.0\n */\nfunction toUndefined(ma) {\n    return exports.isNone(ma) ? undefined : ma.value;\n}\nexports.toUndefined = toUndefined;\n/**\n * Less strict version of [`getOrElse`](#getOrElse).\n *\n * @category destructors\n * @since 2.6.0\n */\nvar getOrElseW = function (onNone) { return function (ma) { return (exports.isNone(ma) ? onNone() : ma.value); }; };\nexports.getOrElseW = getOrElseW;\n/**\n * Extracts the value out of the structure, if it exists. Otherwise returns the given default value\n *\n * @example\n * import { some, none, getOrElse } from 'fp-ts/Option'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.strictEqual(\n *   pipe(\n *     some(1),\n *     getOrElse(() => 0)\n *   ),\n *   1\n * )\n * assert.strictEqual(\n *   pipe(\n *     none,\n *     getOrElse(() => 0)\n *   ),\n *   0\n * )\n *\n * @category destructors\n * @since 2.0.0\n */\nexports.getOrElse = exports.getOrElseW;\n// -------------------------------------------------------------------------------------\n// combinators\n// -------------------------------------------------------------------------------------\n/**\n * Returns a *smart constructor* from a function that returns a nullable value.\n *\n * @example\n * import { fromNullableK, none, some } from 'fp-ts/Option'\n *\n * const f = (s: string): number | undefined => {\n *   const n = parseFloat(s)\n *   return isNaN(n) ? undefined : n\n * }\n *\n * const g = fromNullableK(f)\n *\n * assert.deepStrictEqual(g('1'), some(1))\n * assert.deepStrictEqual(g('a'), none)\n *\n * @category combinators\n * @since 2.9.0\n */\nfunction fromNullableK(f) {\n    return function () {\n        var a = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            a[_i] = arguments[_i];\n        }\n        return fromNullable(f.apply(void 0, a));\n    };\n}\nexports.fromNullableK = fromNullableK;\n/**\n * @category combinators\n * @since 2.0.0\n * @deprecated\n */\nexports.mapNullable = chainNullableK;\n/**\n * This is `chain` + `fromNullable`, useful when working with optional values.\n *\n * @example\n * import { some, none, fromNullable, chainNullableK } from 'fp-ts/Option'\n * import { pipe } from 'fp-ts/function'\n *\n * interface Employee {\n *   company?: {\n *     address?: {\n *       street?: {\n *         name?: string\n *       }\n *     }\n *   }\n * }\n *\n * const employee1: Employee = { company: { address: { street: { name: 'high street' } } } }\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     fromNullable(employee1.company),\n *     chainNullableK(company => company.address),\n *     chainNullableK(address => address.street),\n *     chainNullableK(street => street.name)\n *   ),\n *   some('high street')\n * )\n *\n * const employee2: Employee = { company: { address: { street: {} } } }\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     fromNullable(employee2.company),\n *     chainNullableK(company => company.address),\n *     chainNullableK(address => address.street),\n *     chainNullableK(street => street.name)\n *   ),\n *   none\n * )\n *\n * @category combinators\n * @since 2.9.0\n */\nfunction chainNullableK(f) {\n    return function (ma) { return (exports.isNone(ma) ? exports.none : fromNullable(f(ma.value))); };\n}\nexports.chainNullableK = chainNullableK;\n// -------------------------------------------------------------------------------------\n// non-pipeables\n// -------------------------------------------------------------------------------------\nvar map_ = function (fa, f) { return function_1.pipe(fa, exports.map(f)); };\nvar ap_ = function (fab, fa) { return function_1.pipe(fab, exports.ap(fa)); };\nvar chain_ = function (ma, f) { return function_1.pipe(ma, exports.chain(f)); };\nvar reduce_ = function (fa, b, f) { return function_1.pipe(fa, exports.reduce(b, f)); };\nvar foldMap_ = function (M) {\n    var foldMapM = exports.foldMap(M);\n    return function (fa, f) { return function_1.pipe(fa, foldMapM(f)); };\n};\nvar reduceRight_ = function (fa, b, f) { return function_1.pipe(fa, exports.reduceRight(b, f)); };\nvar traverse_ = function (F) {\n    var traverseF = exports.traverse(F);\n    return function (ta, f) { return function_1.pipe(ta, traverseF(f)); };\n};\n/* istanbul ignore next */\nvar alt_ = function (fa, that) { return function_1.pipe(fa, exports.alt(that)); };\nvar filter_ = function (fa, predicate) {\n    return function_1.pipe(fa, exports.filter(predicate));\n};\n/* istanbul ignore next */\nvar filterMap_ = function (fa, f) { return function_1.pipe(fa, exports.filterMap(f)); };\n/* istanbul ignore next */\nvar extend_ = function (wa, f) { return function_1.pipe(wa, exports.extend(f)); };\n/* istanbul ignore next */\nvar partition_ = function (fa, predicate) { return function_1.pipe(fa, exports.partition(predicate)); };\n/* istanbul ignore next */\nvar partitionMap_ = function (fa, f) { return function_1.pipe(fa, exports.partitionMap(f)); };\n/* istanbul ignore next */\nvar wither_ = function (F) {\n    var witherF = exports.wither(F);\n    return function (fa, f) { return function_1.pipe(fa, witherF(f)); };\n};\n/* istanbul ignore next */\nvar wilt_ = function (F) {\n    var wiltF = exports.wilt(F);\n    return function (fa, f) { return function_1.pipe(fa, wiltF(f)); };\n};\n// -------------------------------------------------------------------------------------\n// pipeables\n// -------------------------------------------------------------------------------------\n/**\n * `map` can be used to turn functions `(a: A) => B` into functions `(fa: F<A>) => F<B>` whose argument and return types\n * use the type constructor `F` to represent some computational context.\n *\n * @category Functor\n * @since 2.0.0\n */\nvar map = function (f) { return function (fa) {\n    return exports.isNone(fa) ? exports.none : exports.some(f(fa.value));\n}; };\nexports.map = map;\n/**\n * Apply a function to an argument under a type constructor.\n *\n * @category Apply\n * @since 2.0.0\n */\nvar ap = function (fa) { return function (fab) {\n    return exports.isNone(fab) ? exports.none : exports.isNone(fa) ? exports.none : exports.some(fab.value(fa.value));\n}; };\nexports.ap = 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 */\nvar apFirst = function (fb) {\n    return function_1.flow(exports.map(function (a) { return function () { return a; }; }), exports.ap(fb));\n};\nexports.apFirst = 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 */\nvar apSecond = function (fb) {\n    return function_1.flow(exports.map(function () { return function (b) { return b; }; }), exports.ap(fb));\n};\nexports.apSecond = apSecond;\n/**\n * Wrap a value into the type constructor.\n *\n * @category Applicative\n * @since 2.7.0\n */\nexports.of = exports.some;\n/**\n * Composes computations in sequence, using the return value of one computation to determine the next computation.\n *\n * @category Monad\n * @since 2.0.0\n */\nvar chain = function (f) { return function (ma) {\n    return exports.isNone(ma) ? exports.none : f(ma.value);\n}; };\nexports.chain = chain;\n/**\n * Composes computations in sequence, using the return value of one computation to determine the next computation and\n * keeping only the result of the first.\n *\n * Derivable from `Monad`.\n *\n * @category combinators\n * @since 2.0.0\n */\nvar chainFirst = function (f) {\n    return exports.chain(function (a) {\n        return function_1.pipe(f(a), exports.map(function () { return a; }));\n    });\n};\nexports.chainFirst = chainFirst;\n/**\n * Derivable from `Monad`.\n *\n * @category combinators\n * @since 2.0.0\n */\nexports.flatten = \n/*#__PURE__*/\nexports.chain(function_1.identity);\n/**\n * Less strict version of [`alt`](#alt).\n *\n * @category Alt\n * @since 2.9.0\n */\nvar altW = function (that) { return function (fa) {\n    return exports.isNone(fa) ? that() : fa;\n}; };\nexports.altW = 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 * In case of `Option` returns the left-most non-`None` value.\n *\n * @example\n * import * as O from 'fp-ts/Option'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     O.some('a'),\n *     O.alt(() => O.some('b'))\n *   ),\n *   O.some('a')\n * )\n * assert.deepStrictEqual(\n *   pipe(\n *     O.none,\n *     O.alt(() => O.some('b'))\n *   ),\n *   O.some('b')\n * )\n *\n * @category Alt\n * @since 2.0.0\n */\nexports.alt = exports.altW;\n/**\n * @category Alternative\n * @since 2.7.0\n */\nvar zero = function () { return exports.none; };\nexports.zero = zero;\n/**\n * @category MonadThrow\n * @since 2.7.0\n */\nvar throwError = function () { return exports.none; };\nexports.throwError = throwError;\n/**\n * @category Extend\n * @since 2.0.0\n */\nvar extend = function (f) { return function (wa) {\n    return exports.isNone(wa) ? exports.none : exports.some(f(wa));\n}; };\nexports.extend = extend;\n/**\n * Derivable from `Extend`.\n *\n * @category combinators\n * @since 2.0.0\n */\nexports.duplicate = \n/*#__PURE__*/\nexports.extend(function_1.identity);\n/**\n * @category Foldable\n * @since 2.0.0\n */\nvar reduce = function (b, f) { return function (fa) {\n    return exports.isNone(fa) ? b : f(b, fa.value);\n}; };\nexports.reduce = reduce;\n/**\n * @category Foldable\n * @since 2.0.0\n */\nvar foldMap = function (M) { return function (f) { return function (fa) {\n    return exports.isNone(fa) ? M.empty : f(fa.value);\n}; }; };\nexports.foldMap = foldMap;\n/**\n * @category Foldable\n * @since 2.0.0\n */\nvar reduceRight = function (b, f) { return function (fa) {\n    return exports.isNone(fa) ? b : f(fa.value, b);\n}; };\nexports.reduceRight = reduceRight;\n/**\n * @category Compactable\n * @since 2.0.0\n */\nexports.compact = exports.flatten;\nvar defaultSeparate = { left: exports.none, right: exports.none };\n/**\n * @category Compactable\n * @since 2.0.0\n */\nvar separate = function (ma) {\n    var o = function_1.pipe(ma, exports.map(function (e) { return ({\n        left: getLeft(e),\n        right: getRight(e)\n    }); }));\n    return exports.isNone(o) ? defaultSeparate : o.value;\n};\nexports.separate = separate;\n/**\n * @category Filterable\n * @since 2.0.0\n */\nvar filter = function (predicate) { return function (fa) { return (exports.isNone(fa) ? exports.none : predicate(fa.value) ? fa : exports.none); }; };\nexports.filter = filter;\n/**\n * @category Filterable\n * @since 2.0.0\n */\nvar filterMap = function (f) { return function (fa) {\n    return exports.isNone(fa) ? exports.none : f(fa.value);\n}; };\nexports.filterMap = filterMap;\n/**\n * @category Filterable\n * @since 2.0.0\n */\nvar partition = function (predicate) { return function (fa) {\n    return {\n        left: filter_(fa, function (a) { return !predicate(a); }),\n        right: filter_(fa, predicate)\n    };\n}; };\nexports.partition = partition;\n/**\n * @category Filterable\n * @since 2.0.0\n */\nvar partitionMap = function (f) { return function_1.flow(exports.map(f), exports.separate); };\nexports.partitionMap = partitionMap;\n/**\n * @category Traversable\n * @since 2.6.3\n */\nvar traverse = function (F) { return function (f) { return function (ta) { return (exports.isNone(ta) ? F.of(exports.none) : F.map(f(ta.value), exports.some)); }; }; };\nexports.traverse = traverse;\n/**\n * @category Traversable\n * @since 2.6.3\n */\nvar sequence = function (F) { return function (ta) { return (exports.isNone(ta) ? F.of(exports.none) : F.map(ta.value, exports.some)); }; };\nexports.sequence = sequence;\n/**\n * @category Witherable\n * @since 2.6.5\n */\nvar wither = function (F) { return function (f) { return function (fa) { return (exports.isNone(fa) ? F.of(exports.none) : f(fa.value)); }; }; };\nexports.wither = wither;\n/**\n * @category Witherable\n * @since 2.6.5\n */\nvar wilt = function (F) { return function (f) { return function (fa) {\n    return exports.isNone(fa)\n        ? F.of({\n            left: exports.none,\n            right: exports.none\n        })\n        : F.map(f(fa.value), function (e) { return ({\n            left: getLeft(e),\n            right: getRight(e)\n        }); });\n}; }; };\nexports.wilt = wilt;\n// -------------------------------------------------------------------------------------\n// instances\n// -------------------------------------------------------------------------------------\n/**\n * @category instances\n * @since 2.0.0\n */\nexports.URI = 'Option';\n/**\n * @category instances\n * @since 2.0.0\n */\nfunction getShow(S) {\n    return {\n        show: function (ma) { return (exports.isNone(ma) ? 'none' : \"some(\" + S.show(ma.value) + \")\"); }\n    };\n}\nexports.getShow = getShow;\n/**\n * @example\n * import { none, some, getEq } from 'fp-ts/Option'\n * import { eqNumber } from 'fp-ts/Eq'\n *\n * const E = getEq(eqNumber)\n * assert.strictEqual(E.equals(none, none), true)\n * assert.strictEqual(E.equals(none, some(1)), false)\n * assert.strictEqual(E.equals(some(1), none), false)\n * assert.strictEqual(E.equals(some(1), some(2)), false)\n * assert.strictEqual(E.equals(some(1), some(1)), true)\n *\n * @category instances\n * @since 2.0.0\n */\nfunction getEq(E) {\n    return {\n        equals: function (x, y) { return x === y || (exports.isNone(x) ? exports.isNone(y) : exports.isNone(y) ? false : E.equals(x.value, y.value)); }\n    };\n}\nexports.getEq = getEq;\n/**\n * The `Ord` instance allows `Option` values to be compared with\n * `compare`, whenever there is an `Ord` instance for\n * the type the `Option` contains.\n *\n * `None` is considered to be less than any `Some` value.\n *\n *\n * @example\n * import { none, some, getOrd } from 'fp-ts/Option'\n * import { ordNumber } from 'fp-ts/Ord'\n *\n * const O = getOrd(ordNumber)\n * assert.strictEqual(O.compare(none, none), 0)\n * assert.strictEqual(O.compare(none, some(1)), -1)\n * assert.strictEqual(O.compare(some(1), none), 1)\n * assert.strictEqual(O.compare(some(1), some(2)), -1)\n * assert.strictEqual(O.compare(some(1), some(1)), 0)\n *\n * @category instances\n * @since 2.0.0\n */\nfunction getOrd(O) {\n    return {\n        equals: getEq(O).equals,\n        compare: function (x, y) { return (x === y ? 0 : exports.isSome(x) ? (exports.isSome(y) ? O.compare(x.value, y.value) : 1) : -1); }\n    };\n}\nexports.getOrd = getOrd;\n/**\n * `Apply` semigroup\n *\n * | x       | y       | concat(x, y)       |\n * | ------- | ------- | ------------------ |\n * | none    | none    | none               |\n * | some(a) | none    | none               |\n * | none    | some(a) | none               |\n * | some(a) | some(b) | some(concat(a, b)) |\n *\n * @example\n * import { getApplySemigroup, some, none } from 'fp-ts/Option'\n * import { semigroupSum } from 'fp-ts/Semigroup'\n *\n * const S = getApplySemigroup(semigroupSum)\n * assert.deepStrictEqual(S.concat(none, none), none)\n * assert.deepStrictEqual(S.concat(some(1), none), none)\n * assert.deepStrictEqual(S.concat(none, some(1)), none)\n * assert.deepStrictEqual(S.concat(some(1), some(2)), some(3))\n *\n * @category instances\n * @since 2.0.0\n */\nfunction getApplySemigroup(S) {\n    return {\n        concat: function (x, y) { return (exports.isSome(x) && exports.isSome(y) ? exports.some(S.concat(x.value, y.value)) : exports.none); }\n    };\n}\nexports.getApplySemigroup = getApplySemigroup;\n/**\n * @category instances\n * @since 2.0.0\n */\nfunction getApplyMonoid(M) {\n    return {\n        concat: getApplySemigroup(M).concat,\n        empty: exports.some(M.empty)\n    };\n}\nexports.getApplyMonoid = getApplyMonoid;\n/**\n * Monoid returning the left-most non-`None` value\n *\n * | x       | y       | concat(x, y) |\n * | ------- | ------- | ------------ |\n * | none    | none    | none         |\n * | some(a) | none    | some(a)      |\n * | none    | some(a) | some(a)      |\n * | some(a) | some(b) | some(a)      |\n *\n * @example\n * import { getFirstMonoid, some, none } from 'fp-ts/Option'\n *\n * const M = getFirstMonoid<number>()\n * assert.deepStrictEqual(M.concat(none, none), none)\n * assert.deepStrictEqual(M.concat(some(1), none), some(1))\n * assert.deepStrictEqual(M.concat(none, some(1)), some(1))\n * assert.deepStrictEqual(M.concat(some(1), some(2)), some(1))\n *\n * @category instances\n * @since 2.0.0\n */\nfunction getFirstMonoid() {\n    return {\n        concat: function (x, y) { return (exports.isNone(x) ? y : x); },\n        empty: exports.none\n    };\n}\nexports.getFirstMonoid = getFirstMonoid;\n/**\n * Monoid returning the right-most non-`None` value\n *\n * | x       | y       | concat(x, y) |\n * | ------- | ------- | ------------ |\n * | none    | none    | none         |\n * | some(a) | none    | some(a)      |\n * | none    | some(a) | some(a)      |\n * | some(a) | some(b) | some(b)      |\n *\n * @example\n * import { getLastMonoid, some, none } from 'fp-ts/Option'\n *\n * const M = getLastMonoid<number>()\n * assert.deepStrictEqual(M.concat(none, none), none)\n * assert.deepStrictEqual(M.concat(some(1), none), some(1))\n * assert.deepStrictEqual(M.concat(none, some(1)), some(1))\n * assert.deepStrictEqual(M.concat(some(1), some(2)), some(2))\n *\n * @category instances\n * @since 2.0.0\n */\nfunction getLastMonoid() {\n    return {\n        concat: function (x, y) { return (exports.isNone(y) ? x : y); },\n        empty: exports.none\n    };\n}\nexports.getLastMonoid = getLastMonoid;\n/**\n * Monoid returning the left-most non-`None` value. If both operands are `Some`s then the inner values are\n * concatenated using the provided `Semigroup`\n *\n * | x       | y       | concat(x, y)       |\n * | ------- | ------- | ------------------ |\n * | none    | none    | none               |\n * | some(a) | none    | some(a)            |\n * | none    | some(a) | some(a)            |\n * | some(a) | some(b) | some(concat(a, b)) |\n *\n * @example\n * import { getMonoid, some, none } from 'fp-ts/Option'\n * import { semigroupSum } from 'fp-ts/Semigroup'\n *\n * const M = getMonoid(semigroupSum)\n * assert.deepStrictEqual(M.concat(none, none), none)\n * assert.deepStrictEqual(M.concat(some(1), none), some(1))\n * assert.deepStrictEqual(M.concat(none, some(1)), some(1))\n * assert.deepStrictEqual(M.concat(some(1), some(2)), some(3))\n *\n * @category instances\n * @since 2.0.0\n */\nfunction getMonoid(S) {\n    return {\n        concat: function (x, y) { return (exports.isNone(x) ? y : exports.isNone(y) ? x : exports.some(S.concat(x.value, y.value))); },\n        empty: exports.none\n    };\n}\nexports.getMonoid = getMonoid;\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Functor = {\n    URI: exports.URI,\n    map: map_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Applicative = {\n    URI: exports.URI,\n    map: map_,\n    ap: ap_,\n    of: exports.of\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Monad = {\n    URI: exports.URI,\n    map: map_,\n    ap: ap_,\n    of: exports.of,\n    chain: chain_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Foldable = {\n    URI: exports.URI,\n    reduce: reduce_,\n    foldMap: foldMap_,\n    reduceRight: reduceRight_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Alt = {\n    URI: exports.URI,\n    map: map_,\n    alt: alt_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Alternative = {\n    URI: exports.URI,\n    map: map_,\n    ap: ap_,\n    of: exports.of,\n    alt: alt_,\n    zero: exports.zero\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Extend = {\n    URI: exports.URI,\n    map: map_,\n    extend: extend_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Compactable = {\n    URI: exports.URI,\n    compact: exports.compact,\n    separate: exports.separate\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Filterable = {\n    URI: exports.URI,\n    map: map_,\n    compact: exports.compact,\n    separate: exports.separate,\n    filter: filter_,\n    filterMap: filterMap_,\n    partition: partition_,\n    partitionMap: partitionMap_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Traversable = {\n    URI: exports.URI,\n    map: map_,\n    reduce: reduce_,\n    foldMap: foldMap_,\n    reduceRight: reduceRight_,\n    traverse: traverse_,\n    sequence: exports.sequence\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Witherable = {\n    URI: exports.URI,\n    map: map_,\n    reduce: reduce_,\n    foldMap: foldMap_,\n    reduceRight: reduceRight_,\n    traverse: traverse_,\n    sequence: exports.sequence,\n    compact: exports.compact,\n    separate: exports.separate,\n    filter: filter_,\n    filterMap: filterMap_,\n    partition: partition_,\n    partitionMap: partitionMap_,\n    wither: wither_,\n    wilt: wilt_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.MonadThrow = {\n    URI: exports.URI,\n    map: map_,\n    ap: ap_,\n    of: exports.of,\n    chain: chain_,\n    throwError: exports.throwError\n};\n// TODO: remove in v3\n/**\n * @category instances\n * @since 2.0.0\n */\nexports.option = {\n    URI: exports.URI,\n    map: map_,\n    of: exports.of,\n    ap: ap_,\n    chain: chain_,\n    reduce: reduce_,\n    foldMap: foldMap_,\n    reduceRight: reduceRight_,\n    traverse: traverse_,\n    sequence: exports.sequence,\n    zero: exports.zero,\n    alt: alt_,\n    extend: extend_,\n    compact: exports.compact,\n    separate: exports.separate,\n    filter: filter_,\n    filterMap: filterMap_,\n    partition: partition_,\n    partitionMap: partitionMap_,\n    wither: wither_,\n    wilt: wilt_,\n    throwError: exports.throwError\n};\n// -------------------------------------------------------------------------------------\n// utils\n// -------------------------------------------------------------------------------------\n/**\n * Returns `true` if `ma` contains `a`\n *\n * @example\n * import { some, none, elem } from 'fp-ts/Option'\n * import { eqNumber } from 'fp-ts/Eq'\n *\n * assert.strictEqual(elem(eqNumber)(1, some(1)), true)\n * assert.strictEqual(elem(eqNumber)(2, some(1)), false)\n * assert.strictEqual(elem(eqNumber)(1, none), false)\n *\n * @since 2.0.0\n */\nfunction elem(E) {\n    return function (a, ma) { return (exports.isNone(ma) ? false : E.equals(a, ma.value)); };\n}\nexports.elem = elem;\n/**\n * Returns `true` if the predicate is satisfied by the wrapped value\n *\n * @example\n * import { some, none, exists } from 'fp-ts/Option'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.strictEqual(\n *   pipe(\n *     some(1),\n *     exists(n => n > 0)\n *   ),\n *   true\n * )\n * assert.strictEqual(\n *   pipe(\n *     some(1),\n *     exists(n => n > 1)\n *   ),\n *   false\n * )\n * assert.strictEqual(\n *   pipe(\n *     none,\n *     exists(n => n > 0)\n *   ),\n *   false\n * )\n *\n * @since 2.0.0\n */\nfunction exists(predicate) {\n    return function (ma) { return (exports.isNone(ma) ? false : predicate(ma.value)); };\n}\nexports.exists = exists;\n/**\n * Returns a `Refinement` (i.e. a custom type guard) from a `Option` returning function.\n * This function ensures that a custom type guard definition is type-safe.\n *\n * ```ts\n * import { some, none, getRefinement } from 'fp-ts/Option'\n *\n * type A = { type: 'A' }\n * type B = { type: 'B' }\n * type C = A | B\n *\n * const isA = (c: C): c is A => c.type === 'B' // <= typo but typescript doesn't complain\n * const isA = getRefinement<C, A>(c => (c.type === 'B' ? some(c) : none)) // static error: Type '\"B\"' is not assignable to type '\"A\"'\n * ```\n *\n * @since 2.0.0\n */\nfunction getRefinement(getOption) {\n    return function (a) { return exports.isSome(getOption(a)); };\n}\nexports.getRefinement = getRefinement;\n// -------------------------------------------------------------------------------------\n// do notation\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.9.0\n */\nexports.Do = \n/*#__PURE__*/\nexports.of({});\n/**\n * @since 2.8.0\n */\nvar bindTo = function (name) { return exports.map(function_1.bindTo_(name)); };\nexports.bindTo = bindTo;\n/**\n * @since 2.8.0\n */\nvar bind = function (name, f) {\n    return exports.chain(function (a) {\n        return function_1.pipe(f(a), exports.map(function (b) { return function_1.bind_(a, name, b); }));\n    });\n};\nexports.bind = bind;\n// -------------------------------------------------------------------------------------\n// pipeable sequence S\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.8.0\n */\nvar apS = function (name, fb) {\n    return function_1.flow(exports.map(function (a) { return function (b) { return function_1.bind_(a, name, b); }; }), exports.ap(fb));\n};\nexports.apS = apS;\n// -------------------------------------------------------------------------------------\n// array utils\n// -------------------------------------------------------------------------------------\n/**\n *\n * @since 2.9.0\n */\nvar traverseArrayWithIndex = function (f) { return function (arr) {\n    // tslint:disable-next-line: readonly-array\n    var result = [];\n    for (var i = 0; i < arr.length; i++) {\n        var b = f(i, arr[i]);\n        if (exports.isNone(b)) {\n            return exports.none;\n        }\n        result.push(b.value);\n    }\n    return exports.some(result);\n}; };\nexports.traverseArrayWithIndex = traverseArrayWithIndex;\n/**\n * Runs an action for every element in array and accumulates the results in option\n *\n * this function have the same behavior of `A.sequence(O.option)` but it's optimized and perform better\n *\n * @example\n *\n * import * as A from 'fp-ts/Array'\n * import { traverseArray, some, fromPredicate, none } from 'fp-ts/Option'\n * import { pipe } from 'fp-ts/function'\n *\n * const arr = A.range(0, 10)\n * assert.deepStrictEqual(pipe(arr, traverseArray(some)), some(arr))\n * assert.deepStrictEqual(pipe(arr, traverseArray(fromPredicate((x) => x > 5))), none)\n *\n * @since 2.9.0\n */\nvar traverseArray = function (f) { return exports.traverseArrayWithIndex(function (_, a) { return f(a); }); };\nexports.traverseArray = traverseArray;\n/**\n * get an array of option and convert it to option of array\n *\n * this function have the same behavior of `A.sequence(O.option)` but it's optimized and perform better\n *\n * @example\n *\n * import * as A from 'fp-ts/Array'\n * import { sequenceArray, some, none, fromPredicate } from 'fp-ts/Option'\n * import { pipe } from 'fp-ts/function'\n *\n * const arr = A.range(0, 10)\n * assert.deepStrictEqual(pipe(arr, A.map(some), sequenceArray), some(arr))\n * assert.deepStrictEqual(pipe(arr, A.map(fromPredicate(x => x > 8)), sequenceArray), none)\n *\n * @since 2.9.0\n */\nexports.sequenceArray = \n/*#__PURE__*/\nexports.traverseArray(function_1.identity);\n","\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n    o[\"default\"] = v;\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 (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n    __setModuleDefault(result, mod);\n    return result;\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.intersperse = exports.prependToAll = exports.unzip = exports.zip = exports.zipWith = exports.sort = exports.lefts = exports.rights = exports.reverse = exports.modifyAt = exports.deleteAt = exports.updateAt = exports.insertAt = exports.findLastIndex = exports.findLastMap = exports.findLast = exports.findFirstMap = exports.findFirst = exports.findIndex = exports.dropLeftWhile = exports.dropRight = exports.dropLeft = exports.spanLeft = exports.takeLeftWhile = exports.takeRight = exports.takeLeft = exports.init = exports.tail = exports.last = exports.head = exports.snoc = exports.cons = exports.lookup = exports.isOutOfBound = exports.isNonEmpty = exports.isEmpty = exports.scanRight = exports.scanLeft = exports.foldRight = exports.foldLeft = exports.flatten = exports.replicate = exports.range = exports.makeBy = exports.getOrd = exports.getEq = exports.getMonoid = exports.getShow = exports.toArray = exports.fromArray = void 0;\nexports.FunctorWithIndex = exports.Functor = exports.URI = exports.unfold = exports.wilt = exports.wither = exports.traverseWithIndex = exports.sequence = exports.traverse = exports.reduceRightWithIndex = exports.reduceRight = exports.reduceWithIndex = exports.foldMap = exports.reduce = exports.foldMapWithIndex = exports.duplicate = exports.extend = exports.filterWithIndex = exports.partitionMapWithIndex = exports.partitionMap = exports.partitionWithIndex = exports.partition = exports.compact = exports.filterMap = exports.filterMapWithIndex = exports.filter = exports.separate = exports.mapWithIndex = exports.map = exports.chainFirst = exports.chainWithIndex = exports.chain = exports.apSecond = exports.apFirst = exports.ap = exports.alt = exports.altW = exports.zero = exports.of = exports.difference = exports.intersection = exports.union = exports.comprehension = exports.chunksOf = exports.splitAt = exports.chop = exports.sortBy = exports.uniq = exports.elem = exports.rotate = void 0;\nexports.apS = exports.bind = exports.bindTo = exports.Do = exports.some = exports.every = exports.empty = exports.unsafeDeleteAt = exports.unsafeUpdateAt = exports.unsafeInsertAt = exports.readonlyArray = exports.Witherable = exports.TraversableWithIndex = exports.Traversable = exports.FoldableWithIndex = exports.Foldable = exports.FilterableWithIndex = exports.Filterable = exports.Compactable = exports.Extend = exports.Alternative = exports.Alt = exports.Unfoldable = exports.Monad = exports.Applicative = void 0;\nvar function_1 = require(\"./function\");\nvar O = __importStar(require(\"./Option\"));\nvar Ord_1 = require(\"./Ord\");\n// -------------------------------------------------------------------------------------\n// model\n// -------------------------------------------------------------------------------------\n/**\n * @category constructors\n * @since 2.5.0\n */\n// tslint:disable-next-line: readonly-array\nfunction fromArray(as) {\n    var l = as.length;\n    if (l === 0) {\n        return exports.empty;\n    }\n    var ras = Array(l);\n    for (var i = 0; i < l; i++) {\n        ras[i] = as[i];\n    }\n    return ras;\n}\nexports.fromArray = fromArray;\n/**\n * @category destructors\n * @since 2.5.0\n */\n// tslint:disable-next-line: readonly-array\nfunction toArray(ras) {\n    var l = ras.length;\n    var as = Array(l);\n    for (var i = 0; i < l; i++) {\n        as[i] = ras[i];\n    }\n    return as;\n}\nexports.toArray = toArray;\n/**\n * @category instances\n * @since 2.5.0\n */\nfunction getShow(S) {\n    return {\n        show: function (as) { return \"[\" + as.map(S.show).join(', ') + \"]\"; }\n    };\n}\nexports.getShow = getShow;\nvar concat = function (x, y) {\n    var lenx = x.length;\n    if (lenx === 0) {\n        return y;\n    }\n    var leny = y.length;\n    if (leny === 0) {\n        return x;\n    }\n    var r = Array(lenx + leny);\n    for (var i = 0; i < lenx; i++) {\n        r[i] = x[i];\n    }\n    for (var i = 0; i < leny; i++) {\n        r[i + lenx] = y[i];\n    }\n    return r;\n};\n/**\n * Returns a `Monoid` for `ReadonlyArray<A>`\n *\n * @example\n * import { getMonoid } from 'fp-ts/ReadonlyArray'\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.5.0\n */\nfunction getMonoid() {\n    return {\n        concat: concat,\n        empty: exports.empty\n    };\n}\nexports.getMonoid = getMonoid;\n/**\n * Derives an `Eq` over the `ReadonlyArray` 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/ReadonlyArray'\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.5.0\n */\nfunction getEq(E) {\n    return {\n        equals: function (xs, ys) { return xs === ys || (xs.length === ys.length && xs.every(function (x, i) { return E.equals(x, ys[i]); })); }\n    };\n}\nexports.getEq = getEq;\n/**\n * Derives an `Ord` over the `ReadonlyArray` 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/ReadonlyArray'\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 *\n * @category instances\n * @since 2.5.0\n */\nfunction getOrd(O) {\n    return Ord_1.fromCompare(function (a, b) {\n        var aLen = a.length;\n        var bLen = b.length;\n        var len = Math.min(aLen, bLen);\n        for (var i = 0; i < len; i++) {\n            var ordering = O.compare(a[i], b[i]);\n            if (ordering !== 0) {\n                return ordering;\n            }\n        }\n        return Ord_1.ordNumber.compare(aLen, bLen);\n    });\n}\nexports.getOrd = getOrd;\n/**\n * Return a list of length `n` with element `i` initialized with `f(i)`\n *\n * @example\n * import { makeBy } from 'fp-ts/ReadonlyArray'\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.5.0\n */\nfunction makeBy(n, f) {\n    // tslint:disable-next-line: readonly-array\n    var r = [];\n    for (var i = 0; i < n; i++) {\n        r.push(f(i));\n    }\n    return r;\n}\nexports.makeBy = makeBy;\n/**\n * Create an array containing a range of integers, including both endpoints\n *\n * @example\n * import { range } from 'fp-ts/ReadonlyArray'\n *\n * assert.deepStrictEqual(range(1, 5), [1, 2, 3, 4, 5])\n *\n * @category constructors\n * @since 2.5.0\n */\nfunction range(start, end) {\n    return makeBy(end - start + 1, function (i) { return start + i; });\n}\nexports.range = range;\n/**\n * Create an array containing a value repeated the specified number of times\n *\n * @example\n * import { replicate } from 'fp-ts/ReadonlyArray'\n *\n * assert.deepStrictEqual(replicate(3, 'a'), ['a', 'a', 'a'])\n *\n * @category constructors\n * @since 2.5.0\n */\nfunction replicate(n, a) {\n    return makeBy(n, function () { return a; });\n}\nexports.replicate = replicate;\n/**\n * Removes one level of nesting\n *\n * Derivable from `Monad`.\n *\n * @example\n * import { flatten } from 'fp-ts/ReadonlyArray'\n *\n * assert.deepStrictEqual(flatten([[1], [2], [3]]), [1, 2, 3])\n *\n * @category combinators\n * @since 2.5.0\n */\nfunction flatten(mma) {\n    var rLen = 0;\n    var len = mma.length;\n    for (var i = 0; i < len; i++) {\n        rLen += mma[i].length;\n    }\n    var r = Array(rLen);\n    var start = 0;\n    for (var i = 0; i < len; i++) {\n        var arr = mma[i];\n        var l = arr.length;\n        for (var j = 0; j < l; j++) {\n            r[j + start] = arr[j];\n        }\n        start += l;\n    }\n    return r;\n}\nexports.flatten = flatten;\n/**\n * Break an array into its first element and remaining elements\n *\n * @example\n * import { foldLeft } from 'fp-ts/ReadonlyArray'\n *\n * const len: <A>(as: ReadonlyArray<A>) => number = foldLeft(() => 0, (_, tail) => 1 + len(tail))\n * assert.strictEqual(len([1, 2, 3]), 3)\n *\n * @category destructors\n * @since 2.5.0\n */\nfunction foldLeft(onEmpty, onCons) {\n    return function (as) { return (isEmpty(as) ? onEmpty() : onCons(as[0], as.slice(1))); };\n}\nexports.foldLeft = foldLeft;\n/**\n * Break an array into its initial elements and the last element\n *\n * @category destructors\n * @since 2.5.0\n */\nfunction foldRight(onEmpty, onCons) {\n    return function (as) { return (isEmpty(as) ? onEmpty() : onCons(as.slice(0, as.length - 1), as[as.length - 1])); };\n}\nexports.foldRight = foldRight;\n/**\n * Same as `reduce` but it carries over the intermediate steps\n *\n * @example\n * import { scanLeft } from 'fp-ts/ReadonlyArray'\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.5.0\n */\nfunction scanLeft(b, f) {\n    return function (as) {\n        var l = as.length;\n        // tslint:disable-next-line: readonly-array\n        var r = new Array(l + 1);\n        r[0] = b;\n        for (var i = 0; i < l; i++) {\n            r[i + 1] = f(r[i], as[i]);\n        }\n        return r;\n    };\n}\nexports.scanLeft = 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/ReadonlyArray'\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.5.0\n */\nfunction scanRight(b, f) {\n    return function (as) {\n        var l = as.length;\n        // tslint:disable-next-line: readonly-array\n        var r = new Array(l + 1);\n        r[l] = b;\n        for (var i = l - 1; i >= 0; i--) {\n            r[i] = f(as[i], r[i + 1]);\n        }\n        return r;\n    };\n}\nexports.scanRight = scanRight;\n/**\n * Test whether an array is empty\n *\n * @example\n * import { isEmpty } from 'fp-ts/ReadonlyArray'\n *\n * assert.strictEqual(isEmpty([]), true)\n *\n * @since 2.5.0\n */\nfunction isEmpty(as) {\n    return as.length === 0;\n}\nexports.isEmpty = isEmpty;\n/**\n * Test whether an array is non empty narrowing down the type to `NonEmptyReadonlyArray<A>`\n *\n * @category guards\n * @since 2.5.0\n */\nfunction isNonEmpty(as) {\n    return as.length > 0;\n}\nexports.isNonEmpty = isNonEmpty;\n/**\n * Test whether an array contains a particular index\n *\n * @since 2.5.0\n */\nfunction isOutOfBound(i, as) {\n    return i < 0 || i >= as.length;\n}\nexports.isOutOfBound = isOutOfBound;\nfunction lookup(i, as) {\n    return as === undefined ? function (as) { return lookup(i, as); } : isOutOfBound(i, as) ? O.none : O.some(as[i]);\n}\nexports.lookup = lookup;\nfunction cons(head, tail) {\n    if (tail === undefined) {\n        return function (tail) { return cons(head, tail); };\n    }\n    var len = tail.length;\n    var r = Array(len + 1);\n    for (var i = 0; i < len; i++) {\n        r[i + 1] = tail[i];\n    }\n    r[0] = head;\n    return r;\n}\nexports.cons = cons;\n// TODO: curry and make data-last 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/ReadonlyArray'\n *\n * assert.deepStrictEqual(snoc([1, 2, 3], 4), [1, 2, 3, 4])\n *\n * @category constructors\n * @since 2.5.0\n */\nfunction snoc(init, end) {\n    var len = init.length;\n    var r = Array(len + 1);\n    for (var i = 0; i < len; i++) {\n        r[i] = init[i];\n    }\n    r[len] = end;\n    return r;\n}\nexports.snoc = 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/ReadonlyArray'\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 * @since 2.5.0\n */\nfunction head(as) {\n    return isEmpty(as) ? O.none : O.some(as[0]);\n}\nexports.head = 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/ReadonlyArray'\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 * @since 2.5.0\n */\nfunction last(as) {\n    return lookup(as.length - 1, as);\n}\nexports.last = 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/ReadonlyArray'\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 * @since 2.5.0\n */\nfunction tail(as) {\n    return isEmpty(as) ? O.none : O.some(as.slice(1));\n}\nexports.tail = 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/ReadonlyArray'\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 * @since 2.5.0\n */\nfunction init(as) {\n    var len = as.length;\n    return len === 0 ? O.none : O.some(as.slice(0, len - 1));\n}\nexports.init = 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/ReadonlyArray'\n *\n * assert.deepStrictEqual(takeLeft(2)([1, 2, 3]), [1, 2])\n *\n * @category combinators\n * @since 2.5.0\n */\nfunction takeLeft(n) {\n    return function (as) { return as.slice(0, n); };\n}\nexports.takeLeft = 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/ReadonlyArray'\n *\n * assert.deepStrictEqual(takeRight(2)([1, 2, 3, 4, 5]), [4, 5])\n *\n * @since 2.5.0\n */\nfunction takeRight(n) {\n    return function (as) { return (n === 0 ? exports.empty : as.slice(-n)); };\n}\nexports.takeRight = takeRight;\nfunction takeLeftWhile(predicate) {\n    return function (as) {\n        var i = spanIndexUncurry(as, predicate);\n        var init = Array(i);\n        for (var j = 0; j < i; j++) {\n            init[j] = as[j];\n        }\n        return init;\n    };\n}\nexports.takeLeftWhile = takeLeftWhile;\nvar spanIndexUncurry = function (as, predicate) {\n    var l = as.length;\n    var i = 0;\n    for (; i < l; i++) {\n        if (!predicate(as[i])) {\n            break;\n        }\n    }\n    return i;\n};\nfunction spanLeft(predicate) {\n    return function (as) {\n        var i = spanIndexUncurry(as, predicate);\n        var init = Array(i);\n        for (var j = 0; j < i; j++) {\n            init[j] = as[j];\n        }\n        var l = as.length;\n        var rest = Array(l - i);\n        for (var j = i; j < l; j++) {\n            rest[j - i] = as[j];\n        }\n        return { init: init, rest: rest };\n    };\n}\nexports.spanLeft = spanLeft;\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/ReadonlyArray'\n *\n * assert.deepStrictEqual(dropLeft(2)([1, 2, 3]), [3])\n *\n * @category combinators\n * @since 2.5.0\n */\nfunction dropLeft(n) {\n    return function (as) { return as.slice(n, as.length); };\n}\nexports.dropLeft = 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/ReadonlyArray'\n *\n * assert.deepStrictEqual(dropRight(2)([1, 2, 3, 4, 5]), [1, 2, 3])\n *\n * @category combinators\n * @since 2.5.0\n */\nfunction dropRight(n) {\n    return function (as) { return as.slice(0, as.length - n); };\n}\nexports.dropRight = 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/ReadonlyArray'\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.5.0\n */\nfunction dropLeftWhile(predicate) {\n    return function (as) {\n        var i = spanIndexUncurry(as, predicate);\n        var l = as.length;\n        var rest = Array(l - i);\n        for (var j = i; j < l; j++) {\n            rest[j - i] = as[j];\n        }\n        return rest;\n    };\n}\nexports.dropLeftWhile = dropLeftWhile;\n/**\n * Find the first index for which a predicate holds\n *\n * @example\n * import { findIndex } from 'fp-ts/ReadonlyArray'\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.5.0\n */\nfunction findIndex(predicate) {\n    return function (as) {\n        var len = as.length;\n        for (var i = 0; i < len; i++) {\n            if (predicate(as[i])) {\n                return O.some(i);\n            }\n        }\n        return O.none;\n    };\n}\nexports.findIndex = findIndex;\nfunction findFirst(predicate) {\n    return function (as) {\n        var len = as.length;\n        for (var i = 0; i < len; i++) {\n            if (predicate(as[i])) {\n                return O.some(as[i]);\n            }\n        }\n        return O.none;\n    };\n}\nexports.findFirst = findFirst;\n/**\n * Find the first element returned by an option based selector function\n *\n * @example\n * import { findFirstMap } from 'fp-ts/ReadonlyArray'\n * import { some, none } from 'fp-ts/Option'\n *\n * interface Person {\n *   name: string\n *   age?: number\n * }\n *\n * const persons: ReadonlyArray<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 * @since 2.5.0\n */\nfunction findFirstMap(f) {\n    return function (as) {\n        var len = as.length;\n        for (var i = 0; i < len; i++) {\n            var v = f(as[i]);\n            if (O.isSome(v)) {\n                return v;\n            }\n        }\n        return O.none;\n    };\n}\nexports.findFirstMap = findFirstMap;\nfunction findLast(predicate) {\n    return function (as) {\n        var len = as.length;\n        for (var i = len - 1; i >= 0; i--) {\n            if (predicate(as[i])) {\n                return O.some(as[i]);\n            }\n        }\n        return O.none;\n    };\n}\nexports.findLast = findLast;\n/**\n * Find the last element returned by an option based selector function\n *\n * @example\n * import { findLastMap } from 'fp-ts/ReadonlyArray'\n * import { some, none } from 'fp-ts/Option'\n *\n * interface Person {\n *   name: string\n *   age?: number\n * }\n *\n * const persons: ReadonlyArray<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 * @since 2.5.0\n */\nfunction findLastMap(f) {\n    return function (as) {\n        var len = as.length;\n        for (var i = len - 1; i >= 0; i--) {\n            var v = f(as[i]);\n            if (O.isSome(v)) {\n                return v;\n            }\n        }\n        return O.none;\n    };\n}\nexports.findLastMap = 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/ReadonlyArray'\n * import { some, none } from 'fp-ts/Option'\n *\n * interface X {\n *   a: number\n *   b: number\n * }\n * const xs: ReadonlyArray<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.5.0\n */\nfunction findLastIndex(predicate) {\n    return function (as) {\n        var len = as.length;\n        for (var i = len - 1; i >= 0; i--) {\n            if (predicate(as[i])) {\n                return O.some(i);\n            }\n        }\n        return O.none;\n    };\n}\nexports.findLastIndex = findLastIndex;\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/ReadonlyArray'\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.5.0\n */\nfunction insertAt(i, a) {\n    return function (as) { return (i < 0 || i > as.length ? O.none : O.some(unsafeInsertAt(i, a, as))); };\n}\nexports.insertAt = 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/ReadonlyArray'\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.5.0\n */\nfunction updateAt(i, a) {\n    return function (as) { return (isOutOfBound(i, as) ? O.none : O.some(unsafeUpdateAt(i, a, as))); };\n}\nexports.updateAt = 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/ReadonlyArray'\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.5.0\n */\nfunction deleteAt(i) {\n    return function (as) { return (isOutOfBound(i, as) ? O.none : O.some(unsafeDeleteAt(i, as))); };\n}\nexports.deleteAt = 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/ReadonlyArray'\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.5.0\n */\nfunction modifyAt(i, f) {\n    return function (as) { return (isOutOfBound(i, as) ? O.none : O.some(unsafeUpdateAt(i, f(as[i]), as))); };\n}\nexports.modifyAt = modifyAt;\n/**\n * Reverse an array, creating a new array\n *\n * @example\n * import { reverse } from 'fp-ts/ReadonlyArray'\n *\n * assert.deepStrictEqual(reverse([1, 2, 3]), [3, 2, 1])\n *\n * @category combinators\n * @since 2.5.0\n */\nfunction reverse(as) {\n    if (isEmpty(as)) {\n        return as;\n    }\n    return as.slice().reverse();\n}\nexports.reverse = 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/ReadonlyArray'\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.5.0\n */\nfunction rights(as) {\n    // tslint:disable-next-line: readonly-array\n    var r = [];\n    var len = as.length;\n    for (var i = 0; i < len; i++) {\n        var a = as[i];\n        if (a._tag === 'Right') {\n            r.push(a.right);\n        }\n    }\n    return r;\n}\nexports.rights = 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/ReadonlyArray'\n * import { left, right } from 'fp-ts/Either'\n *\n * assert.deepStrictEqual(lefts([right(1), left('foo'), right(2)]), ['foo'])\n *\n * @since 2.5.0\n */\nfunction lefts(as) {\n    // tslint:disable-next-line: readonly-array\n    var r = [];\n    var len = as.length;\n    for (var i = 0; i < len; i++) {\n        var a = as[i];\n        if (a._tag === 'Left') {\n            r.push(a.left);\n        }\n    }\n    return r;\n}\nexports.lefts = 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/ReadonlyArray'\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.5.0\n */\nvar sort = function (O) { return function (as) {\n    return as.length <= 1 ? as : as.slice().sort(O.compare);\n}; };\nexports.sort = sort;\n// TODO: curry and make data-last in v3\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/ReadonlyArray'\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.5.0\n */\nfunction zipWith(fa, fb, f) {\n    // tslint:disable-next-line: readonly-array\n    var fc = [];\n    var len = Math.min(fa.length, fb.length);\n    for (var i = 0; i < len; i++) {\n        fc[i] = f(fa[i], fb[i]);\n    }\n    return fc;\n}\nexports.zipWith = zipWith;\nfunction zip(as, bs) {\n    if (bs === undefined) {\n        return function (bs) { return zip(bs, as); };\n    }\n    return zipWith(as, bs, function (a, b) { return [a, b]; });\n}\nexports.zip = 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/ReadonlyArray'\n *\n * assert.deepStrictEqual(unzip([[1, 'a'], [2, 'b'], [3, 'c']]), [[1, 2, 3], ['a', 'b', 'c']])\n *\n * @since 2.5.0\n */\nfunction unzip(as) {\n    // tslint:disable-next-line: readonly-array\n    var fa = [];\n    // tslint:disable-next-line: readonly-array\n    var fb = [];\n    for (var i = 0; i < as.length; i++) {\n        fa[i] = as[i][0];\n        fb[i] = as[i][1];\n    }\n    return [fa, fb];\n}\nexports.unzip = unzip;\n/**\n * Prepend an element to every member of an array\n *\n * @example\n * import { prependToAll } from 'fp-ts/ReadonlyArray'\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 */\nvar prependToAll = function (e) { return function (xs) {\n    // tslint:disable-next-line: readonly-array\n    var ys = [];\n    for (var _i = 0, xs_1 = xs; _i < xs_1.length; _i++) {\n        var x = xs_1[_i];\n        ys.push(e, x);\n    }\n    return ys;\n}; };\nexports.prependToAll = prependToAll;\n/**\n * Places an element in between members of an array\n *\n * @example\n * import { intersperse } from 'fp-ts/ReadonlyArray'\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 */\nfunction intersperse(e) {\n    return function (as) {\n        var length = as.length;\n        if (length === 0) {\n            return as;\n        }\n        return cons(as[0], exports.prependToAll(e)(as.slice(1, as.length)));\n    };\n}\nexports.intersperse = intersperse;\n/**\n * Rotate an array to the right by `n` steps\n *\n * @example\n * import { rotate } from 'fp-ts/ReadonlyArray'\n *\n * assert.deepStrictEqual(rotate(2)([1, 2, 3, 4, 5]), [4, 5, 1, 2, 3])\n *\n * @category combinators\n * @since 2.5.0\n */\nfunction rotate(n) {\n    return function (as) {\n        var len = as.length;\n        if (n === 0 || len <= 1 || len === Math.abs(n)) {\n            return as;\n        }\n        else if (n < 0) {\n            return rotate(len + n)(as);\n        }\n        else {\n            return as.slice(-n).concat(as.slice(0, len - n));\n        }\n    };\n}\nexports.rotate = rotate;\nfunction elem(E) {\n    return function (a, as) {\n        if (as === undefined) {\n            var elemE_1 = elem(E);\n            return function (as) { return elemE_1(a, as); };\n        }\n        var predicate = function (element) { return E.equals(element, a); };\n        var i = 0;\n        var len = as.length;\n        for (; i < len; i++) {\n            if (predicate(as[i])) {\n                return true;\n            }\n        }\n        return false;\n    };\n}\nexports.elem = elem;\n/**\n * Remove duplicates from an array, keeping the first occurrence of an element.\n *\n * @example\n * import { uniq } from 'fp-ts/ReadonlyArray'\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.5.0\n */\nfunction uniq(E) {\n    var elemS = elem(E);\n    return function (as) {\n        var len = as.length;\n        if (len <= 1) {\n            return as;\n        }\n        // tslint:disable-next-line: readonly-array\n        var r = [];\n        var i = 0;\n        for (; i < len; i++) {\n            var a = as[i];\n            if (!elemS(a, r)) {\n                r.push(a);\n            }\n        }\n        return len === r.length ? as : r;\n    };\n}\nexports.uniq = 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/ReadonlyArray'\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.5.0\n */\nfunction sortBy(ords) {\n    var M = Ord_1.getMonoid();\n    return exports.sort(ords.reduce(M.concat, M.empty));\n}\nexports.sortBy = 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/ReadonlyArray'\n *\n * const group = <A>(S: Eq<A>): ((as: ReadonlyArray<A>) => ReadonlyArray<ReadonlyArray<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.5.0\n */\nvar chop = function (f) { return function (as) {\n    // tslint:disable-next-line: readonly-array\n    var result = [];\n    var cs = as;\n    while (isNonEmpty(cs)) {\n        var _a = f(cs), b = _a[0], c = _a[1];\n        result.push(b);\n        cs = c;\n    }\n    return result;\n}; };\nexports.chop = chop;\n/**\n * Splits an array into two pieces, the first piece has `n` elements.\n *\n * @example\n * import { splitAt } from 'fp-ts/ReadonlyArray'\n *\n * assert.deepStrictEqual(splitAt(2)([1, 2, 3, 4, 5]), [[1, 2], [3, 4, 5]])\n *\n * @since 2.5.0\n */\nfunction splitAt(n) {\n    return function (as) { return [as.slice(0, n), as.slice(n)]; };\n}\nexports.splitAt = 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/ReadonlyArray'\n *\n * assert.deepStrictEqual(chunksOf(2)([1, 2, 3, 4, 5]), [[1, 2], [3, 4], [5]])\n *\n *\n * @since 2.5.0\n */\nfunction chunksOf(n) {\n    var f = exports.chop(splitAt(n));\n    return function (as) { return (as.length === 0 ? exports.empty : isOutOfBound(n - 1, as) ? [as] : f(as)); };\n}\nexports.chunksOf = chunksOf;\nfunction comprehension(input, f, g) {\n    if (g === void 0) { g = function () { return true; }; }\n    var go = function (scope, input) {\n        if (input.length === 0) {\n            return g.apply(void 0, scope) ? [f.apply(void 0, scope)] : exports.empty;\n        }\n        else {\n            return chain_(input[0], function (x) { return go(snoc(scope, x), input.slice(1)); });\n        }\n    };\n    return go(exports.empty, input);\n}\nexports.comprehension = comprehension;\nfunction union(E) {\n    var elemE = elem(E);\n    return function (xs, ys) {\n        if (ys === undefined) {\n            var unionE_1 = union(E);\n            return function (ys) { return unionE_1(ys, xs); };\n        }\n        return concat(xs, ys.filter(function (a) { return !elemE(a, xs); }));\n    };\n}\nexports.union = union;\nfunction intersection(E) {\n    var elemE = elem(E);\n    return function (xs, ys) {\n        if (ys === undefined) {\n            var intersectionE_1 = intersection(E);\n            return function (ys) { return intersectionE_1(ys, xs); };\n        }\n        return xs.filter(function (a) { return elemE(a, ys); });\n    };\n}\nexports.intersection = intersection;\nfunction difference(E) {\n    var elemE = elem(E);\n    return function (xs, ys) {\n        if (ys === undefined) {\n            var differenceE_1 = difference(E);\n            return function (ys) { return differenceE_1(ys, xs); };\n        }\n        return xs.filter(function (a) { return !elemE(a, ys); });\n    };\n}\nexports.difference = difference;\n/**\n * Wrap a value into the type constructor.\n *\n * @category Applicative\n * @since 2.5.0\n */\nvar of = function (a) { return [a]; };\nexports.of = of;\n/**\n * @category Alternative\n * @since 2.7.0\n */\nvar zero = function () { return exports.empty; };\nexports.zero = zero;\n// -------------------------------------------------------------------------------------\n// non-pipeables\n// -------------------------------------------------------------------------------------\nvar map_ = function (fa, f) { return function_1.pipe(fa, exports.map(f)); };\nvar mapWithIndex_ = function (fa, f) { return function_1.pipe(fa, exports.mapWithIndex(f)); };\nvar ap_ = function (fab, fa) { return function_1.pipe(fab, exports.ap(fa)); };\nvar chain_ = function (ma, f) {\n    return function_1.pipe(ma, exports.chain(f));\n};\nvar filter_ = function (fa, predicate) { return function_1.pipe(fa, exports.filter(predicate)); };\nvar filterMap_ = function (fa, f) { return function_1.pipe(fa, exports.filterMap(f)); };\nvar partitionWithIndex_ = function (fa, predicateWithIndex) { return function_1.pipe(fa, exports.partitionWithIndex(predicateWithIndex)); };\nvar partition_ = function (fa, predicate) { return function_1.pipe(fa, exports.partition(predicate)); };\nvar partitionMap_ = function (fa, f) { return function_1.pipe(fa, exports.partitionMap(f)); };\nvar partitionMapWithIndex_ = function (fa, f) { return function_1.pipe(fa, exports.partitionMapWithIndex(f)); };\nvar alt_ = function (fa, that) { return function_1.pipe(fa, exports.alt(that)); };\nvar reduce_ = function (fa, b, f) { return function_1.pipe(fa, exports.reduce(b, f)); };\nvar foldMap_ = function (M) {\n    var foldMapM = exports.foldMap(M);\n    return function (fa, f) { return function_1.pipe(fa, foldMapM(f)); };\n};\nvar reduceRight_ = function (fa, b, f) { return function_1.pipe(fa, exports.reduceRight(b, f)); };\nvar reduceWithIndex_ = function (fa, b, f) {\n    var l = fa.length;\n    var r = b;\n    for (var i = 0; i < l; i++) {\n        r = f(i, r, fa[i]);\n    }\n    return r;\n};\nvar foldMapWithIndex_ = function (M) { return function (fa, f) {\n    return fa.reduce(function (b, a, i) { return M.concat(b, f(i, a)); }, M.empty);\n}; };\nvar reduceRightWithIndex_ = function (fa, b, f) {\n    return function_1.pipe(fa, exports.reduceRightWithIndex(b, f));\n};\nvar filterMapWithIndex_ = function (fa, f) {\n    return function_1.pipe(fa, exports.filterMapWithIndex(f));\n};\nvar filterWithIndex_ = function (fa, predicateWithIndex) { return function_1.pipe(fa, exports.filterWithIndex(predicateWithIndex)); };\nvar extend_ = function (fa, f) { return function_1.pipe(fa, exports.extend(f)); };\nvar traverse_ = function (F) {\n    var traverseF = exports.traverse(F);\n    return function (ta, f) { return function_1.pipe(ta, traverseF(f)); };\n};\n/* istanbul ignore next */\nvar traverseWithIndex_ = function (F) {\n    var traverseWithIndexF = exports.traverseWithIndex(F);\n    return function (ta, f) { return function_1.pipe(ta, traverseWithIndexF(f)); };\n};\n/* istanbul ignore next */\nvar wither_ = function (F) {\n    var witherF = exports.wither(F);\n    return function (fa, f) { return function_1.pipe(fa, witherF(f)); };\n};\n/* istanbul ignore next */\nvar wilt_ = function (F) {\n    var wiltF = exports.wilt(F);\n    return function (fa, f) { return function_1.pipe(fa, wiltF(f)); };\n};\n// -------------------------------------------------------------------------------------\n// pipeables\n// -------------------------------------------------------------------------------------\n/**\n * Less strict version of [`alt`](#alt).\n *\n * @category Alt\n * @since 2.9.0\n */\nvar altW = function (that) { return function (fa) { return concat(fa, that()); }; };\nexports.altW = 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.5.0\n */\nexports.alt = exports.altW;\n/**\n * Apply a function to an argument under a type constructor.\n *\n * @category Apply\n * @since 2.5.0\n */\nvar ap = function (fa) {\n    return exports.chain(function (f) { return function_1.pipe(fa, exports.map(f)); });\n};\nexports.ap = 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.5.0\n */\nvar apFirst = function (fb) {\n    return function_1.flow(exports.map(function (a) { return function () { return a; }; }), exports.ap(fb));\n};\nexports.apFirst = 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.5.0\n */\nvar apSecond = function (fb) {\n    return function_1.flow(exports.map(function () { return function (b) { return b; }; }), exports.ap(fb));\n};\nexports.apSecond = 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.5.0\n */\nvar chain = function (f) { return function (ma) {\n    return function_1.pipe(ma, exports.chainWithIndex(function (_, a) { return f(a); }));\n}; };\nexports.chain = chain;\n/**\n * @since 2.7.0\n */\nvar chainWithIndex = function (f) { return function (ma) {\n    var outLen = 0;\n    var l = ma.length;\n    var temp = new Array(l);\n    for (var i = 0; i < l; i++) {\n        var e = ma[i];\n        var arr = f(i, e);\n        outLen += arr.length;\n        temp[i] = arr;\n    }\n    var out = Array(outLen);\n    var start = 0;\n    for (var i = 0; i < l; i++) {\n        var arr = temp[i];\n        var l_1 = arr.length;\n        for (var j = 0; j < l_1; j++) {\n            out[j + start] = arr[j];\n        }\n        start += l_1;\n    }\n    return out;\n}; };\nexports.chainWithIndex = 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.5.0\n */\nvar chainFirst = function (f) {\n    return exports.chain(function (a) {\n        return function_1.pipe(f(a), exports.map(function () { return a; }));\n    });\n};\nexports.chainFirst = chainFirst;\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.5.0\n */\nvar map = function (f) { return function (fa) {\n    return fa.map(function (a) { return f(a); });\n}; };\nexports.map = map;\n/**\n * @category FunctorWithIndex\n * @since 2.5.0\n */\nvar mapWithIndex = function (f) { return function (fa) { return fa.map(function (a, i) { return f(i, a); }); }; };\nexports.mapWithIndex = mapWithIndex;\n/**\n * @category Compactable\n * @since 2.5.0\n */\nvar separate = function (fa) {\n    // tslint:disable-next-line: readonly-array\n    var left = [];\n    // tslint:disable-next-line: readonly-array\n    var right = [];\n    for (var _i = 0, fa_1 = fa; _i < fa_1.length; _i++) {\n        var e = fa_1[_i];\n        if (e._tag === 'Left') {\n            left.push(e.left);\n        }\n        else {\n            right.push(e.right);\n        }\n    }\n    return {\n        left: left,\n        right: right\n    };\n};\nexports.separate = separate;\n/**\n * @category Filterable\n * @since 2.5.0\n */\nvar filter = function (predicate) { return function (fa) { return fa.filter(predicate); }; };\nexports.filter = filter;\n/**\n * @category FilterableWithIndex\n * @since 2.5.0\n */\nvar filterMapWithIndex = function (f) { return function (fa) {\n    // tslint:disable-next-line: readonly-array\n    var result = [];\n    for (var i = 0; i < fa.length; i++) {\n        var optionB = f(i, fa[i]);\n        if (O.isSome(optionB)) {\n            result.push(optionB.value);\n        }\n    }\n    return result;\n}; };\nexports.filterMapWithIndex = filterMapWithIndex;\n/**\n * @category Filterable\n * @since 2.5.0\n */\nvar filterMap = function (f) {\n    return exports.filterMapWithIndex(function (_, a) { return f(a); });\n};\nexports.filterMap = filterMap;\n/**\n * @category Compactable\n * @since 2.5.0\n */\nexports.compact = \n/*#__PURE__*/\nexports.filterMap(function_1.identity);\n/**\n * @category Filterable\n * @since 2.5.0\n */\nvar partition = function (predicate) {\n    return exports.partitionWithIndex(function (_, a) { return predicate(a); });\n};\nexports.partition = partition;\n/**\n * @category FilterableWithIndex\n * @since 2.5.0\n */\nvar partitionWithIndex = function (predicateWithIndex) { return function (fa) {\n    // tslint:disable-next-line: readonly-array\n    var left = [];\n    // tslint:disable-next-line: readonly-array\n    var right = [];\n    for (var i = 0; i < fa.length; i++) {\n        var a = fa[i];\n        if (predicateWithIndex(i, a)) {\n            right.push(a);\n        }\n        else {\n            left.push(a);\n        }\n    }\n    return {\n        left: left,\n        right: right\n    };\n}; };\nexports.partitionWithIndex = partitionWithIndex;\n/**\n * @category Filterable\n * @since 2.5.0\n */\nvar partitionMap = function (f) {\n    return exports.partitionMapWithIndex(function (_, a) { return f(a); });\n};\nexports.partitionMap = partitionMap;\n/**\n * @category FilterableWithIndex\n * @since 2.5.0\n */\nvar partitionMapWithIndex = function (f) { return function (fa) {\n    // tslint:disable-next-line: readonly-array\n    var left = [];\n    // tslint:disable-next-line: readonly-array\n    var right = [];\n    for (var i = 0; i < fa.length; i++) {\n        var e = f(i, fa[i]);\n        if (e._tag === 'Left') {\n            left.push(e.left);\n        }\n        else {\n            right.push(e.right);\n        }\n    }\n    return {\n        left: left,\n        right: right\n    };\n}; };\nexports.partitionMapWithIndex = partitionMapWithIndex;\n/**\n * @category FilterableWithIndex\n * @since 2.5.0\n */\nvar filterWithIndex = function (predicateWithIndex) { return function (fa) {\n    return fa.filter(function (a, i) { return predicateWithIndex(i, a); });\n}; };\nexports.filterWithIndex = filterWithIndex;\n/**\n * @category Extend\n * @since 2.5.0\n */\nvar extend = function (f) { return function (wa) { return wa.map(function (_, i, as) { return f(as.slice(i)); }); }; };\nexports.extend = extend;\n/**\n * Derivable from `Extend`.\n *\n * @category combinators\n * @since 2.5.0\n */\nexports.duplicate = \n/*#__PURE__*/\nexports.extend(function_1.identity);\n/**\n * @category FoldableWithIndex\n * @since 2.5.0\n */\nvar foldMapWithIndex = function (M) {\n    var foldMapWithIndexM = foldMapWithIndex_(M);\n    return function (f) { return function (fa) { return foldMapWithIndexM(fa, f); }; };\n};\nexports.foldMapWithIndex = foldMapWithIndex;\n/**\n * @category Foldable\n * @since 2.5.0\n */\nvar reduce = function (b, f) {\n    return exports.reduceWithIndex(b, function (_, b, a) { return f(b, a); });\n};\nexports.reduce = reduce;\n/**\n * @category Foldable\n * @since 2.5.0\n */\nvar foldMap = function (M) {\n    var foldMapWithIndexM = exports.foldMapWithIndex(M);\n    return function (f) { return foldMapWithIndexM(function (_, a) { return f(a); }); };\n};\nexports.foldMap = foldMap;\n/**\n * @category FoldableWithIndex\n * @since 2.5.0\n */\nvar reduceWithIndex = function (b, f) { return function (fa) { return reduceWithIndex_(fa, b, f); }; };\nexports.reduceWithIndex = reduceWithIndex;\n/**\n * @category Foldable\n * @since 2.5.0\n */\nvar reduceRight = function (b, f) {\n    return exports.reduceRightWithIndex(b, function (_, a, b) { return f(a, b); });\n};\nexports.reduceRight = reduceRight;\n/**\n * @category FoldableWithIndex\n * @since 2.5.0\n */\nvar reduceRightWithIndex = function (b, f) { return function (fa) { return fa.reduceRight(function (b, a, i) { return f(i, a, b); }, b); }; };\nexports.reduceRightWithIndex = reduceRightWithIndex;\n/**\n * **for optimized and stack safe version check the data types `traverseArray` function**\n * @category Traversable\n * @since 2.6.3\n */\nvar traverse = function (F) {\n    var traverseWithIndexF = exports.traverseWithIndex(F);\n    return function (f) { return traverseWithIndexF(function (_, a) { return f(a); }); };\n};\nexports.traverse = traverse;\n/**\n * **for optimized and stack safe version check the data types `sequenceArray` function**\n * @category Traversable\n * @since 2.6.3\n */\nvar sequence = function (F) { return function (ta) {\n    return reduce_(ta, F.of(exports.zero()), function (fas, fa) {\n        return F.ap(F.map(fas, function (as) { return function (a) { return snoc(as, a); }; }), fa);\n    });\n}; };\nexports.sequence = sequence;\n/**\n * **for optimized and stack safe version check the data types `traverseArrayWithIndex` function**\n * @category TraversableWithIndex\n * @since 2.6.3\n */\nvar traverseWithIndex = function (F) { return function (f) {\n    return exports.reduceWithIndex(F.of(exports.zero()), function (i, fbs, a) {\n        return F.ap(F.map(fbs, function (bs) { return function (b) { return snoc(bs, b); }; }), f(i, a));\n    });\n}; };\nexports.traverseWithIndex = traverseWithIndex;\n/**\n * @category Witherable\n * @since 2.6.5\n */\nvar wither = function (F) {\n    var traverseF = exports.traverse(F);\n    return function (f) { return function (fa) { return F.map(function_1.pipe(fa, traverseF(f)), exports.compact); }; };\n};\nexports.wither = wither;\n/**\n * @category Witherable\n * @since 2.6.5\n */\nvar wilt = function (F) {\n    var traverseF = exports.traverse(F);\n    return function (f) { return function (fa) { return F.map(function_1.pipe(fa, traverseF(f)), exports.separate); }; };\n};\nexports.wilt = wilt;\n/**\n * @category Unfoldable\n * @since 2.6.6\n */\nvar unfold = function (b, f) {\n    // tslint:disable-next-line: readonly-array\n    var ret = [];\n    var bb = b;\n    while (true) {\n        var mt = f(bb);\n        if (O.isSome(mt)) {\n            var _a = mt.value, a = _a[0], b_1 = _a[1];\n            ret.push(a);\n            bb = b_1;\n        }\n        else {\n            break;\n        }\n    }\n    return ret;\n};\nexports.unfold = unfold;\n// -------------------------------------------------------------------------------------\n// instances\n// -------------------------------------------------------------------------------------\n/**\n * @category instances\n * @since 2.5.0\n */\nexports.URI = 'ReadonlyArray';\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Functor = {\n    URI: exports.URI,\n    map: map_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.FunctorWithIndex = {\n    URI: exports.URI,\n    map: map_,\n    mapWithIndex: mapWithIndex_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Applicative = {\n    URI: exports.URI,\n    map: map_,\n    ap: ap_,\n    of: exports.of\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Monad = {\n    URI: exports.URI,\n    map: map_,\n    ap: ap_,\n    of: exports.of,\n    chain: chain_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Unfoldable = {\n    URI: exports.URI,\n    unfold: exports.unfold\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Alt = {\n    URI: exports.URI,\n    map: map_,\n    alt: alt_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Alternative = {\n    URI: exports.URI,\n    map: map_,\n    ap: ap_,\n    of: exports.of,\n    alt: alt_,\n    zero: exports.zero\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Extend = {\n    URI: exports.URI,\n    map: map_,\n    extend: extend_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Compactable = {\n    URI: exports.URI,\n    compact: exports.compact,\n    separate: exports.separate\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Filterable = {\n    URI: exports.URI,\n    map: map_,\n    compact: exports.compact,\n    separate: exports.separate,\n    filter: filter_,\n    filterMap: filterMap_,\n    partition: partition_,\n    partitionMap: partitionMap_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.FilterableWithIndex = {\n    URI: exports.URI,\n    map: map_,\n    mapWithIndex: mapWithIndex_,\n    compact: exports.compact,\n    separate: exports.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 */\nexports.Foldable = {\n    URI: exports.URI,\n    reduce: reduce_,\n    foldMap: foldMap_,\n    reduceRight: reduceRight_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.FoldableWithIndex = {\n    URI: exports.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 */\nexports.Traversable = {\n    URI: exports.URI,\n    map: map_,\n    reduce: reduce_,\n    foldMap: foldMap_,\n    reduceRight: reduceRight_,\n    traverse: traverse_,\n    sequence: exports.sequence\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.TraversableWithIndex = {\n    URI: exports.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: exports.sequence,\n    traverseWithIndex: traverseWithIndex_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Witherable = {\n    URI: exports.URI,\n    map: map_,\n    compact: exports.compact,\n    separate: exports.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: exports.sequence,\n    wither: wither_,\n    wilt: wilt_\n};\n// TODO: remove in v3\n/**\n * @category instances\n * @since 2.5.0\n */\nexports.readonlyArray = {\n    URI: exports.URI,\n    compact: exports.compact,\n    separate: exports.separate,\n    map: map_,\n    ap: ap_,\n    of: exports.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: exports.zero,\n    unfold: exports.unfold,\n    reduce: reduce_,\n    foldMap: foldMap_,\n    reduceRight: reduceRight_,\n    traverse: traverse_,\n    sequence: exports.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.5.0\n */\nfunction unsafeInsertAt(i, a, as) {\n    var xs = as.slice();\n    xs.splice(i, 0, a);\n    return xs;\n}\nexports.unsafeInsertAt = unsafeInsertAt;\n/**\n * @category unsafe\n * @since 2.5.0\n */\nfunction unsafeUpdateAt(i, a, as) {\n    if (as[i] === a) {\n        return as;\n    }\n    else {\n        var xs = as.slice();\n        xs[i] = a;\n        return xs;\n    }\n}\nexports.unsafeUpdateAt = unsafeUpdateAt;\n/**\n * @category unsafe\n * @since 2.5.0\n */\nfunction unsafeDeleteAt(i, as) {\n    var xs = as.slice();\n    xs.splice(i, 1);\n    return xs;\n}\nexports.unsafeDeleteAt = unsafeDeleteAt;\n// -------------------------------------------------------------------------------------\n// utils\n// -------------------------------------------------------------------------------------\n/**\n * An empty array\n *\n * @since 2.5.0\n */\nexports.empty = [];\n/**\n * Check if a predicate holds true for every array member.\n *\n * @example\n * import { every } from 'fp-ts/ReadonlyArray'\n * import { pipe } from 'fp-ts/function'\n *\n * const isPositive = (n: number): boolean => n > 0\n *\n * assert.deepStrictEqual(pipe([1, 2, 3], every(isPositive)), true)\n * assert.deepStrictEqual(pipe([1, 2, -3], every(isPositive)), false)\n *\n * @since 2.9.0\n */\nvar every = function (predicate) { return function (as) { return as.every(predicate); }; };\nexports.every = every;\n/**\n * Check if a predicate holds true for any array member.\n *\n * @example\n * import { some } from 'fp-ts/ReadonlyArray'\n * import { pipe } from 'fp-ts/function'\n *\n * const isPositive = (n: number): boolean => n > 0\n *\n * assert.deepStrictEqual(pipe([-1, -2, 3], some(isPositive)), true)\n * assert.deepStrictEqual(pipe([-1, -2, -3], some(isPositive)), false)\n *\n * @since 2.9.0\n */\nvar some = function (predicate) { return function (as) { return as.some(predicate); }; };\nexports.some = some;\n// -------------------------------------------------------------------------------------\n// do notation\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.9.0\n */\nexports.Do = \n/*#__PURE__*/\nexports.of({});\n/**\n * @since 2.8.0\n */\nvar bindTo = function (name) {\n    return exports.map(function_1.bindTo_(name));\n};\nexports.bindTo = bindTo;\n/**\n * @since 2.8.0\n */\nvar bind = function (name, f) {\n    return exports.chain(function (a) {\n        return function_1.pipe(f(a), exports.map(function (b) { return function_1.bind_(a, name, b); }));\n    });\n};\nexports.bind = bind;\n// -------------------------------------------------------------------------------------\n// pipeable sequence S\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.8.0\n */\nvar apS = function (name, fb) {\n    return function_1.flow(exports.map(function (a) { return function (b) { return function_1.bind_(a, name, b); }; }), exports.ap(fb));\n};\nexports.apS = apS;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.ord = exports.Contravariant = exports.ordDate = exports.URI = exports.contramap = exports.getDualOrd = exports.getTupleOrd = exports.getMonoid = exports.getSemigroup = exports.fromCompare = exports.between = exports.clamp = exports.max = exports.min = exports.geq = exports.leq = exports.gt = exports.lt = exports.ordBoolean = exports.ordNumber = exports.ordString = void 0;\nvar Ordering_1 = require(\"./Ordering\");\nvar function_1 = require(\"./function\");\n// default compare for primitive types\nfunction compare(x, y) {\n    return x < y ? -1 : x > y ? 1 : 0;\n}\nfunction strictEqual(a, b) {\n    return a === b;\n}\n/**\n * @category instances\n * @since 2.0.0\n */\nexports.ordString = {\n    equals: strictEqual,\n    compare: compare\n};\n/**\n * @category instances\n * @since 2.0.0\n */\nexports.ordNumber = {\n    equals: strictEqual,\n    compare: compare\n};\n/**\n * @category instances\n * @since 2.0.0\n */\nexports.ordBoolean = {\n    equals: strictEqual,\n    compare: compare\n};\n// TODO: curry in v3\n/**\n * Test whether one value is _strictly less than_ another\n *\n * @since 2.0.0\n */\nfunction lt(O) {\n    return function (x, y) { return O.compare(x, y) === -1; };\n}\nexports.lt = lt;\n// TODO: curry in v3\n/**\n * Test whether one value is _strictly greater than_ another\n *\n * @since 2.0.0\n */\nfunction gt(O) {\n    return function (x, y) { return O.compare(x, y) === 1; };\n}\nexports.gt = gt;\n// TODO: curry in v3\n/**\n * Test whether one value is _non-strictly less than_ another\n *\n * @since 2.0.0\n */\nfunction leq(O) {\n    return function (x, y) { return O.compare(x, y) !== 1; };\n}\nexports.leq = leq;\n// TODO: curry in v3\n/**\n * Test whether one value is _non-strictly greater than_ another\n *\n * @since 2.0.0\n */\nfunction geq(O) {\n    return function (x, y) { return O.compare(x, y) !== -1; };\n}\nexports.geq = geq;\n// TODO: curry in v3\n/**\n * Take the minimum of two values. If they are considered equal, the first argument is chosen\n *\n * @since 2.0.0\n */\nfunction min(O) {\n    return function (x, y) { return (O.compare(x, y) === 1 ? y : x); };\n}\nexports.min = min;\n// TODO: curry in v3\n/**\n * Take the maximum of two values. If they are considered equal, the first argument is chosen\n *\n * @since 2.0.0\n */\nfunction max(O) {\n    return function (x, y) { return (O.compare(x, y) === -1 ? y : x); };\n}\nexports.max = max;\n/**\n * Clamp a value between a minimum and a maximum\n *\n * @since 2.0.0\n */\nfunction clamp(O) {\n    var minO = min(O);\n    var maxO = max(O);\n    return function (low, hi) { return function (x) { return maxO(minO(x, hi), low); }; };\n}\nexports.clamp = clamp;\n/**\n * Test whether a value is between a minimum and a maximum (inclusive)\n *\n * @since 2.0.0\n */\nfunction between(O) {\n    var lessThanO = lt(O);\n    var greaterThanO = gt(O);\n    return function (low, hi) { return function (x) { return (lessThanO(x, low) || greaterThanO(x, hi) ? false : true); }; };\n}\nexports.between = between;\n/**\n * @category constructors\n * @since 2.0.0\n */\nfunction fromCompare(compare) {\n    var optimizedCompare = function (x, y) { return (x === y ? 0 : compare(x, y)); };\n    return {\n        equals: function (x, y) { return optimizedCompare(x, y) === 0; },\n        compare: optimizedCompare\n    };\n}\nexports.fromCompare = fromCompare;\n/**\n * Use `getMonoid` instead\n *\n * @category instances\n * @since 2.0.0\n * @deprecated\n */\nfunction getSemigroup() {\n    return {\n        concat: function (x, y) { return fromCompare(function (a, b) { return Ordering_1.monoidOrdering.concat(x.compare(a, b), y.compare(a, b)); }); }\n    };\n}\nexports.getSemigroup = getSemigroup;\n/**\n * Returns a `Monoid` such that:\n *\n * - its `concat(ord1, ord2)` operation will order first by `ord1`, and then by `ord2`\n * - its `empty` value is an `Ord` that always considers compared elements equal\n *\n * @example\n * import { sort } from 'fp-ts/Array'\n * import { contramap, getDualOrd, getMonoid, ordBoolean, ordNumber, ordString } from 'fp-ts/Ord'\n * import { pipe } from 'fp-ts/function'\n * import { fold } from 'fp-ts/Monoid'\n *\n * interface User {\n *   id: number\n *   name: string\n *   age: number\n *   rememberMe: boolean\n * }\n *\n * const byName = pipe(\n *   ordString,\n *   contramap((p: User) => p.name)\n * )\n *\n * const byAge = pipe(\n *   ordNumber,\n *   contramap((p: User) => p.age)\n * )\n *\n * const byRememberMe = pipe(\n *   ordBoolean,\n *   contramap((p: User) => p.rememberMe)\n * )\n *\n * const M = getMonoid<User>()\n *\n * const users: Array<User> = [\n *   { id: 1, name: 'Guido', age: 47, rememberMe: false },\n *   { id: 2, name: 'Guido', age: 46, rememberMe: true },\n *   { id: 3, name: 'Giulio', age: 44, rememberMe: false },\n *   { id: 4, name: 'Giulio', age: 44, rememberMe: true }\n * ]\n *\n * // sort by name, then by age, then by `rememberMe`\n * const O1 = fold(M)([byName, byAge, byRememberMe])\n * assert.deepStrictEqual(sort(O1)(users), [\n *   { id: 3, name: 'Giulio', age: 44, rememberMe: false },\n *   { id: 4, name: 'Giulio', age: 44, rememberMe: true },\n *   { id: 2, name: 'Guido', age: 46, rememberMe: true },\n *   { id: 1, name: 'Guido', age: 47, rememberMe: false }\n * ])\n *\n * // now `rememberMe = true` first, then by name, then by age\n * const O2 = fold(M)([getDualOrd(byRememberMe), byName, byAge])\n * assert.deepStrictEqual(sort(O2)(users), [\n *   { id: 4, name: 'Giulio', age: 44, rememberMe: true },\n *   { id: 2, name: 'Guido', age: 46, rememberMe: true },\n *   { id: 3, name: 'Giulio', age: 44, rememberMe: false },\n *   { id: 1, name: 'Guido', age: 47, rememberMe: false }\n * ])\n *\n * @category instances\n * @since 2.4.0\n */\nfunction getMonoid() {\n    return {\n        // tslint:disable-next-line: deprecation\n        concat: getSemigroup().concat,\n        empty: fromCompare(function () { return 0; })\n    };\n}\nexports.getMonoid = getMonoid;\n/**\n * Given a tuple of `Ord`s returns an `Ord` for the tuple\n *\n * @example\n * import { getTupleOrd, ordString, ordNumber, ordBoolean } from 'fp-ts/Ord'\n *\n * const O = getTupleOrd(ordString, ordNumber, ordBoolean)\n * assert.strictEqual(O.compare(['a', 1, true], ['b', 2, true]), -1)\n * assert.strictEqual(O.compare(['a', 1, true], ['a', 2, true]), -1)\n * assert.strictEqual(O.compare(['a', 1, true], ['a', 1, false]), 1)\n *\n * @category instances\n * @since 2.0.0\n */\nfunction getTupleOrd() {\n    var ords = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        ords[_i] = arguments[_i];\n    }\n    var len = ords.length;\n    return fromCompare(function (x, y) {\n        var i = 0;\n        for (; i < len - 1; i++) {\n            var r = ords[i].compare(x[i], y[i]);\n            if (r !== 0) {\n                return r;\n            }\n        }\n        return ords[i].compare(x[i], y[i]);\n    });\n}\nexports.getTupleOrd = getTupleOrd;\n/**\n * @category combinators\n * @since 2.0.0\n */\nfunction getDualOrd(O) {\n    return fromCompare(function (x, y) { return O.compare(y, x); });\n}\nexports.getDualOrd = getDualOrd;\n// -------------------------------------------------------------------------------------\n// non-pipeables\n// -------------------------------------------------------------------------------------\n/* istanbul ignore next */\nvar contramap_ = function (fa, f) { return function_1.pipe(fa, exports.contramap(f)); };\n// -------------------------------------------------------------------------------------\n// pipeables\n// -------------------------------------------------------------------------------------\n/**\n * @category Contravariant\n * @since 2.0.0\n */\nvar contramap = function (f) { return function (fa) {\n    return fromCompare(function (x, y) { return fa.compare(f(x), f(y)); });\n}; };\nexports.contramap = contramap;\n// -------------------------------------------------------------------------------------\n// instances\n// -------------------------------------------------------------------------------------\n/**\n * @category instances\n * @since 2.0.0\n */\nexports.URI = 'Ord';\n/**\n * @category instances\n * @since 2.0.0\n */\nexports.ordDate = \n/*#__PURE__*/\nfunction_1.pipe(exports.ordNumber, \n/*#__PURE__*/\nexports.contramap(function (date) { return date.valueOf(); }));\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Contravariant = {\n    URI: exports.URI,\n    contramap: contramap_\n};\n// TODO: remove in v3\n/**\n * @category instances\n * @since 2.0.0\n */\nexports.ord = exports.Contravariant;\n","\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n    o[\"default\"] = v;\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 (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n    __setModuleDefault(result, mod);\n    return result;\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.reduceRight = exports.reduceWithIndex = exports.reduce = exports.mapWithIndex = exports.map = exports.flatten = exports.extend = exports.duplicate = exports.chainFirst = exports.chain = exports.apSecond = exports.apFirst = exports.ap = exports.alt = exports.altW = exports.foldMap = exports.foldMapWithIndex = exports.intersperse = exports.prependToAll = exports.unzip = exports.zip = exports.zipWith = exports.fold = exports.concat = exports.of = exports.filterWithIndex = exports.filter = exports.copy = exports.modifyAt = exports.updateAt = exports.insertAt = exports.sort = exports.init = exports.last = exports.groupBy = exports.groupSort = exports.group = exports.getEq = exports.getSemigroup = exports.max = exports.min = exports.reverse = exports.tail = exports.head = exports.getShow = exports.unsnoc = exports.uncons = exports.fromArray = exports.snoc = exports.cons = void 0;\nexports.apS = exports.bind = exports.bindTo = exports.Do = exports.nonEmptyArray = exports.Comonad = exports.Alt = exports.TraversableWithIndex = exports.Traversable = exports.FoldableWithIndex = exports.Foldable = exports.Monad = exports.Applicative = exports.FunctorWithIndex = exports.Functor = exports.URI = exports.extract = exports.traverseWithIndex = exports.sequence = exports.traverse = exports.reduceRightWithIndex = void 0;\nvar RNEA = __importStar(require(\"./ReadonlyNonEmptyArray\"));\n/* tslint:enable:readonly-keyword */\n/**\n * Append an element to the front of an array, creating a new non empty array\n *\n * @example\n * import { cons } from 'fp-ts/NonEmptyArray'\n *\n * assert.deepStrictEqual(cons(1, [2, 3, 4]), [1, 2, 3, 4])\n *\n * @category constructors\n * @since 2.0.0\n */\nexports.cons = RNEA.cons;\n/**\n * Append an element to the end of an array, creating a new non empty array\n *\n * @example\n * import { snoc } from 'fp-ts/NonEmptyArray'\n *\n * assert.deepStrictEqual(snoc([1, 2, 3], 4), [1, 2, 3, 4])\n *\n * @category constructors\n * @since 2.0.0\n */\nexports.snoc = RNEA.snoc;\n/**\n * Builds a `NonEmptyArray` from an `Array` returning `none` if `as` is an empty array\n *\n * @category constructors\n * @since 2.0.0\n */\nexports.fromArray = RNEA.fromArray;\n/**\n * Produces a couple of the first element of the array, and a new array of the remaining elements, if any\n *\n * @example\n * import { cons, uncons } from 'fp-ts/NonEmptyArray'\n *\n * assert.deepStrictEqual(uncons(cons(1, [2, 3, 4])), [1, [2, 3, 4]])\n *\n * @category destructors\n * @since 2.9.0\n */\nexports.uncons = RNEA.uncons;\n/**\n * Produces a couple of a copy of the array without its last element, and that last element\n *\n * @example\n * import { snoc, unsnoc } from 'fp-ts/NonEmptyArray'\n *\n * assert.deepStrictEqual(unsnoc(snoc([1, 2, 3], 4)), [[1, 2, 3], 4])\n *\n * @category destructors\n * @since 2.9.0\n */\nexports.unsnoc = RNEA.unsnoc;\n/**\n * @category instances\n * @since 2.0.0\n */\nexports.getShow = RNEA.getShow;\n/**\n * @since 2.0.0\n */\nexports.head = RNEA.head;\n/**\n * @since 2.0.0\n */\nexports.tail = RNEA.tail;\n/**\n * @category combinators\n * @since 2.0.0\n */\nexports.reverse = RNEA.reverse;\n/**\n * @since 2.0.0\n */\nexports.min = RNEA.min;\n/**\n * @since 2.0.0\n */\nexports.max = RNEA.max;\n/**\n * Builds a `Semigroup` instance for `NonEmptyArray`\n *\n * @category instances\n * @since 2.0.0\n */\nexports.getSemigroup = RNEA.getSemigroup;\n/**\n * @example\n * import { getEq, cons } from 'fp-ts/NonEmptyArray'\n * import { eqNumber } from 'fp-ts/Eq'\n *\n * const E = getEq(eqNumber)\n * assert.strictEqual(E.equals(cons(1, [2]), [1, 2]), true)\n * assert.strictEqual(E.equals(cons(1, [2]), [1, 3]), false)\n *\n * @category instances\n * @since 2.0.0\n */\nexports.getEq = RNEA.getEq;\nfunction group(E) {\n    return RNEA.group(E);\n}\nexports.group = group;\n/**\n * Sort and then group the elements of an array into non empty arrays.\n *\n * @example\n * import { cons, groupSort } from 'fp-ts/NonEmptyArray'\n * import { ordNumber } from 'fp-ts/Ord'\n *\n * assert.deepStrictEqual(groupSort(ordNumber)([1, 2, 1, 1]), [cons(1, [1, 1]), cons(2, [])])\n *\n * @category combinators\n * @since 2.0.0\n */\nexports.groupSort = RNEA.groupSort;\n/**\n * Splits an array into sub-non-empty-arrays stored in an object, based on the result of calling a `string`-returning\n * function on each element, and grouping the results according to values returned\n *\n * @example\n * import { cons, groupBy } from 'fp-ts/NonEmptyArray'\n *\n * assert.deepStrictEqual(groupBy((s: string) => String(s.length))(['foo', 'bar', 'foobar']), {\n *   '3': cons('foo', ['bar']),\n *   '6': cons('foobar', [])\n * })\n *\n * @category constructors\n * @since 2.0.0\n */\nexports.groupBy = RNEA.groupBy;\n/**\n * @since 2.0.0\n */\nexports.last = RNEA.last;\n/**\n * Get all but the last element of a non empty array, creating a new array.\n *\n * @example\n * import { init } from 'fp-ts/NonEmptyArray'\n *\n * assert.deepStrictEqual(init([1, 2, 3]), [1, 2])\n * assert.deepStrictEqual(init([1]), [])\n *\n * @since 2.2.0\n */\nexports.init = RNEA.init;\n/**\n * @category combinators\n * @since 2.0.0\n */\nexports.sort = RNEA.sort;\n/**\n * @since 2.0.0\n */\nexports.insertAt = RNEA.insertAt;\n/**\n * @since 2.0.0\n */\nexports.updateAt = RNEA.updateAt;\n/**\n * @since 2.0.0\n */\nexports.modifyAt = RNEA.modifyAt;\n/**\n * @category combinators\n * @since 2.0.0\n */\nfunction copy(nea) {\n    var l = nea.length;\n    var as = Array(l);\n    for (var i = 0; i < l; i++) {\n        as[i] = nea[i];\n    }\n    return as;\n}\nexports.copy = copy;\nfunction filter(predicate) {\n    return RNEA.filter(predicate);\n}\nexports.filter = filter;\n/**\n * @since 2.0.0\n */\nexports.filterWithIndex = RNEA.filterWithIndex;\n/**\n * Wrap a value into the type constructor.\n *\n * @category Applicative\n * @since 2.0.0\n */\nexports.of = RNEA.of;\nfunction concat(fx, fy) {\n    return RNEA.concat(fx, fy);\n}\nexports.concat = concat;\n/**\n * @since 2.5.0\n */\nexports.fold = RNEA.fold;\n/**\n * @category combinators\n * @since 2.5.1\n */\nexports.zipWith = RNEA.zipWith;\n/**\n * @category combinators\n * @since 2.5.1\n */\nexports.zip = RNEA.zip;\n/**\n * @since 2.5.1\n */\nexports.unzip = RNEA.unzip;\n/**\n * Prepend an element to every member of an array\n *\n * @example\n * import { cons, prependToAll } from 'fp-ts/NonEmptyArray'\n *\n * assert.deepStrictEqual(prependToAll(9)(cons(1, [2, 3, 4])), cons(9, [1, 9, 2, 9, 3, 9, 4]))\n *\n * @category combinators\n * @since 2.9.0\n */\nexports.prependToAll = RNEA.prependToAll;\n/**\n * Places an element in between members of an array\n *\n * @example\n * import { cons, intersperse } from 'fp-ts/NonEmptyArray'\n *\n * assert.deepStrictEqual(intersperse(9)(cons(1, [2, 3, 4])), cons(1, [9, 2, 9, 3, 9, 4]))\n *\n * @category combinators\n * @since 2.9.0\n */\nexports.intersperse = RNEA.intersperse;\n// -------------------------------------------------------------------------------------\n// non-pipeables\n// -------------------------------------------------------------------------------------\nvar map_ = RNEA.Functor.map;\nvar mapWithIndex_ = RNEA.FunctorWithIndex.mapWithIndex;\nvar ap_ = RNEA.Applicative.ap;\nvar chain_ = RNEA.Monad.chain;\nvar extend_ = RNEA.Comonad.extend;\nvar reduce_ = RNEA.Foldable.reduce;\nvar foldMap_ = RNEA.Foldable.foldMap;\nvar reduceRight_ = RNEA.Foldable.reduceRight;\nvar traverse_ = RNEA.Traversable.traverse;\nvar alt_ = RNEA.Alt.alt;\nvar reduceWithIndex_ = RNEA.FoldableWithIndex\n    .reduceWithIndex;\nvar foldMapWithIndex_ = RNEA.FoldableWithIndex\n    .foldMapWithIndex;\nvar reduceRightWithIndex_ = RNEA.FoldableWithIndex\n    .reduceRightWithIndex;\nvar traverseWithIndex_ = RNEA.TraversableWithIndex\n    .traverseWithIndex;\n// -------------------------------------------------------------------------------------\n// pipeables\n// -------------------------------------------------------------------------------------\n/**\n * @category FoldableWithIndex\n * @since 2.0.0\n */\nexports.foldMapWithIndex = RNEA.foldMapWithIndex;\n/**\n * @category Foldable\n * @since 2.0.0\n */\nexports.foldMap = RNEA.foldMap;\n/**\n * Less strict version of [`alt`](#alt).\n *\n * @category Alt\n * @since 2.9.0\n */\nexports.altW = RNEA.altW;\n/**\n * Identifies an associative operation on a type constructor. It is similar to `Semigroup`, except that it applies to\n * types of kind `* -> *`.\n *\n * @category Alt\n * @since 2.6.2\n */\nexports.alt = RNEA.alt;\n/**\n * Apply a function to an argument under a type constructor.\n *\n * @category Apply\n * @since 2.0.0\n */\nexports.ap = RNEA.ap;\n/**\n * Combine two effectful actions, keeping only the result of the first.\n *\n * Derivable from `Apply`.\n *\n * @category combinators\n * @since 2.0.0\n */\nexports.apFirst = RNEA.apFirst;\n/**\n * Combine two effectful actions, keeping only the result of the second.\n *\n * Derivable from `Apply`.\n *\n * @category combinators\n * @since 2.0.0\n */\nexports.apSecond = RNEA.apSecond;\n/**\n * Composes computations in sequence, using the return value of one computation to determine the next computation.\n *\n * @category Monad\n * @since 2.0.0\n */\nexports.chain = RNEA.chain;\n/**\n * Composes computations in sequence, using the return value of one computation to determine the next computation and\n * keeping only the result of the first.\n *\n * Derivable from `Monad`.\n *\n * @category combinators\n * @since 2.0.0\n */\nexports.chainFirst = RNEA.chainFirst;\n/**\n * Derivable from `Extend`.\n *\n * @category combinators\n * @since 2.0.0\n */\nexports.duplicate = RNEA.duplicate;\n/**\n * @category Extend\n * @since 2.0.0\n */\nexports.extend = RNEA.extend;\n/**\n * Derivable from `Monad`.\n *\n * @category combinators\n * @since 2.0.0\n */\nexports.flatten = RNEA.flatten;\n/**\n * `map` can be used to turn functions `(a: A) => B` into functions `(fa: F<A>) => F<B>` whose argument and return types\n * use the type constructor `F` to represent some computational context.\n *\n * @category Functor\n * @since 2.0.0\n */\nexports.map = RNEA.map;\n/**\n * @category FunctorWithIndex\n * @since 2.0.0\n */\nexports.mapWithIndex = RNEA.mapWithIndex;\n/**\n * @category Foldable\n * @since 2.0.0\n */\nexports.reduce = RNEA.reduce;\n/**\n * @category FoldableWithIndex\n * @since 2.0.0\n */\nexports.reduceWithIndex = RNEA.reduceWithIndex;\n/**\n * @category Foldable\n * @since 2.0.0\n */\nexports.reduceRight = RNEA.reduceRight;\n/**\n * @category FoldableWithIndex\n * @since 2.0.0\n */\nexports.reduceRightWithIndex = RNEA.reduceRightWithIndex;\n/**\n * @since 2.6.3\n */\nexports.traverse = RNEA.traverse;\n/**\n * @since 2.6.3\n */\nexports.sequence = RNEA.sequence;\n/**\n * @since 2.6.3\n */\nexports.traverseWithIndex = RNEA.traverseWithIndex;\n/**\n * @since 2.7.0\n */\nexports.extract = exports.head;\n// -------------------------------------------------------------------------------------\n// instances\n// -------------------------------------------------------------------------------------\n/**\n * @category instances\n * @since 2.0.0\n */\nexports.URI = 'NonEmptyArray';\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Functor = {\n    URI: exports.URI,\n    map: map_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.FunctorWithIndex = {\n    URI: exports.URI,\n    map: map_,\n    mapWithIndex: mapWithIndex_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Applicative = {\n    URI: exports.URI,\n    map: map_,\n    ap: ap_,\n    of: exports.of\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Monad = {\n    URI: exports.URI,\n    map: map_,\n    ap: ap_,\n    of: exports.of,\n    chain: chain_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Foldable = {\n    URI: exports.URI,\n    reduce: reduce_,\n    foldMap: foldMap_,\n    reduceRight: reduceRight_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.FoldableWithIndex = {\n    URI: exports.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 */\nexports.Traversable = {\n    URI: exports.URI,\n    map: map_,\n    reduce: reduce_,\n    foldMap: foldMap_,\n    reduceRight: reduceRight_,\n    traverse: traverse_,\n    sequence: exports.sequence\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.TraversableWithIndex = {\n    URI: exports.URI,\n    map: map_,\n    mapWithIndex: mapWithIndex_,\n    reduce: reduce_,\n    foldMap: foldMap_,\n    reduceRight: reduceRight_,\n    traverse: traverse_,\n    sequence: exports.sequence,\n    reduceWithIndex: reduceWithIndex_,\n    foldMapWithIndex: foldMapWithIndex_,\n    reduceRightWithIndex: reduceRightWithIndex_,\n    traverseWithIndex: traverseWithIndex_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Alt = {\n    URI: exports.URI,\n    map: map_,\n    alt: alt_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Comonad = {\n    URI: exports.URI,\n    map: map_,\n    extend: extend_,\n    extract: exports.extract\n};\n// TODO: remove in v3\n/**\n * @category instances\n * @since 2.0.0\n */\nexports.nonEmptyArray = {\n    URI: exports.URI,\n    of: exports.of,\n    map: map_,\n    mapWithIndex: mapWithIndex_,\n    ap: ap_,\n    chain: chain_,\n    extend: extend_,\n    extract: exports.extract,\n    reduce: reduce_,\n    foldMap: foldMap_,\n    reduceRight: reduceRight_,\n    traverse: traverse_,\n    sequence: exports.sequence,\n    reduceWithIndex: reduceWithIndex_,\n    foldMapWithIndex: foldMapWithIndex_,\n    reduceRightWithIndex: reduceRightWithIndex_,\n    traverseWithIndex: traverseWithIndex_,\n    alt: alt_\n};\n// -------------------------------------------------------------------------------------\n// do notation\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.9.0\n */\nexports.Do = \n/*#__PURE__*/\nexports.of({});\n/**\n * @since 2.8.0\n */\nexports.bindTo = RNEA.bindTo;\n/**\n * @since 2.8.0\n */\nexports.bind = RNEA.bind;\n// -------------------------------------------------------------------------------------\n// pipeable sequence S\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.8.0\n */\nexports.apS = RNEA.apS;\n","\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n    o[\"default\"] = v;\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 (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n    __setModuleDefault(result, mod);\n    return result;\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.reduceRight = exports.reduceWithIndex = exports.reduce = exports.mapWithIndex = exports.map = exports.flatten = exports.extend = exports.duplicate = exports.chainFirst = exports.chain = exports.apSecond = exports.apFirst = exports.ap = exports.alt = exports.altW = exports.foldMap = exports.foldMapWithIndex = exports.intersperse = exports.prependToAll = exports.unzip = exports.zip = exports.zipWith = exports.fold = exports.concat = exports.of = exports.filterWithIndex = exports.filter = exports.modifyAt = exports.updateAt = exports.insertAt = exports.sort = exports.init = exports.last = exports.groupBy = exports.groupSort = exports.group = exports.getEq = exports.getSemigroup = exports.max = exports.min = exports.reverse = exports.tail = exports.head = exports.getShow = exports.unsnoc = exports.uncons = exports.fromArray = exports.fromReadonlyArray = exports.snoc = exports.cons = void 0;\nexports.apS = exports.bind = exports.bindTo = exports.Do = exports.readonlyNonEmptyArray = exports.Comonad = exports.Alt = exports.TraversableWithIndex = exports.Traversable = exports.FoldableWithIndex = exports.Foldable = exports.Monad = exports.Applicative = exports.FunctorWithIndex = exports.Functor = exports.URI = exports.extract = exports.traverseWithIndex = exports.sequence = exports.traverse = exports.reduceRightWithIndex = void 0;\nvar function_1 = require(\"./function\");\nvar Option_1 = require(\"./Option\");\nvar RA = __importStar(require(\"./ReadonlyArray\"));\nvar Semigroup_1 = require(\"./Semigroup\");\n/**\n * Append an element to the front of an array, creating a new non empty array\n *\n * @example\n * import { cons } from 'fp-ts/ReadonlyNonEmptyArray'\n *\n * assert.deepStrictEqual(cons(1, [2, 3, 4]), [1, 2, 3, 4])\n *\n * @category constructors\n * @since 2.5.0\n */\nexports.cons = RA.cons;\n/**\n * Append an element to the end of an array, creating a new non empty array\n *\n * @example\n * import { snoc } from 'fp-ts/ReadonlyNonEmptyArray'\n *\n * assert.deepStrictEqual(snoc([1, 2, 3], 4), [1, 2, 3, 4])\n *\n * @category constructors\n * @since 2.5.0\n */\nexports.snoc = RA.snoc;\n/**\n * Builds a `ReadonlyNonEmptyArray` from an array returning `none` if `as` is an empty array\n *\n * @category constructors\n * @since 2.5.0\n */\nfunction fromReadonlyArray(as) {\n    return RA.isNonEmpty(as) ? Option_1.some(as) : Option_1.none;\n}\nexports.fromReadonlyArray = fromReadonlyArray;\n/**\n * @category constructors\n * @since 2.5.0\n */\n// tslint:disable-next-line: readonly-array\nfunction fromArray(as) {\n    return fromReadonlyArray(RA.fromArray(as));\n}\nexports.fromArray = fromArray;\n/**\n * Produces a couple of the first element of the array, and a new array of the remaining elements, if any\n *\n * @example\n * import { cons, uncons } from 'fp-ts/ReadonlyNonEmptyArray'\n *\n * assert.deepStrictEqual(uncons(cons(1, [2, 3, 4])), [1, [2, 3, 4]])\n *\n * @category destructors\n * @since 2.9.0\n */\nfunction uncons(nea) {\n    return [nea[0], nea.slice(1)];\n}\nexports.uncons = uncons;\n/**\n * Produces a couple of a copy of the array without its last element, and that last element\n *\n * @example\n * import { snoc, unsnoc } from 'fp-ts/ReadonlyNonEmptyArray'\n *\n * assert.deepStrictEqual(unsnoc(snoc([1, 2, 3], 4)), [[1, 2, 3], 4])\n *\n * @category destructors\n * @since 2.9.0\n */\nfunction unsnoc(nea) {\n    var l = nea.length - 1;\n    return [nea.slice(0, l), nea[l]];\n}\nexports.unsnoc = unsnoc;\n/**\n * @category instances\n * @since 2.5.0\n */\nexports.getShow = RA.getShow;\n/**\n * @since 2.5.0\n */\nfunction head(nea) {\n    return nea[0];\n}\nexports.head = head;\n/**\n * @since 2.5.0\n */\nfunction tail(nea) {\n    return nea.slice(1);\n}\nexports.tail = tail;\n/**\n * @category combinators\n * @since 2.5.0\n */\nexports.reverse = RA.reverse;\n/**\n * @since 2.5.0\n */\nfunction min(ord) {\n    var S = Semigroup_1.getMeetSemigroup(ord);\n    return function (nea) { return nea.reduce(S.concat); };\n}\nexports.min = min;\n/**\n * @since 2.5.0\n */\nfunction max(ord) {\n    var S = Semigroup_1.getJoinSemigroup(ord);\n    return function (nea) { return nea.reduce(S.concat); };\n}\nexports.max = max;\n/**\n * Builds a `Semigroup` instance for `ReadonlyNonEmptyArray`\n *\n * @category instances\n * @since 2.5.0\n */\nfunction getSemigroup() {\n    return {\n        concat: concat\n    };\n}\nexports.getSemigroup = getSemigroup;\n/**\n * @example\n * import { getEq, cons } from 'fp-ts/ReadonlyNonEmptyArray'\n * import { eqNumber } from 'fp-ts/Eq'\n *\n * const E = getEq(eqNumber)\n * assert.strictEqual(E.equals(cons(1, [2]), [1, 2]), true)\n * assert.strictEqual(E.equals(cons(1, [2]), [1, 3]), false)\n *\n * @category instances\n * @since 2.5.0\n */\nexports.getEq = RA.getEq;\nfunction group(E) {\n    return function (as) {\n        var len = as.length;\n        if (len === 0) {\n            return RA.empty;\n        }\n        // tslint:disable-next-line: readonly-array\n        var r = [];\n        var head = as[0];\n        var nea = [head];\n        for (var i = 1; i < len; i++) {\n            var x = as[i];\n            if (E.equals(x, head)) {\n                nea.push(x);\n            }\n            else {\n                r.push(nea);\n                head = x;\n                nea = [head];\n            }\n        }\n        r.push(nea);\n        return r;\n    };\n}\nexports.group = group;\nfunction groupSort(O) {\n    var sortO = RA.sort(O);\n    var groupO = group(O);\n    return function (as) { return groupO(sortO(as)); };\n}\nexports.groupSort = groupSort;\n/**\n * Splits an array into sub-non-empty-arrays stored in an object, based on the result of calling a `string`-returning\n * function on each element, and grouping the results according to values returned\n *\n * @example\n * import { cons, groupBy } from 'fp-ts/ReadonlyNonEmptyArray'\n *\n * assert.deepStrictEqual(groupBy((s: string) => String(s.length))(['foo', 'bar', 'foobar']), {\n *   '3': cons('foo', ['bar']),\n *   '6': cons('foobar', [])\n * })\n *\n * @category constructors\n * @since 2.5.0\n */\nfunction groupBy(f) {\n    return function (as) {\n        var r = {};\n        for (var _i = 0, as_1 = as; _i < as_1.length; _i++) {\n            var a = as_1[_i];\n            var k = f(a);\n            if (r.hasOwnProperty(k)) {\n                r[k].push(a);\n            }\n            else {\n                r[k] = [a];\n            }\n        }\n        return r;\n    };\n}\nexports.groupBy = groupBy;\n/**\n * @since 2.5.0\n */\nfunction last(nea) {\n    return nea[nea.length - 1];\n}\nexports.last = last;\n/**\n * Get all but the last element of a non empty array, creating a new array.\n *\n * @example\n * import { init } from 'fp-ts/ReadonlyNonEmptyArray'\n *\n * assert.deepStrictEqual(init([1, 2, 3]), [1, 2])\n * assert.deepStrictEqual(init([1]), [])\n *\n * @since 2.5.0\n */\nfunction init(nea) {\n    return nea.slice(0, -1);\n}\nexports.init = init;\n/**\n * @category combinators\n * @since 2.5.0\n */\nfunction sort(O) {\n    return RA.sort(O);\n}\nexports.sort = sort;\n/**\n * @since 2.5.0\n */\nfunction insertAt(i, a) {\n    return RA.insertAt(i, a);\n}\nexports.insertAt = insertAt;\n/**\n * @since 2.5.0\n */\nfunction updateAt(i, a) {\n    return RA.updateAt(i, a);\n}\nexports.updateAt = updateAt;\n/**\n * @since 2.5.0\n */\nfunction modifyAt(i, f) {\n    return RA.modifyAt(i, f);\n}\nexports.modifyAt = modifyAt;\nfunction filter(predicate) {\n    return filterWithIndex(function (_, a) { return predicate(a); });\n}\nexports.filter = filter;\n/**\n * @since 2.5.0\n */\nfunction filterWithIndex(predicate) {\n    return function (nea) { return fromReadonlyArray(nea.filter(function (a, i) { return predicate(i, a); })); };\n}\nexports.filterWithIndex = filterWithIndex;\n/**\n * Wrap a value into the type constructor.\n *\n * @category Applicative\n * @since 2.5.0\n */\nexports.of = RA.of;\nfunction concat(fx, fy) {\n    return fx.concat(fy);\n}\nexports.concat = concat;\n/**\n * @since 2.5.0\n */\nfunction fold(S) {\n    return function (fa) { return fa.reduce(S.concat); };\n}\nexports.fold = fold;\n/**\n * @category combinators\n * @since 2.5.1\n */\nexports.zipWith = RA.zipWith;\n/**\n * @category combinators\n * @since 2.5.1\n */\nexports.zip = RA.zip;\n/**\n * @since 2.5.1\n */\nexports.unzip = RA.unzip;\n/**\n * Prepend an element to every member of an array\n *\n * @example\n * import { cons, prependToAll } from 'fp-ts/ReadonlyNonEmptyArray'\n *\n * assert.deepStrictEqual(prependToAll(9)(cons(1, [2, 3, 4])), cons(9, [1, 9, 2, 9, 3, 9, 4]))\n *\n * @category combinators\n * @since 2.9.0\n */\nexports.prependToAll = RA.prependToAll;\n/**\n * Places an element in between members of an array\n *\n * @example\n * import { cons, intersperse } from 'fp-ts/ReadonlyNonEmptyArray'\n *\n * assert.deepStrictEqual(intersperse(9)(cons(1, [2, 3, 4])), cons(1, [9, 2, 9, 3, 9, 4]))\n *\n * @category combinators\n * @since 2.9.0\n */\nexports.intersperse = RA.intersperse;\n// -------------------------------------------------------------------------------------\n// non-pipeables\n// -------------------------------------------------------------------------------------\nvar map_ = RA.Functor.map;\nvar mapWithIndex_ = RA.FunctorWithIndex.mapWithIndex;\nvar ap_ = RA.Applicative.ap;\nvar chain_ = RA.Monad.chain;\nvar extend_ = RA.Extend.extend;\nvar reduce_ = RA.Foldable.reduce;\nvar foldMap_ = RA.Foldable.foldMap;\nvar reduceRight_ = RA.Foldable.reduceRight;\nvar traverse_ = RA.Traversable.traverse;\nvar alt_ = RA.Alt.alt;\nvar reduceWithIndex_ = RA.FoldableWithIndex.reduceWithIndex;\nvar foldMapWithIndex_ = RA.FoldableWithIndex\n    .foldMapWithIndex;\nvar reduceRightWithIndex_ = RA.FoldableWithIndex\n    .reduceRightWithIndex;\nvar traverseWithIndex_ = RA.TraversableWithIndex\n    .traverseWithIndex;\n// -------------------------------------------------------------------------------------\n// pipeables\n// -------------------------------------------------------------------------------------\n/**\n * @category FoldableWithIndex\n * @since 2.5.0\n */\nvar foldMapWithIndex = function (S) { return function (f) { return function (fa) { return fa.slice(1).reduce(function (s, a, i) { return S.concat(s, f(i + 1, a)); }, f(0, fa[0])); }; }; };\nexports.foldMapWithIndex = foldMapWithIndex;\n/**\n * @category Foldable\n * @since 2.5.0\n */\nvar foldMap = function (S) { return function (f) { return function (fa) {\n    return fa.slice(1).reduce(function (s, a) { return S.concat(s, f(a)); }, f(fa[0]));\n}; }; };\nexports.foldMap = foldMap;\n/**\n * Less strict version of [`alt`](#alt).\n *\n * @category Alt\n * @since 2.9.0\n */\nexports.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.6.2\n */\nexports.alt = RA.alt;\n/**\n * @category Apply\n * @since 2.5.0\n */\nexports.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.5.0\n */\nexports.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.5.0\n */\nexports.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.5.0\n */\nexports.chain = RA.chain;\n/**\n * Composes computations in sequence, using the return value of one computation to determine the next computation and\n * keeping only the result of the first.\n *\n * Derivable from `Monad`.\n *\n * @category combinators\n * @since 2.5.0\n */\nexports.chainFirst = RA.chainFirst;\n/**\n * Derivable from `Extend`.\n *\n * @category combinators\n * @since 2.5.0\n */\nexports.duplicate = RA.duplicate;\n/**\n * @category Extend\n * @since 2.5.0\n */\nexports.extend = RA.extend;\n/**\n * Derivable from `Monad`.\n *\n * @category combinators\n * @since 2.5.0\n */\nexports.flatten = RA.flatten;\n/**\n * `map` can be used to turn functions `(a: A) => B` into functions `(fa: F<A>) => F<B>` whose argument and return types\n * use the type constructor `F` to represent some computational context.\n *\n * @category Functor\n * @since 2.5.0\n */\nexports.map = RA.map;\n/**\n * @category FunctorWithIndex\n * @since 2.5.0\n */\nexports.mapWithIndex = RA.mapWithIndex;\n/**\n * @category Foldable\n * @since 2.5.0\n */\nexports.reduce = RA.reduce;\n/**\n * @category FoldableWithIndex\n * @since 2.5.0\n */\nexports.reduceWithIndex = RA.reduceWithIndex;\n/**\n * @category Foldable\n * @since 2.5.0\n */\nexports.reduceRight = RA.reduceRight;\n/**\n * @category FoldableWithIndex\n * @since 2.5.0\n */\nexports.reduceRightWithIndex = RA.reduceRightWithIndex;\n/**\n * @since 2.6.3\n */\nexports.traverse = RA.traverse;\n/**\n * @since 2.6.3\n */\nexports.sequence = RA.sequence;\n/**\n * @since 2.6.3\n */\nexports.traverseWithIndex = RA.traverseWithIndex;\n/**\n * @since 2.6.3\n */\nexports.extract = head;\n// -------------------------------------------------------------------------------------\n// instances\n// -------------------------------------------------------------------------------------\n/**\n * @category instances\n * @since 2.5.0\n */\nexports.URI = 'ReadonlyNonEmptyArray';\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Functor = {\n    URI: exports.URI,\n    map: map_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.FunctorWithIndex = {\n    URI: exports.URI,\n    map: map_,\n    mapWithIndex: mapWithIndex_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Applicative = {\n    URI: exports.URI,\n    map: map_,\n    ap: ap_,\n    of: exports.of\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Monad = {\n    URI: exports.URI,\n    map: map_,\n    ap: ap_,\n    of: exports.of,\n    chain: chain_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Foldable = {\n    URI: exports.URI,\n    reduce: reduce_,\n    foldMap: foldMap_,\n    reduceRight: reduceRight_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.FoldableWithIndex = {\n    URI: exports.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 */\nexports.Traversable = {\n    URI: exports.URI,\n    map: map_,\n    reduce: reduce_,\n    foldMap: foldMap_,\n    reduceRight: reduceRight_,\n    traverse: traverse_,\n    sequence: exports.sequence\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.TraversableWithIndex = {\n    URI: exports.URI,\n    map: map_,\n    mapWithIndex: mapWithIndex_,\n    reduce: reduce_,\n    foldMap: foldMap_,\n    reduceRight: reduceRight_,\n    traverse: traverse_,\n    sequence: exports.sequence,\n    reduceWithIndex: reduceWithIndex_,\n    foldMapWithIndex: foldMapWithIndex_,\n    reduceRightWithIndex: reduceRightWithIndex_,\n    traverseWithIndex: traverseWithIndex_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Alt = {\n    URI: exports.URI,\n    map: map_,\n    alt: alt_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Comonad = {\n    URI: exports.URI,\n    map: map_,\n    extend: extend_,\n    extract: exports.extract\n};\n// TODO: remove in v3\n/**\n * @category instances\n * @since 2.5.0\n */\nexports.readonlyNonEmptyArray = {\n    URI: exports.URI,\n    of: exports.of,\n    map: map_,\n    mapWithIndex: mapWithIndex_,\n    ap: ap_,\n    chain: chain_,\n    extend: extend_,\n    extract: exports.extract,\n    reduce: reduce_,\n    foldMap: foldMap_,\n    reduceRight: reduceRight_,\n    traverse: traverse_,\n    sequence: exports.sequence,\n    reduceWithIndex: reduceWithIndex_,\n    foldMapWithIndex: foldMapWithIndex_,\n    reduceRightWithIndex: reduceRightWithIndex_,\n    traverseWithIndex: traverseWithIndex_,\n    alt: alt_\n};\n// -------------------------------------------------------------------------------------\n// do notation\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.9.0\n */\nexports.Do = \n/*#__PURE__*/\nexports.of({});\n/**\n * @since 2.8.0\n */\nvar bindTo = function (name) { return exports.map(function_1.bindTo_(name)); };\nexports.bindTo = bindTo;\n/**\n * @since 2.8.0\n */\nvar bind = function (name, f) {\n    return exports.chain(function (a) {\n        return function_1.pipe(f(a), exports.map(function (b) { return function_1.bind_(a, name, b); }));\n    });\n};\nexports.bind = bind;\n// -------------------------------------------------------------------------------------\n// pipeable sequence S\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.8.0\n */\nvar apS = function (name, fb) {\n    return function_1.flow(exports.map(function (a) { return function (b) { return function_1.bind_(a, name, b); }; }), exports.ap(fb));\n};\nexports.apS = apS;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.invert = exports.monoidOrdering = exports.semigroupOrdering = exports.eqOrdering = exports.sign = void 0;\n/**\n * @since 2.0.0\n */\nfunction sign(n) {\n    return n <= -1 ? -1 : n >= 1 ? 1 : 0;\n}\nexports.sign = sign;\n/**\n * @category instances\n * @since 2.0.0\n */\nexports.eqOrdering = {\n    equals: function (x, y) { return x === y; }\n};\n/**\n * Use `monoidOrdering` instead\n *\n * @category instances\n * @since 2.0.0\n * @deprecated\n */\nexports.semigroupOrdering = {\n    concat: function (x, y) { return (x !== 0 ? x : y); }\n};\n/**\n * @category instances\n * @since 2.4.0\n */\nexports.monoidOrdering = {\n    // tslint:disable-next-line: deprecation\n    concat: exports.semigroupOrdering.concat,\n    empty: 0\n};\n/**\n * @since 2.0.0\n */\nfunction invert(O) {\n    switch (O) {\n        case -1:\n            return 1;\n        case 1:\n            return -1;\n        default:\n            return 0;\n    }\n}\nexports.invert = invert;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.getIntercalateSemigroup = exports.semigroupVoid = exports.semigroupString = exports.semigroupProduct = exports.semigroupSum = exports.semigroupAny = exports.semigroupAll = exports.getObjectSemigroup = exports.getJoinSemigroup = exports.getMeetSemigroup = exports.getStructSemigroup = exports.getFunctionSemigroup = exports.getDualSemigroup = exports.getTupleSemigroup = exports.getLastSemigroup = exports.getFirstSemigroup = exports.fold = void 0;\n/**\n * If a type `A` can form a `Semigroup` it has an **associative** binary operation.\n *\n * ```ts\n * interface Semigroup<A> {\n *   readonly concat: (x: A, y: A) => A\n * }\n * ```\n *\n * Associativity means the following equality must hold for any choice of `x`, `y`, and `z`.\n *\n * ```ts\n * concat(x, concat(y, z)) = concat(concat(x, y), z)\n * ```\n *\n * A common example of a semigroup is the type `string` with the operation `+`.\n *\n * ```ts\n * import { Semigroup } from 'fp-ts/Semigroup'\n *\n * const semigroupString: Semigroup<string> = {\n *   concat: (x, y) => x + y\n * }\n *\n * const x = 'x'\n * const y = 'y'\n * const z = 'z'\n *\n * semigroupString.concat(x, y) // 'xy'\n *\n * semigroupString.concat(x, semigroupString.concat(y, z)) // 'xyz'\n *\n * semigroupString.concat(semigroupString.concat(x, y), z) // 'xyz'\n * ```\n *\n * *Adapted from https://typelevel.org/cats*\n *\n * @since 2.0.0\n */\nvar function_1 = require(\"./function\");\nvar Ord_1 = require(\"./Ord\");\nfunction fold(S) {\n    return function (startWith, as) {\n        if (as === undefined) {\n            var foldS_1 = fold(S);\n            return function (as) { return foldS_1(startWith, as); };\n        }\n        return as.reduce(S.concat, startWith);\n    };\n}\nexports.fold = fold;\n/**\n * Always return the first argument.\n *\n * @example\n * import * as S from 'fp-ts/Semigroup'\n *\n * assert.deepStrictEqual(S.getFirstSemigroup<number>().concat(1, 2), 1)\n *\n * @category instances\n * @since 2.0.0\n */\nfunction getFirstSemigroup() {\n    return { concat: function_1.identity };\n}\nexports.getFirstSemigroup = getFirstSemigroup;\n/**\n * Always return the last argument.\n *\n * @example\n * import * as S from 'fp-ts/Semigroup'\n *\n * assert.deepStrictEqual(S.getLastSemigroup<number>().concat(1, 2), 2)\n *\n * @category instances\n * @since 2.0.0\n */\nfunction getLastSemigroup() {\n    return { concat: function (_, y) { return y; } };\n}\nexports.getLastSemigroup = getLastSemigroup;\n/**\n * Given a tuple of semigroups returns a semigroup for the tuple.\n *\n * @example\n * import * as S from 'fp-ts/Semigroup'\n *\n * const S1 = S.getTupleSemigroup(S.semigroupString, S.semigroupSum)\n * assert.deepStrictEqual(S1.concat(['a', 1], ['b', 2]), ['ab', 3])\n *\n * const S2 = S.getTupleSemigroup(S.semigroupString, S.semigroupSum, S.semigroupAll)\n * assert.deepStrictEqual(S2.concat(['a', 1, true], ['b', 2, false]), ['ab', 3, false])\n *\n * @category instances\n * @since 2.0.0\n */\nfunction getTupleSemigroup() {\n    var semigroups = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        semigroups[_i] = arguments[_i];\n    }\n    return {\n        concat: function (x, y) { return semigroups.map(function (s, i) { return s.concat(x[i], y[i]); }); }\n    };\n}\nexports.getTupleSemigroup = getTupleSemigroup;\n/**\n * The dual of a `Semigroup`, obtained by swapping the arguments of `concat`.\n *\n * @example\n * import * as S from 'fp-ts/Semigroup'\n *\n * assert.deepStrictEqual(S.getDualSemigroup(S.semigroupString).concat('a', 'b'), 'ba')\n *\n * @category instances\n * @since 2.0.0\n */\nfunction getDualSemigroup(S) {\n    return {\n        concat: function (x, y) { return S.concat(y, x); }\n    };\n}\nexports.getDualSemigroup = getDualSemigroup;\n/**\n * Unary functions form a semigroup as long as you can provide a semigroup for the codomain.\n *\n * @example\n * import { Predicate } from 'fp-ts/function'\n * import * as S from 'fp-ts/Semigroup'\n *\n * const f: Predicate<number> = (n) => n <= 2\n * const g: Predicate<number> = (n) => n >= 0\n *\n * const S1 = S.getFunctionSemigroup(S.semigroupAll)<number>()\n *\n * assert.deepStrictEqual(S1.concat(f, g)(1), true)\n * assert.deepStrictEqual(S1.concat(f, g)(3), false)\n *\n * const S2 = S.getFunctionSemigroup(S.semigroupAny)<number>()\n *\n * assert.deepStrictEqual(S2.concat(f, g)(1), true)\n * assert.deepStrictEqual(S2.concat(f, g)(3), true)\n *\n * @category instances\n * @since 2.0.0\n */\nfunction getFunctionSemigroup(S) {\n    return function () { return ({\n        concat: function (f, g) { return function (a) { return S.concat(f(a), g(a)); }; }\n    }); };\n}\nexports.getFunctionSemigroup = getFunctionSemigroup;\n/**\n * Given a struct of semigroups returns a semigroup for the struct.\n *\n * @example\n * import * as S from 'fp-ts/Semigroup'\n *\n * interface Point {\n *   readonly x: number\n *   readonly y: number\n * }\n *\n * const semigroupPoint = S.getStructSemigroup<Point>({\n *   x: S.semigroupSum,\n *   y: S.semigroupSum\n * })\n *\n * assert.deepStrictEqual(semigroupPoint.concat({ x: 1, y: 2 }, { x: 3, y: 4 }), { x: 4, y: 6 })\n *\n * @category instances\n * @since 2.0.0\n */\nfunction getStructSemigroup(semigroups) {\n    return {\n        concat: function (x, y) {\n            var r = {};\n            for (var _i = 0, _a = Object.keys(semigroups); _i < _a.length; _i++) {\n                var key = _a[_i];\n                r[key] = semigroups[key].concat(x[key], y[key]);\n            }\n            return r;\n        }\n    };\n}\nexports.getStructSemigroup = getStructSemigroup;\n/**\n * Get a semigroup where `concat` will return the minimum, based on the provided order.\n *\n * @example\n * import * as O from 'fp-ts/Ord'\n * import * as S from 'fp-ts/Semigroup'\n *\n * const S1 = S.getMeetSemigroup(O.ordNumber)\n *\n * assert.deepStrictEqual(S1.concat(1, 2), 1)\n *\n * @category instances\n * @since 2.0.0\n */\nfunction getMeetSemigroup(O) {\n    return {\n        concat: Ord_1.min(O)\n    };\n}\nexports.getMeetSemigroup = getMeetSemigroup;\n/**\n * Get a semigroup where `concat` will return the maximum, based on the provided order.\n *\n * @example\n * import * as O from 'fp-ts/Ord'\n * import * as S from 'fp-ts/Semigroup'\n *\n * const S1 = S.getJoinSemigroup(O.ordNumber)\n *\n * assert.deepStrictEqual(S1.concat(1, 2), 2)\n *\n * @category instances\n * @since 2.0.0\n */\nfunction getJoinSemigroup(O) {\n    return {\n        concat: Ord_1.max(O)\n    };\n}\nexports.getJoinSemigroup = getJoinSemigroup;\n/**\n * Return a semigroup for objects, preserving their type.\n *\n * @example\n * import * as S from 'fp-ts/Semigroup'\n *\n * interface Person {\n *   name: string\n *   age: number\n * }\n *\n * const S1 = S.getObjectSemigroup<Person>()\n * assert.deepStrictEqual(S1.concat({ name: 'name', age: 23 }, { name: 'name', age: 24 }), { name: 'name', age: 24 })\n *\n * @category instances\n * @since 2.0.0\n */\nfunction getObjectSemigroup() {\n    return {\n        concat: function (x, y) { return Object.assign({}, x, y); }\n    };\n}\nexports.getObjectSemigroup = getObjectSemigroup;\n/**\n * `boolean` semigroup under conjunction.\n *\n * @example\n * import * as S from 'fp-ts/Semigroup'\n *\n * assert.deepStrictEqual(S.semigroupAll.concat(true, true), true)\n * assert.deepStrictEqual(S.semigroupAll.concat(true, false), false)\n *\n * @category instances\n * @since 2.0.0\n */\nexports.semigroupAll = {\n    concat: function (x, y) { return x && y; }\n};\n/**\n * `boolean` semigroup under disjunction.\n *\n * @example\n * import * as S from 'fp-ts/Semigroup'\n *\n * assert.deepStrictEqual(S.semigroupAny.concat(true, true), true)\n * assert.deepStrictEqual(S.semigroupAny.concat(true, false), true)\n * assert.deepStrictEqual(S.semigroupAny.concat(false, false), false)\n *\n * @category instances\n * @since 2.0.0\n */\nexports.semigroupAny = {\n    concat: function (x, y) { return x || y; }\n};\n/**\n * `number` semigroup under addition.\n *\n * @example\n * import * as S from 'fp-ts/Semigroup'\n *\n * assert.deepStrictEqual(S.semigroupSum.concat(2, 3), 5)\n *\n * @category instances\n * @since 2.0.0\n */\nexports.semigroupSum = {\n    concat: function (x, y) { return x + y; }\n};\n/**\n * `number` semigroup under multiplication.\n *\n * @example\n * import * as S from 'fp-ts/Semigroup'\n *\n * assert.deepStrictEqual(S.semigroupProduct.concat(2, 3), 6)\n *\n * @category instances\n * @since 2.0.0\n */\nexports.semigroupProduct = {\n    concat: function (x, y) { return x * y; }\n};\n/**\n * `string` semigroup under concatenation.\n *\n * @example\n * import * as S from 'fp-ts/Semigroup'\n *\n * assert.deepStrictEqual(S.semigroupString.concat('a', 'b'), 'ab')\n *\n * @category instances\n * @since 2.0.0\n */\nexports.semigroupString = {\n    concat: function (x, y) { return x + y; }\n};\n/**\n * @category instances\n * @since 2.0.0\n */\nexports.semigroupVoid = {\n    concat: function () { return undefined; }\n};\n/**\n * You can glue items between and stay associative.\n *\n * @example\n * import * as S from 'fp-ts/Semigroup'\n *\n * const S1 = S.getIntercalateSemigroup(' ')(S.semigroupString)\n *\n * assert.strictEqual(S1.concat('a', 'b'), 'a b')\n * assert.strictEqual(S1.concat(S1.concat('a', 'b'), 'c'), S1.concat('a', S1.concat('b', 'c')))\n *\n * @category instances\n * @since 2.5.0\n */\nfunction getIntercalateSemigroup(a) {\n    return function (S) { return ({\n        concat: function (x, y) { return S.concat(x, S.concat(a, y)); }\n    }); };\n}\nexports.getIntercalateSemigroup = getIntercalateSemigroup;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.pipeable = exports.pipe = void 0;\nvar function_1 = require(\"./function\");\n// TODO: remove module in v3\n/**\n * Use [`pipe`](https://gcanti.github.io/fp-ts/modules/function.ts.html#flow) from `function` module instead.\n *\n * @since 2.0.0\n */\nexports.pipe = function_1.pipe;\nvar isFunctor = function (I) { return typeof I.map === 'function'; };\nvar isContravariant = function (I) { return typeof I.contramap === 'function'; };\nvar isFunctorWithIndex = function (I) { return typeof I.mapWithIndex === 'function'; };\nvar isApply = function (I) { return typeof I.ap === 'function'; };\nvar isChain = function (I) { return typeof I.chain === 'function'; };\nvar isBifunctor = function (I) { return typeof I.bimap === 'function'; };\nvar isExtend = function (I) { return typeof I.extend === 'function'; };\nvar isFoldable = function (I) { return typeof I.reduce === 'function'; };\nvar isFoldableWithIndex = function (I) { return typeof I.reduceWithIndex === 'function'; };\nvar isAlt = function (I) { return typeof I.alt === 'function'; };\nvar isCompactable = function (I) { return typeof I.compact === 'function'; };\nvar isFilterable = function (I) { return typeof I.filter === 'function'; };\nvar isFilterableWithIndex = function (I) {\n    return typeof I.filterWithIndex === 'function';\n};\nvar isProfunctor = function (I) { return typeof I.promap === 'function'; };\nvar isSemigroupoid = function (I) { return typeof I.compose === 'function'; };\nvar isMonadThrow = function (I) { return typeof I.throwError === 'function'; };\nfunction pipeable(I) {\n    var r = {};\n    if (isFunctor(I)) {\n        var map = function (f) { return function (fa) { return I.map(fa, f); }; };\n        r.map = map;\n    }\n    if (isContravariant(I)) {\n        var contramap = function (f) { return function (fa) { return I.contramap(fa, f); }; };\n        r.contramap = contramap;\n    }\n    if (isFunctorWithIndex(I)) {\n        var mapWithIndex = function (f) { return function (fa) { return I.mapWithIndex(fa, f); }; };\n        r.mapWithIndex = mapWithIndex;\n    }\n    if (isApply(I)) {\n        var ap = function (fa) { return function (fab) { return I.ap(fab, fa); }; };\n        var apFirst = function (fb) { return function (fa) {\n            return I.ap(I.map(fa, function (a) { return function () { return a; }; }), fb);\n        }; };\n        r.ap = ap;\n        r.apFirst = apFirst;\n        r.apSecond = function (fb) { return function (fa) {\n            return I.ap(I.map(fa, function () { return function (b) { return b; }; }), fb);\n        }; };\n    }\n    if (isChain(I)) {\n        var chain = function (f) { return function (ma) { return I.chain(ma, f); }; };\n        var chainFirst = function (f) { return function (ma) { return I.chain(ma, function (a) { return I.map(f(a), function () { return a; }); }); }; };\n        var flatten = function (mma) { return I.chain(mma, function_1.identity); };\n        r.chain = chain;\n        r.chainFirst = chainFirst;\n        r.flatten = flatten;\n    }\n    if (isBifunctor(I)) {\n        var bimap = function (f, g) { return function (fa) { return I.bimap(fa, f, g); }; };\n        var mapLeft = function (f) { return function (fa) { return I.mapLeft(fa, f); }; };\n        r.bimap = bimap;\n        r.mapLeft = mapLeft;\n    }\n    if (isExtend(I)) {\n        var extend = function (f) { return function (wa) { return I.extend(wa, f); }; };\n        var duplicate = function (wa) { return I.extend(wa, function_1.identity); };\n        r.extend = extend;\n        r.duplicate = duplicate;\n    }\n    if (isFoldable(I)) {\n        var reduce = function (b, f) { return function (fa) { return I.reduce(fa, b, f); }; };\n        var foldMap = function (M) {\n            var foldMapM = I.foldMap(M);\n            return function (f) { return function (fa) { return foldMapM(fa, f); }; };\n        };\n        var reduceRight = function (b, f) { return function (fa) { return I.reduceRight(fa, b, f); }; };\n        r.reduce = reduce;\n        r.foldMap = foldMap;\n        r.reduceRight = reduceRight;\n    }\n    if (isFoldableWithIndex(I)) {\n        var reduceWithIndex = function (b, f) { return function (fa) {\n            return I.reduceWithIndex(fa, b, f);\n        }; };\n        var foldMapWithIndex = function (M) {\n            var foldMapM = I.foldMapWithIndex(M);\n            return function (f) { return function (fa) { return foldMapM(fa, f); }; };\n        };\n        var reduceRightWithIndex = function (b, f) { return function (fa) {\n            return I.reduceRightWithIndex(fa, b, f);\n        }; };\n        r.reduceWithIndex = reduceWithIndex;\n        r.foldMapWithIndex = foldMapWithIndex;\n        r.reduceRightWithIndex = reduceRightWithIndex;\n    }\n    if (isAlt(I)) {\n        var alt = function (that) { return function (fa) { return I.alt(fa, that); }; };\n        r.alt = alt;\n    }\n    if (isCompactable(I)) {\n        r.compact = I.compact;\n        r.separate = I.separate;\n    }\n    if (isFilterable(I)) {\n        var filter = function (predicate) { return function (fa) {\n            return I.filter(fa, predicate);\n        }; };\n        var filterMap = function (f) { return function (fa) { return I.filterMap(fa, f); }; };\n        var partition = function (predicate) { return function (fa) {\n            return I.partition(fa, predicate);\n        }; };\n        var partitionMap = function (f) { return function (fa) { return I.partitionMap(fa, f); }; };\n        r.filter = filter;\n        r.filterMap = filterMap;\n        r.partition = partition;\n        r.partitionMap = partitionMap;\n    }\n    if (isFilterableWithIndex(I)) {\n        var filterWithIndex = function (predicateWithIndex) { return function (fa) { return I.filterWithIndex(fa, predicateWithIndex); }; };\n        var filterMapWithIndex = function (f) { return function (fa) {\n            return I.filterMapWithIndex(fa, f);\n        }; };\n        var partitionWithIndex = function (predicateWithIndex) { return function (fa) { return I.partitionWithIndex(fa, predicateWithIndex); }; };\n        var partitionMapWithIndex = function (f) { return function (fa) {\n            return I.partitionMapWithIndex(fa, f);\n        }; };\n        r.filterWithIndex = filterWithIndex;\n        r.filterMapWithIndex = filterMapWithIndex;\n        r.partitionWithIndex = partitionWithIndex;\n        r.partitionMapWithIndex = partitionMapWithIndex;\n    }\n    if (isProfunctor(I)) {\n        var promap = function (f, g) { return function (fa) { return I.promap(fa, f, g); }; };\n        r.promap = promap;\n    }\n    if (isSemigroupoid(I)) {\n        var compose = function (that) { return function (fa) { return I.compose(fa, that); }; };\n        r.compose = compose;\n    }\n    if (isMonadThrow(I)) {\n        var fromOption = function (onNone) { return function (ma) {\n            return ma._tag === 'None' ? I.throwError(onNone()) : I.of(ma.value);\n        }; };\n        var fromEither = function (ma) {\n            return ma._tag === 'Left' ? I.throwError(ma.left) : I.of(ma.right);\n        };\n        var fromPredicate = function (predicate, onFalse) { return function (a) { return (predicate(a) ? I.of(a) : I.throwError(onFalse(a))); }; };\n        var filterOrElse = function (predicate, onFalse) { return function (ma) { return I.chain(ma, function (a) { return (predicate(a) ? I.of(a) : I.throwError(onFalse(a))); }); }; };\n        r.fromOption = fromOption;\n        r.fromEither = fromEither;\n        r.fromPredicate = fromPredicate;\n        r.filterOrElse = filterOrElse;\n    }\n    return r;\n}\nexports.pipeable = pipeable;\n"],"sourceRoot":""}