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

package/dist/_node_modules/fp-ts/lib/Array.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"Array.cjs","sources":["../../../../../../node_modules/fp-ts/lib/Array.js"],"sourcesContent":["\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\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.lefts = exports.rights = exports.reverse = exports.modifyAt = exports.deleteAt = exports.updateAt = exports.insertAt = exports.copy = 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.lookup = exports.isOutOfBound = exports.size = exports.scanRight = exports.scanLeft = exports.chainWithIndex = exports.foldRight = exports.matchRight = exports.matchRightW = exports.foldLeft = exports.matchLeft = exports.matchLeftW = exports.match = exports.matchW = exports.fromEither = exports.fromOption = exports.fromPredicate = exports.replicate = exports.makeBy = exports.appendW = exports.append = exports.prependW = exports.prepend = exports.isNonEmpty = exports.isEmpty = void 0;\nexports.traverseWithIndex = exports.sequence = exports.traverse = exports.reduceRightWithIndex = exports.reduceRight = exports.reduceWithIndex = exports.reduce = exports.foldMapWithIndex = exports.foldMap = exports.duplicate = exports.extend = exports.filterWithIndex = exports.alt = exports.altW = exports.partitionMapWithIndex = exports.partitionMap = exports.partitionWithIndex = exports.partition = exports.filter = exports.separate = exports.compact = exports.filterMap = exports.filterMapWithIndex = exports.mapWithIndex = exports.flatten = exports.flatMap = exports.ap = exports.map = exports.zero = exports.of = exports.difference = exports.intersection = exports.union = exports.concat = exports.concatW = exports.comprehension = exports.fromOptionK = exports.chunksOf = exports.splitAt = exports.chop = exports.sortBy = exports.uniq = exports.elem = exports.rotate = exports.intersperse = exports.prependAll = exports.unzip = exports.zip = exports.zipWith = exports.sort = void 0;\nexports.some = exports.every = exports.unsafeDeleteAt = exports.unsafeUpdateAt = exports.unsafeInsertAt = exports.fromEitherK = exports.FromEither = exports.filterE = exports.ChainRecBreadthFirst = exports.chainRecBreadthFirst = exports.ChainRecDepthFirst = exports.chainRecDepthFirst = exports.Witherable = exports.TraversableWithIndex = exports.Traversable = exports.FoldableWithIndex = exports.Foldable = exports.FilterableWithIndex = exports.Filterable = exports.Compactable = exports.Extend = exports.Alternative = exports.guard = exports.Zero = exports.Alt = exports.Unfoldable = exports.Monad = exports.chainFirst = exports.Chain = exports.Applicative = exports.apSecond = exports.apFirst = exports.Apply = exports.FunctorWithIndex = exports.Pointed = exports.flap = exports.Functor = exports.getDifferenceMagma = exports.getIntersectionSemigroup = exports.getUnionMonoid = exports.getUnionSemigroup = exports.getOrd = exports.getEq = exports.getMonoid = exports.getSemigroup = exports.getShow = exports.URI = exports.unfold = exports.wilt = exports.wither = void 0;\nexports.array = exports.prependToAll = exports.snoc = exports.cons = exports.empty = exports.range = exports.chain = exports.apS = exports.bind = exports.let = exports.bindTo = exports.Do = exports.intercalate = exports.exists = void 0;\nvar Apply_1 = require(\"./Apply\");\nvar Chain_1 = require(\"./Chain\");\nvar FromEither_1 = require(\"./FromEither\");\nvar function_1 = require(\"./function\");\nvar Functor_1 = require(\"./Functor\");\nvar _ = __importStar(require(\"./internal\"));\nvar NEA = __importStar(require(\"./NonEmptyArray\"));\nvar RA = __importStar(require(\"./ReadonlyArray\"));\nvar Separated_1 = require(\"./Separated\");\nvar Witherable_1 = require(\"./Witherable\");\nvar Zero_1 = require(\"./Zero\");\n// -------------------------------------------------------------------------------------\n// refinements\n// -------------------------------------------------------------------------------------\n/**\n * Test whether an array is empty\n *\n * @example\n * import { isEmpty } from 'fp-ts/Array'\n *\n * assert.strictEqual(isEmpty([]), true)\n * assert.strictEqual(isEmpty(['a']), false)\n *\n * @category refinements\n * @since 2.0.0\n */\nvar isEmpty = function (as) { return as.length === 0; };\nexports.isEmpty = isEmpty;\n/**\n * Test whether an array is non empty narrowing down the type to `NonEmptyArray<A>`\n *\n * @example\n * import { isNonEmpty } from 'fp-ts/Array'\n *\n * assert.strictEqual(isNonEmpty([]), false)\n * assert.strictEqual(isNonEmpty(['a']), true)\n *\n * @category refinements\n * @since 2.0.0\n */\nexports.isNonEmpty = NEA.isNonEmpty;\n// -------------------------------------------------------------------------------------\n// constructors\n// -------------------------------------------------------------------------------------\n/**\n * Prepend an element to the front of a `Array`, creating a new `NonEmptyArray`.\n *\n * @example\n * import { prepend } from 'fp-ts/Array'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(pipe([2, 3, 4], prepend(1)), [1, 2, 3, 4])\n *\n * @since 2.10.0\n */\nexports.prepend = NEA.prepend;\n/**\n * Less strict version of [`prepend`](#prepend).\n *\n * @example\n * import { prependW } from 'fp-ts/Array'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(pipe([2, 3, 4], prependW(\"a\")), [\"a\", 2, 3, 4]);\n *\n * @since 2.11.0\n */\nexports.prependW = NEA.prependW;\n/**\n * Append an element to the end of a `Array`, creating a new `NonEmptyArray`.\n *\n * @example\n * import { append } from 'fp-ts/Array'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(pipe([1, 2, 3], append(4)), [1, 2, 3, 4])\n *\n * @since 2.10.0\n */\nexports.append = NEA.append;\n/**\n * Less strict version of [`append`](#append).\n *\n * @example\n * import { appendW } from 'fp-ts/Array'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(pipe([1, 2, 3], appendW(\"d\")), [1, 2, 3, \"d\"]);\n *\n * @since 2.11.0\n */\nexports.appendW = NEA.appendW;\n/**\n * Return a `Array` of length `n` with element `i` initialized with `f(i)`.\n *\n * **Note**. `n` is normalized to a non negative integer.\n *\n * @example\n * import { makeBy } from 'fp-ts/Array'\n *\n * const double = (i: number): number => i * 2\n * assert.deepStrictEqual(makeBy(5, double), [0, 2, 4, 6, 8])\n * assert.deepStrictEqual(makeBy(-3, double), [])\n * assert.deepStrictEqual(makeBy(4.32164, double), [0, 2, 4, 6])\n *\n * @category constructors\n * @since 2.0.0\n */\nvar makeBy = function (n, f) { return (n <= 0 ? [] : NEA.makeBy(f)(n)); };\nexports.makeBy = makeBy;\n/**\n * Create a `Array` containing a value repeated the specified number of times.\n *\n * **Note**. `n` is normalized to a non negative integer.\n *\n * @example\n * import { replicate } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(replicate(3, 'a'), ['a', 'a', 'a'])\n * assert.deepStrictEqual(replicate(-3, 'a'), [])\n * assert.deepStrictEqual(replicate(2.985647, 'a'), ['a', 'a'])\n *\n * @category constructors\n * @since 2.0.0\n */\nvar replicate = function (n, a) { return (0, exports.makeBy)(n, function () { return a; }); };\nexports.replicate = replicate;\nfunction fromPredicate(predicate) {\n    return function (a) { return (predicate(a) ? [a] : []); };\n}\nexports.fromPredicate = fromPredicate;\n// -------------------------------------------------------------------------------------\n// conversions\n// -------------------------------------------------------------------------------------\n/**\n * Create an array from an `Option`. The resulting array will contain the content of the\n * `Option` if it is `Some` and it will be empty if the `Option` is `None`.\n *\n * @example\n * import { fromOption } from 'fp-ts/Array'\n * import { option } from \"fp-ts\";\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(pipe(option.some(\"a\"), fromOption),[\"a\"])\n * assert.deepStrictEqual(pipe(option.none, fromOption),[])\n *\n * @category conversions\n * @since 2.11.0\n */\nvar fromOption = function (ma) { return (_.isNone(ma) ? [] : [ma.value]); };\nexports.fromOption = fromOption;\n/**\n * Create an array from an `Either`. The resulting array will contain the content of the\n * `Either` if it is `Right` and it will be empty if the `Either` is `Left`.\n *\n * @example\n * import { fromEither } from 'fp-ts/Array'\n * import { either } from \"fp-ts\";\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(pipe(either.right(\"r\"), fromEither), [\"r\"]);\n * assert.deepStrictEqual(pipe(either.left(\"l\"), fromEither), []);\n *\n * @category conversions\n * @since 2.11.0\n */\nvar fromEither = function (e) { return (_.isLeft(e) ? [] : [e.right]); };\nexports.fromEither = fromEither;\n/**\n * Less strict version of [`match`](#match).\n *\n * The `W` suffix (short for **W**idening) means that the handler return types will be merged.\n *\n * @example\n * import { matchW } from 'fp-ts/Array'\n * import { pipe } from 'fp-ts/function'\n *\n * const matcherW = matchW(\n *   () => \"No elements\",\n *   (as) => as.length\n * );\n * assert.deepStrictEqual(pipe([1, 2, 3, 4], matcherW), 4);\n * assert.deepStrictEqual(pipe([], matcherW), \"No elements\");\n *\n * @category pattern matching\n * @since 2.11.0\n */\nvar matchW = function (onEmpty, onNonEmpty) {\n    return function (as) {\n        return (0, exports.isNonEmpty)(as) ? onNonEmpty(as) : onEmpty();\n    };\n};\nexports.matchW = matchW;\n/**\n * Takes an array, if the array is empty it returns the result of `onEmpty`, otherwise\n * it passes the array to `onNonEmpty` and returns the result.\n *\n * @example\n * import { match } from 'fp-ts/Array'\n * import { pipe } from 'fp-ts/function'\n *\n * const matcher = match(\n *   () => \"No elements\",\n *   (as) => `Found ${as.length} element(s)`\n * );\n * assert.deepStrictEqual(pipe([1, 2, 3, 4], matcher), \"Found 4 element(s)\");\n * assert.deepStrictEqual(pipe([], matcher), \"No elements\");\n *\n * @category pattern matching\n * @since 2.11.0\n */\nexports.match = exports.matchW;\n/**\n * Less strict version of [`matchLeft`](#matchleft). It will work when `onEmpty` and\n * `onNonEmpty` have different return types.\n *\n * @example\n * import { matchLeftW } from 'fp-ts/Array'\n *\n * const f = matchLeftW(\n *   () => 0,\n *   (head: string, tail: string[]) => `Found \"${head}\" followed by ${tail.length} elements`\n * );\n * assert.strictEqual(f([\"a\", \"b\", \"c\"]), 'Found \"a\" followed by 2 elements');\n * assert.strictEqual(f([]), 0);\n *\n * @category pattern matching\n * @since 2.11.0\n */\nvar matchLeftW = function (onEmpty, onNonEmpty) {\n    return function (as) {\n        return (0, exports.isNonEmpty)(as) ? onNonEmpty(NEA.head(as), NEA.tail(as)) : onEmpty();\n    };\n};\nexports.matchLeftW = matchLeftW;\n/**\n * Takes an array, if the array is empty it returns the result of `onEmpty`, otherwise\n * it passes the array to `onNonEmpty` broken into its first element and remaining elements.\n *\n * @example\n * import { matchLeft } from 'fp-ts/Array'\n *\n * const len: <A>(as: Array<A>) => number = matchLeft(() => 0, (_, tail) => 1 + len(tail))\n * assert.strictEqual(len([1, 2, 3]), 3)\n *\n * @category pattern matching\n * @since 2.10.0\n */\nexports.matchLeft = exports.matchLeftW;\n/**\n * Alias of [`matchLeft`](#matchleft).\n *\n * @category pattern matching\n * @since 2.0.0\n */\nexports.foldLeft = exports.matchLeft;\n/**\n * Less strict version of [`matchRight`](#matchright). It will work when `onEmpty` and\n * `onNonEmpty` have different return types.\n *\n * @example\n * import { matchRightW } from 'fp-ts/Array'\n *\n * const f = matchRightW(\n *   () => 0,\n *   (head: string[], tail: string) => `Found ${head.length} elements folllowed by \"${tail}\"`\n * );\n * assert.strictEqual(f([\"a\", \"b\", \"c\"]), 'Found 2 elements folllowed by \"c\"');\n * assert.strictEqual(f([]), 0);\n *\n * @category pattern matching\n * @since 2.11.0\n */\nvar matchRightW = function (onEmpty, onNonEmpty) {\n    return function (as) {\n        return (0, exports.isNonEmpty)(as) ? onNonEmpty(NEA.init(as), NEA.last(as)) : onEmpty();\n    };\n};\nexports.matchRightW = matchRightW;\n/**\n * Takes an array, if the array is empty it returns the result of `onEmpty`, otherwise\n * it passes the array to `onNonEmpty` broken  into its initial elements and the last element.\n *\n * @example\n * import { matchRight } from 'fp-ts/Array'\n *\n * const len: <A>(as: Array<A>) => number = matchRight(\n *   () => 0,\n *   (head, _) => 1 + len(head)\n * );\n * assert.strictEqual(len([1, 2, 3]), 3);\n *\n * @category pattern matching\n * @since 2.10.0\n */\nexports.matchRight = exports.matchRightW;\n/**\n * Alias of [`matchRight`](#matchright).\n *\n * @category pattern matching\n * @since 2.0.0\n */\nexports.foldRight = exports.matchRight;\n// -------------------------------------------------------------------------------------\n// combinators\n// -------------------------------------------------------------------------------------\n/**\n * Same as [`chain`](#chain), but passing also the index to the iterating function.\n *\n * @example\n * import { chainWithIndex, replicate } from 'fp-ts/Array'\n * import { pipe } from 'fp-ts/function'\n *\n * const f = (index: number, x: string) => replicate(2, `${x}${index}`);\n * assert.deepStrictEqual(pipe([\"a\", \"b\", \"c\"], chainWithIndex(f)), [\"a0\", \"a0\", \"b1\", \"b1\", \"c2\", \"c2\"]);\n *\n * @category sequencing\n * @since 2.7.0\n */\nvar chainWithIndex = function (f) {\n    return function (as) {\n        var out = [];\n        for (var i = 0; i < as.length; i++) {\n            out.push.apply(out, f(i, as[i]));\n        }\n        return out;\n    };\n};\nexports.chainWithIndex = chainWithIndex;\n/**\n * Same as `reduce` but it carries over the intermediate steps\n *\n * @example\n * import { scanLeft } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(scanLeft(10, (b, a: number) => b - a)([1, 2, 3]), [10, 9, 7, 4])\n *\n * @since 2.0.0\n */\nvar scanLeft = function (b, f) {\n    return function (as) {\n        var len = as.length;\n        var out = new Array(len + 1);\n        out[0] = b;\n        for (var i = 0; i < len; i++) {\n            out[i + 1] = f(out[i], as[i]);\n        }\n        return out;\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/Array'\n *\n * assert.deepStrictEqual(scanRight(10, (a: number, b) => b - a)([1, 2, 3]), [4, 5, 7, 10])\n *\n * @since 2.0.0\n */\nvar scanRight = function (b, f) {\n    return function (as) {\n        var len = as.length;\n        var out = new Array(len + 1);\n        out[len] = b;\n        for (var i = len - 1; i >= 0; i--) {\n            out[i] = f(as[i], out[i + 1]);\n        }\n        return out;\n    };\n};\nexports.scanRight = scanRight;\n/**\n * Calculate the number of elements in a `Array`.\n *\n * @example\n * import { size } from 'fp-ts/Array'\n *\n * assert.strictEqual(size([\"a\",\"b\",\"c\"]),3)\n *\n * @since 2.10.0\n */\nvar size = function (as) { return as.length; };\nexports.size = size;\n/**\n * Test whether an array contains a particular index\n *\n * @example\n * import { isOutOfBound } from 'fp-ts/Array'\n *\n * assert.strictEqual(isOutOfBound(1,[\"a\",\"b\",\"c\"]),false)\n * assert.strictEqual(isOutOfBound(-1,[\"a\",\"b\",\"c\"]),true)\n * assert.strictEqual(isOutOfBound(3,[\"a\",\"b\",\"c\"]),true)\n *\n * @since 2.0.0\n */\nexports.isOutOfBound = NEA.isOutOfBound;\n// TODO: remove non-curried overloading in v3\n/**\n * This function provides a safe way to read a value at a particular index from an array.\n * It returns a `none` if the index is out of bounds, and a `some` of the element if the\n * index is valid.\n *\n * @example\n * import { lookup } from 'fp-ts/Array'\n * import { some, none } from 'fp-ts/Option'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(pipe([1, 2, 3], lookup(1)), some(2))\n * assert.deepStrictEqual(pipe([1, 2, 3], lookup(3)), none)\n *\n * @since 2.0.0\n */\nexports.lookup = RA.lookup;\n/**\n * Get the first element in an array, or `None` if the array is empty\n *\n * @example\n * import { head } from 'fp-ts/Array'\n * import { some, none } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(head([1, 2, 3]), some(1))\n * assert.deepStrictEqual(head([]), none)\n *\n * @since 2.0.0\n */\nexports.head = RA.head;\n/**\n * Get the last element in an array, or `None` if the array is empty\n *\n * @example\n * import { last } from 'fp-ts/Array'\n * import { some, none } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(last([1, 2, 3]), some(3))\n * assert.deepStrictEqual(last([]), none)\n *\n * @since 2.0.0\n */\nexports.last = RA.last;\n/**\n * Get all but the first element of an array, creating a new array, or `None` if the array is empty\n *\n * @example\n * import { tail } from 'fp-ts/Array'\n * import { some, none } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(tail([1, 2, 3]), some([2, 3]))\n * assert.deepStrictEqual(tail([]), none)\n *\n * @since 2.0.0\n */\nvar tail = function (as) { return ((0, exports.isNonEmpty)(as) ? _.some(NEA.tail(as)) : _.none); };\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/Array'\n * import { some, none } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(init([1, 2, 3]), some([1, 2]))\n * assert.deepStrictEqual(init([]), none)\n *\n * @since 2.0.0\n */\nvar init = function (as) { return ((0, exports.isNonEmpty)(as) ? _.some(NEA.init(as)) : _.none); };\nexports.init = init;\n/**\n * Keep only a max number of elements from the start of an `Array`, creating a new `Array`.\n *\n * **Note**. `n` is normalized to a non negative integer.\n *\n * @example\n * import { takeLeft } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(takeLeft(2)([1, 2, 3, 4, 5]), [1, 2]);\n * assert.deepStrictEqual(takeLeft(7)([1, 2, 3, 4, 5]), [1, 2, 3, 4, 5]);\n * assert.deepStrictEqual(takeLeft(0)([1, 2, 3, 4, 5]), []);\n * assert.deepStrictEqual(takeLeft(-1)([1, 2, 3, 4, 5]), [1, 2, 3, 4, 5]);\n *\n * @since 2.0.0\n */\nvar takeLeft = function (n) {\n    return function (as) {\n        return (0, exports.isOutOfBound)(n, as) ? (0, exports.copy)(as) : as.slice(0, n);\n    };\n};\nexports.takeLeft = takeLeft;\n/**\n * Keep only a max number of elements from the end of an `Array`, creating a new `Array`.\n *\n * **Note**. `n` is normalized to a non negative integer.\n *\n * @example\n * import { takeRight } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(takeRight(2)([1, 2, 3, 4, 5]), [4, 5]);\n * assert.deepStrictEqual(takeRight(7)([1, 2, 3, 4, 5]), [1, 2, 3, 4, 5]);\n * assert.deepStrictEqual(takeRight(0)([1, 2, 3, 4, 5]), []);\n * assert.deepStrictEqual(takeRight(-1)([1, 2, 3, 4, 5]), [1, 2, 3, 4, 5]);\n *\n * @since 2.0.0\n */\nvar takeRight = function (n) {\n    return function (as) {\n        return (0, exports.isOutOfBound)(n, as) ? (0, exports.copy)(as) : n === 0 ? [] : as.slice(-n);\n    };\n};\nexports.takeRight = takeRight;\nfunction takeLeftWhile(predicate) {\n    return function (as) {\n        var out = [];\n        for (var _i = 0, as_1 = as; _i < as_1.length; _i++) {\n            var a = as_1[_i];\n            if (!predicate(a)) {\n                break;\n            }\n            out.push(a);\n        }\n        return out;\n    };\n}\nexports.takeLeftWhile = takeLeftWhile;\nvar spanLeftIndex = 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 _a = (0, exports.splitAt)(spanLeftIndex(as, predicate))(as), init = _a[0], rest = _a[1];\n        return { init: init, rest: rest };\n    };\n}\nexports.spanLeft = spanLeft;\n/**\n * Creates a new `Array` which is a copy of the input dropping a max number of elements from the start.\n *\n * **Note**. `n` is normalized to a non negative integer.\n *\n * @example\n * import { dropLeft } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(dropLeft(2)([1, 2, 3]), [3]);\n * assert.deepStrictEqual(dropLeft(5)([1, 2, 3]), []);\n * assert.deepStrictEqual(dropLeft(0)([1, 2, 3]), [1, 2, 3]);\n * assert.deepStrictEqual(dropLeft(-2)([1, 2, 3]), [1, 2, 3]);\n *\n * @since 2.0.0\n */\nvar dropLeft = function (n) {\n    return function (as) {\n        return n <= 0 || (0, exports.isEmpty)(as) ? (0, exports.copy)(as) : n >= as.length ? [] : as.slice(n, as.length);\n    };\n};\nexports.dropLeft = dropLeft;\n/**\n * Creates a new `Array` which is a copy of the input dropping a max number of elements from the end.\n *\n * **Note**. `n` is normalized to a non negative integer.\n *\n * @example\n * import { dropRight } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(dropRight(2)([1, 2, 3]), [1]);\n * assert.deepStrictEqual(dropRight(5)([1, 2, 3]), []);\n * assert.deepStrictEqual(dropRight(0)([1, 2, 3]), [1, 2, 3]);\n * assert.deepStrictEqual(dropRight(-2)([1, 2, 3]), [1, 2, 3]);\n *\n * @since 2.0.0\n */\nvar dropRight = function (n) {\n    return function (as) {\n        return n <= 0 || (0, exports.isEmpty)(as) ? (0, exports.copy)(as) : n >= as.length ? [] : as.slice(0, as.length - n);\n    };\n};\nexports.dropRight = dropRight;\nfunction dropLeftWhile(predicate) {\n    return function (as) { return as.slice(spanLeftIndex(as, predicate)); };\n}\nexports.dropLeftWhile = dropLeftWhile;\n/**\n * `findIndex` returns an `Option` containing the first index for which a predicate holds.\n * It returns `None` if no element satisfies the predicate.\n * Similar to [`findFirst`](#findFirst) but returning the index instead of the element.\n *\n * @example\n * import { findIndex } from 'fp-ts/Array'\n * import { some, none } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(findIndex((n: number) => n === 2)([1, 2, 3]), some(1))\n * assert.deepStrictEqual(findIndex((n: number) => n === 2)([]), none)\n *\n * @since 2.0.0\n */\nexports.findIndex = RA.findIndex;\nfunction findFirst(predicate) {\n    return RA.findFirst(predicate);\n}\nexports.findFirst = findFirst;\n/**\n * Given a selector function which takes an element and returns an option,\n * this function applies the selector to each element of the array and\n * returns the first `Some` result. Otherwise it returns `None`.\n *\n * @example\n * import { findFirstMap } from 'fp-ts/Array'\n * import { some, none } from 'fp-ts/Option'\n *\n * interface Person {\n *   readonly name: string;\n *   readonly age: number;\n * }\n *\n * const persons: Array<Person> = [\n *   { name: \"John\", age: 16 },\n *   { name: \"Mary\", age: 45 },\n *   { name: \"Joey\", age: 28 },\n * ];\n *\n * const nameOfPersonAbove18 = (p: Person) => (p.age <= 18 ? none : some(p.name));\n * const nameOfPersonAbove70 = (p: Person) => (p.age <= 70 ? none : some(p.name));\n * assert.deepStrictEqual(findFirstMap(nameOfPersonAbove18)(persons), some(\"Mary\"));\n * assert.deepStrictEqual(findFirstMap(nameOfPersonAbove70)(persons), none);\n *\n * @since 2.0.0\n */\nexports.findFirstMap = RA.findFirstMap;\nfunction findLast(predicate) {\n    return RA.findLast(predicate);\n}\nexports.findLast = findLast;\n/**\n * Given a selector function which takes an element and returns an option,\n * this function applies the selector to each element of the array starting from the\n * end and returns the last `Some` result. Otherwise it returns `None`.\n *\n * @example\n * import { findLastMap } from 'fp-ts/Array'\n * import { some, none } from 'fp-ts/Option'\n *\n * interface Person {\n *   readonly name: string;\n *   readonly age: number;\n * }\n *\n * const persons: Array<Person> = [\n *   { name: \"John\", age: 16 },\n *   { name: \"Mary\", age: 45 },\n *   { name: \"Joey\", age: 28 },\n * ];\n *\n * const nameOfPersonAbove18 = (p: Person) => (p.age <= 18 ? none : some(p.name));\n * const nameOfPersonAbove70 = (p: Person) => (p.age <= 70 ? none : some(p.name));\n * assert.deepStrictEqual(findLastMap(nameOfPersonAbove18)(persons), some(\"Joey\"));\n * assert.deepStrictEqual(findLastMap(nameOfPersonAbove70)(persons), none);\n *\n * @since 2.0.0\n */\nexports.findLastMap = RA.findLastMap;\n/**\n * Returns the index of the last element of the list which matches the predicate.\n * It returns an `Option` containing the index or `None` if not found.\n *\n * @example\n * import { findLastIndex } from 'fp-ts/Array'\n * import { some, none } from 'fp-ts/Option'\n *\n * interface X {\n *   readonly a: number\n *   readonly b: number\n * }\n * const xs: Array<X> = [{ a: 1, b: 0 }, { a: 1, b: 1 }]\n * assert.deepStrictEqual(findLastIndex((x: { readonly a: number }) => x.a === 1)(xs), some(1))\n * assert.deepStrictEqual(findLastIndex((x: { readonly a: number }) => x.a === 4)(xs), none)\n *\n * @since 2.0.0\n */\nexports.findLastIndex = RA.findLastIndex;\n/**\n * This function takes an array and makes a new array containing the same elements.\n *\n * @since 2.0.0\n */\nvar copy = function (as) { return as.slice(); };\nexports.copy = copy;\n/**\n * Insert an element at the specified index, creating a new array,\n * or returning `None` if the index is out of bounds.\n *\n * @example\n * import { insertAt } from 'fp-ts/Array'\n * import { some } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(insertAt(2, 5)([1, 2, 3, 4]), some([1, 2, 5, 3, 4]))\n *\n * @since 2.0.0\n */\nvar insertAt = function (i, a) {\n    return function (as) {\n        return i < 0 || i > as.length ? _.none : _.some((0, exports.unsafeInsertAt)(i, a, as));\n    };\n};\nexports.insertAt = insertAt;\n/**\n * Change the element at the specified index, creating a new array,\n * or returning `None` if the index is out of bounds.\n *\n * @example\n * import { updateAt } from 'fp-ts/Array'\n * import { some, none } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(updateAt(1, 1)([1, 2, 3]), some([1, 1, 3]))\n * assert.deepStrictEqual(updateAt(1, 1)([]), none)\n *\n * @since 2.0.0\n */\nvar updateAt = function (i, a) { return (0, exports.modifyAt)(i, function () { return a; }); };\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/Array'\n * import { some, none } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(deleteAt(0)([1, 2, 3]), some([2, 3]))\n * assert.deepStrictEqual(deleteAt(1)([]), none)\n *\n * @since 2.0.0\n */\nvar deleteAt = function (i) {\n    return function (as) {\n        return (0, exports.isOutOfBound)(i, as) ? _.none : _.some((0, exports.unsafeDeleteAt)(i, as));\n    };\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/Array'\n * import { some, none } from 'fp-ts/Option'\n *\n * const double = (x: number): number => x * 2\n * assert.deepStrictEqual(modifyAt(1, double)([1, 2, 3]), some([1, 4, 3]))\n * assert.deepStrictEqual(modifyAt(1, double)([]), none)\n *\n * @since 2.0.0\n */\nvar modifyAt = function (i, f) {\n    return function (as) {\n        return (0, exports.isOutOfBound)(i, as) ? _.none : _.some((0, exports.unsafeUpdateAt)(i, f(as[i]), as));\n    };\n};\nexports.modifyAt = modifyAt;\n/**\n * Reverse an array, creating a new array\n *\n * @example\n * import { reverse } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(reverse([1, 2, 3]), [3, 2, 1])\n *\n * @since 2.0.0\n */\nvar reverse = function (as) { return ((0, exports.isEmpty)(as) ? [] : as.slice().reverse()); };\nexports.reverse = reverse;\n/**\n * Takes an `Array` of `Either` and produces a new `Array` containing\n * the values of all the `Right` elements in the same order.\n *\n * @example\n * import { rights } from 'fp-ts/Array'\n * import { right, left } from 'fp-ts/Either'\n *\n * assert.deepStrictEqual(rights([right(1), left('foo'), right(2)]), [1, 2])\n *\n * @since 2.0.0\n */\nvar rights = function (as) {\n    var r = [];\n    for (var i = 0; i < as.length; 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 * Takes an `Array` of `Either` and produces a new `Array` containing\n * the values of all the `Left` elements in the same order.\n *\n * @example\n * import { lefts } from 'fp-ts/Array'\n * import { left, right } from 'fp-ts/Either'\n *\n * assert.deepStrictEqual(lefts([right(1), left('foo'), right(2)]), ['foo'])\n *\n * @since 2.0.0\n */\nvar lefts = function (as) {\n    var r = [];\n    for (var i = 0; i < as.length; 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/Array'\n * import * as N from 'fp-ts/number'\n *\n * assert.deepStrictEqual(sort(N.Ord)([3, 2, 1]), [1, 2, 3])\n *\n * @since 2.0.0\n */\nvar sort = function (O) {\n    return function (as) {\n        return as.length <= 1 ? (0, exports.copy)(as) : as.slice().sort(O.compare);\n    };\n};\nexports.sort = sort;\n/**\n * Apply a function to pairs of elements at the same index in two arrays, collecting the results in a new array. If one\n * input array is short, excess elements of the longer array are discarded.\n *\n * @example\n * import { zipWith } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(zipWith([1, 2, 3], ['a', 'b', 'c', 'd'], (n, s) => s + n), ['a1', 'b2', 'c3'])\n *\n * @since 2.0.0\n */\nvar zipWith = function (fa, fb, f) {\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 (0, exports.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/Array'\n *\n * assert.deepStrictEqual(unzip([[1, 'a'], [2, 'b'], [3, 'c']]), [[1, 2, 3], ['a', 'b', 'c']])\n *\n * @since 2.0.0\n */\nvar unzip = function (as) {\n    var fa = [];\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 * Creates a new `Array`, prepending an element to every member of the input `Array`.\n *\n * @example\n * import { prependAll } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(prependAll(9)([1, 2, 3, 4]), [9, 1, 9, 2, 9, 3, 9, 4])\n *\n * @since 2.10.0\n */\nvar prependAll = function (middle) {\n    var f = NEA.prependAll(middle);\n    return function (as) { return ((0, exports.isNonEmpty)(as) ? f(as) : []); };\n};\nexports.prependAll = prependAll;\n/**\n * Creates a new `Array` placing an element in between members of the input `Array`.\n *\n * @example\n * import { intersperse } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(intersperse(9)([1, 2, 3, 4]), [1, 9, 2, 9, 3, 9, 4])\n *\n * @since 2.9.0\n */\nvar intersperse = function (middle) {\n    var f = NEA.intersperse(middle);\n    return function (as) { return ((0, exports.isNonEmpty)(as) ? f(as) : (0, exports.copy)(as)); };\n};\nexports.intersperse = intersperse;\n/**\n * Creates a new `Array` rotating the input `Array` by `n` steps.\n *\n * @example\n * import { rotate } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(rotate(2)([1, 2, 3, 4, 5]), [4, 5, 1, 2, 3])\n *\n * @since 2.0.0\n */\nvar rotate = function (n) {\n    var f = NEA.rotate(n);\n    return function (as) { return ((0, exports.isNonEmpty)(as) ? f(as) : (0, exports.copy)(as)); };\n};\nexports.rotate = rotate;\n// TODO: remove non-curried overloading in v3\n/**\n * Test if a value is a member of an `Array`. Takes a `Eq<A>` as a single\n * argument which returns the function to use to search for a value of type `A` in\n * an `Array<A>`.\n *\n * @example\n * import { elem } from 'fp-ts/Array'\n * import * as N from 'fp-ts/number'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.strictEqual(pipe([1, 2, 3], elem(N.Eq)(2)), true)\n * assert.strictEqual(pipe([1, 2, 3], elem(N.Eq)(0)), false)\n *\n * @since 2.0.0\n */\nexports.elem = RA.elem;\n/**\n * Creates a new `Array` removing duplicate elements, keeping the first occurrence of an element,\n * based on a `Eq<A>`.\n *\n * @example\n * import { uniq } from 'fp-ts/Array'\n * import * as N from 'fp-ts/number'\n *\n * assert.deepStrictEqual(uniq(N.Eq)([1, 2, 1]), [1, 2])\n *\n * @since 2.0.0\n */\nvar uniq = function (E) {\n    var f = NEA.uniq(E);\n    return function (as) { return ((0, exports.isNonEmpty)(as) ? f(as) : (0, exports.copy)(as)); };\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/Array'\n * import { contramap } from 'fp-ts/Ord'\n * import * as S from 'fp-ts/string'\n * import * as N from 'fp-ts/number'\n * import { pipe } from 'fp-ts/function'\n *\n * interface Person {\n *   readonly name: string\n *   readonly age: number\n * }\n * const byName = pipe(S.Ord, contramap((p: Person) => p.name))\n * const byAge = pipe(N.Ord, contramap((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 * @since 2.0.0\n */\nvar sortBy = function (ords) {\n    var f = NEA.sortBy(ords);\n    return function (as) { return ((0, exports.isNonEmpty)(as) ? f(as) : (0, exports.copy)(as)); };\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 } from 'fp-ts/Eq'\n * import * as A from 'fp-ts/Array'\n * import * as N from 'fp-ts/number'\n * import { pipe } from 'fp-ts/function'\n *\n * const group = <A>(S: Eq<A>): ((as: Array<A>) => Array<Array<A>>) => {\n *   return A.chop(as => {\n *     const { init, rest } = pipe(as, A.spanLeft((a: A) => S.equals(a, as[0])))\n *     return [init, rest]\n *   })\n * }\n * assert.deepStrictEqual(group(N.Eq)([1, 1, 2, 3, 3, 4]), [[1, 1], [2], [3, 3], [4]])\n *\n * @since 2.0.0\n */\nvar chop = function (f) {\n    var g = NEA.chop(f);\n    return function (as) { return ((0, exports.isNonEmpty)(as) ? g(as) : []); };\n};\nexports.chop = chop;\n/**\n * Splits an `Array` into two pieces, the first piece has max `n` elements.\n *\n * @example\n * import { splitAt } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(splitAt(2)([1, 2, 3, 4, 5]), [[1, 2], [3, 4, 5]])\n *\n * @since 2.0.0\n */\nvar splitAt = function (n) {\n    return function (as) {\n        return n >= 1 && (0, exports.isNonEmpty)(as) ? NEA.splitAt(n)(as) : (0, exports.isEmpty)(as) ? [(0, exports.copy)(as), []] : [[], (0, exports.copy)(as)];\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/Array'\n *\n * assert.deepStrictEqual(chunksOf(2)([1, 2, 3, 4, 5]), [[1, 2], [3, 4], [5]])\n *\n * @since 2.0.0\n */\nvar chunksOf = function (n) {\n    var f = NEA.chunksOf(n);\n    return function (as) { return ((0, exports.isNonEmpty)(as) ? f(as) : []); };\n};\nexports.chunksOf = chunksOf;\n/**\n * @category lifting\n * @since 2.11.0\n */\nvar fromOptionK = function (f) {\n    return function () {\n        var a = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            a[_i] = arguments[_i];\n        }\n        return (0, exports.fromOption)(f.apply(void 0, a));\n    };\n};\nexports.fromOptionK = fromOptionK;\nfunction comprehension(input, f, g) {\n    if (g === void 0) { g = function () { return true; }; }\n    var go = function (scope, input) {\n        return (0, exports.isNonEmpty)(input)\n            ? (0, exports.flatMap)(NEA.head(input), function (a) { return go((0, function_1.pipe)(scope, (0, exports.append)(a)), NEA.tail(input)); })\n            : g.apply(void 0, scope) ? [f.apply(void 0, scope)]\n                : [];\n    };\n    return go([], input);\n}\nexports.comprehension = comprehension;\n/**\n * @since 2.11.0\n */\nvar concatW = function (second) {\n    return function (first) {\n        return (0, exports.isEmpty)(first) ? (0, exports.copy)(second) : (0, exports.isEmpty)(second) ? (0, exports.copy)(first) : first.concat(second);\n    };\n};\nexports.concatW = concatW;\n/**\n * @since 2.11.0\n */\nexports.concat = exports.concatW;\nfunction union(E) {\n    var unionE = NEA.union(E);\n    return function (first, second) {\n        if (second === undefined) {\n            var unionE_1 = union(E);\n            return function (second) { return unionE_1(second, first); };\n        }\n        return (0, exports.isNonEmpty)(first) && (0, exports.isNonEmpty)(second)\n            ? unionE(second)(first)\n            : (0, exports.isNonEmpty)(first)\n                ? (0, exports.copy)(first)\n                : (0, exports.copy)(second);\n    };\n}\nexports.union = union;\nfunction intersection(E) {\n    var elemE = (0, exports.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 = (0, exports.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;\nvar _map = function (fa, f) { return (0, function_1.pipe)(fa, (0, exports.map)(f)); };\n/* istanbul ignore next */\nvar _mapWithIndex = function (fa, f) { return (0, function_1.pipe)(fa, (0, exports.mapWithIndex)(f)); };\nvar _ap = function (fab, fa) { return (0, function_1.pipe)(fab, (0, exports.ap)(fa)); };\n/* istanbul ignore next */\nvar _filter = function (fa, predicate) { return (0, function_1.pipe)(fa, (0, exports.filter)(predicate)); };\n/* istanbul ignore next */\nvar _filterMap = function (fa, f) { return (0, function_1.pipe)(fa, (0, exports.filterMap)(f)); };\n/* istanbul ignore next */\nvar _partition = function (fa, predicate) {\n    return (0, function_1.pipe)(fa, (0, exports.partition)(predicate));\n};\n/* istanbul ignore next */\nvar _partitionMap = function (fa, f) { return (0, function_1.pipe)(fa, (0, exports.partitionMap)(f)); };\n/* istanbul ignore next */\nvar _partitionWithIndex = function (fa, predicateWithIndex) { return (0, function_1.pipe)(fa, (0, exports.partitionWithIndex)(predicateWithIndex)); };\n/* istanbul ignore next */\nvar _partitionMapWithIndex = function (fa, f) { return (0, function_1.pipe)(fa, (0, exports.partitionMapWithIndex)(f)); };\n/* istanbul ignore next */\nvar _alt = function (fa, that) { return (0, function_1.pipe)(fa, (0, exports.alt)(that)); };\nvar _reduce = function (fa, b, f) { return (0, function_1.pipe)(fa, (0, exports.reduce)(b, f)); };\n/* istanbul ignore next */\nvar _foldMap = function (M) {\n    var foldMapM = (0, exports.foldMap)(M);\n    return function (fa, f) { return (0, function_1.pipe)(fa, foldMapM(f)); };\n};\n/* istanbul ignore next */\nvar _reduceRight = function (fa, b, f) { return (0, function_1.pipe)(fa, (0, exports.reduceRight)(b, f)); };\n/* istanbul ignore next */\nvar _reduceWithIndex = function (fa, b, f) {\n    return (0, function_1.pipe)(fa, (0, exports.reduceWithIndex)(b, f));\n};\n/* istanbul ignore next */\nvar _foldMapWithIndex = function (M) {\n    var foldMapWithIndexM = (0, exports.foldMapWithIndex)(M);\n    return function (fa, f) { return (0, function_1.pipe)(fa, foldMapWithIndexM(f)); };\n};\n/* istanbul ignore next */\nvar _reduceRightWithIndex = function (fa, b, f) {\n    return (0, function_1.pipe)(fa, (0, exports.reduceRightWithIndex)(b, f));\n};\n/* istanbul ignore next */\nvar _filterMapWithIndex = function (fa, f) { return (0, function_1.pipe)(fa, (0, exports.filterMapWithIndex)(f)); };\n/* istanbul ignore next */\nvar _filterWithIndex = function (fa, predicateWithIndex) { return (0, function_1.pipe)(fa, (0, exports.filterWithIndex)(predicateWithIndex)); };\n/* istanbul ignore next */\nvar _extend = function (fa, f) { return (0, function_1.pipe)(fa, (0, exports.extend)(f)); };\n/* istanbul ignore next */\nvar _traverse = function (F) {\n    var traverseF = (0, exports.traverse)(F);\n    return function (ta, f) { return (0, function_1.pipe)(ta, traverseF(f)); };\n};\n/* istanbul ignore next */\nvar _traverseWithIndex = function (F) {\n    var traverseWithIndexF = (0, exports.traverseWithIndex)(F);\n    return function (ta, f) { return (0, function_1.pipe)(ta, traverseWithIndexF(f)); };\n};\nvar _chainRecDepthFirst = RA._chainRecDepthFirst;\nvar _chainRecBreadthFirst = RA._chainRecBreadthFirst;\n/**\n * Given an element of the base type, `of` builds an `Array` containing just that\n * element of the base type (this is useful for building a `Monad`).\n *\n * @example\n * import { of } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(of(\"a\"), [\"a\"]);\n *\n * @category constructors\n * @since 2.0.0\n */\nexports.of = NEA.of;\n/**\n * Makes an empty `Array`, useful for building a [`Monoid`](#Monoid)\n *\n * @since 2.7.0\n */\nvar zero = function () { return []; };\nexports.zero = zero;\n/**\n * `map` can be used to turn functions `(a: A) => B` into functions `(fa: Array<A>) => Array<B>`.\n * In practice it applies the base function to each element of the array and collects the\n * results in a new array.\n *\n * @example\n * import { map } from 'fp-ts/Array'\n * import { pipe } from 'fp-ts/function'\n *\n * const f = (n: number) => n * 2;\n * assert.deepStrictEqual(pipe([1, 2, 3], map(f)), [2, 4, 6]);\n *\n * @category mapping\n * @since 2.0.0\n */\nvar map = function (f) { return function (fa) { return fa.map(function (a) { return f(a); }); }; };\nexports.map = map;\n/**\n * @example\n * import { ap, map, of } from 'fp-ts/Array'\n * import { pipe } from 'fp-ts/function'\n *\n * // a curried function with 3 input parameteres\n * const f = (s1: string) => (n: number) => (s2: string) => s1 + n + s2;\n *\n * // let's use `ap` to iterate `f` over an array for each input parameter\n * assert.deepStrictEqual(pipe([\"a\", \"b\"], map(f), ap([1, 2]), ap([\"😀\", \"😫\", \"😎\"])), [\n *   \"a1😀\", \"a1😫\", \"a1😎\",\n *   \"a2😀\", \"a2😫\", \"a2😎\",\n *   \"b1😀\", \"b1😫\", \"b1😎\",\n *   \"b2😀\", \"b2😫\", \"b2😎\",\n * ]);\n *\n * // given Array implements the Applicative interface with the `of` method,\n * // we can write exactly the same thing in a more symmetric way\n * // using `of` on `f` and `ap` on each array in input\n * assert.deepStrictEqual(\n *   pipe(of(f), ap([\"a\", \"b\"]), ap([1, 2]), ap([\"😀\", \"😫\", \"😎\"])),\n *   pipe([\"a\", \"b\"], map(f), ap([1, 2]), ap([\"😀\", \"😫\", \"😎\"]))\n * );\n *\n * @since 2.0.0\n */\nvar ap = function (fa) {\n    return (0, exports.flatMap)(function (f) { return (0, function_1.pipe)(fa, (0, exports.map)(f)); });\n};\nexports.ap = ap;\n/**\n * Composes computations in sequence, using the return value of one computation to\n * determine the next computation.\n *\n * In other words it takes a function `f` that produces an array from a single element of\n * the base type `A` and returns a new function which applies `f` to each element of the\n * input array (like [`map`](#map)) and, instead of returning an array of arrays, concatenates the\n * results into a single array (like [`flatten`](#flatten)).\n *\n * @example\n * import { flatMap, map, replicate } from 'fp-ts/Array'\n * import { pipe } from 'fp-ts/function'\n *\n * const f = (n: number) => replicate(n, `${n}`);\n * assert.deepStrictEqual(pipe([1, 2, 3], map(f)), [[\"1\"], [\"2\", \"2\"], [\"3\", \"3\", \"3\"]]);\n * assert.deepStrictEqual(pipe([1, 2, 3], flatMap(f)), [\"1\", \"2\", \"2\", \"3\", \"3\", \"3\"]);\n *\n * @category sequencing\n * @since 2.14.0\n */\nexports.flatMap = (0, function_1.dual)(2, function (ma, f) {\n    return (0, function_1.pipe)(ma, (0, exports.chainWithIndex)(function (i, a) { return f(a, i); }));\n});\n/**\n * Takes an array of arrays of `A` and flattens them into an array of `A`\n * by concatenating the elements of each array in order.\n *\n * @example\n * import { flatten } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(flatten([[\"a\"], [\"b\", \"c\"], [\"d\", \"e\", \"f\"]]), [\"a\", \"b\", \"c\", \"d\", \"e\", \"f\"]);\n *\n * @category sequencing\n * @since 2.5.0\n */\nexports.flatten = (0, exports.flatMap)(function_1.identity);\n/**\n * Same as [`map`](#map), but the iterating function takes both the index and the value\n * of the element.\n *\n * @example\n * import { mapWithIndex } from 'fp-ts/Array'\n * import { pipe } from 'fp-ts/function'\n *\n * const f = (i: number, s: string) => `${s} - ${i}`;\n * assert.deepStrictEqual(pipe([\"a\", \"b\", \"c\"], mapWithIndex(f)), [\"a - 0\", \"b - 1\", \"c - 2\"]);\n *\n * @category mapping\n * @since 2.0.0\n */\nvar mapWithIndex = function (f) { return function (fa) {\n    return fa.map(function (a, i) { return f(i, a); });\n}; };\nexports.mapWithIndex = mapWithIndex;\n/**\n * Maps an array with an iterating function that takes the index and the value of\n * each element and returns an `Option`. It keeps only the `Some` values discarding\n * the `None`s.\n *\n * Same as [`filterMap`](#filterMap), but with an iterating function which takes also\n * the index as input.\n *\n * @example\n * import { filterMapWithIndex } from 'fp-ts/Array'\n * import { pipe } from 'fp-ts/function'\n * import { option } from \"fp-ts\";\n *\n * const f = (i: number, s: string) => (i % 2 === 1 ? option.some(s.toUpperCase()) : option.none);\n * assert.deepStrictEqual(pipe([\"a\", \"no\", \"neither\", \"b\"], filterMapWithIndex(f)), [\"NO\", \"B\"]);\n *\n * @category filtering\n * @since 2.0.0\n */\nvar filterMapWithIndex = function (f) {\n    return function (fa) {\n        var out = [];\n        for (var i = 0; i < fa.length; i++) {\n            var optionB = f(i, fa[i]);\n            if (_.isSome(optionB)) {\n                out.push(optionB.value);\n            }\n        }\n        return out;\n    };\n};\nexports.filterMapWithIndex = filterMapWithIndex;\n/**\n * Maps an array with an iterating function that returns an `Option`\n * and it keeps only the `Some` values discarding the `None`s.\n *\n * @example\n * import { filterMap } from 'fp-ts/Array'\n * import { pipe } from 'fp-ts/function'\n * import { option } from \"fp-ts\";\n *\n * const f = (s: string) => s.length === 1 ? option.some(s.toUpperCase()) : option.none;\n * assert.deepStrictEqual(pipe([\"a\", \"no\", \"neither\", \"b\"], filterMap(f)), [\"A\", \"B\"]);\n *\n * @category filtering\n * @since 2.0.0\n */\nvar filterMap = function (f) {\n    return (0, exports.filterMapWithIndex)(function (_, a) { return f(a); });\n};\nexports.filterMap = filterMap;\n/**\n * Compact an array of `Option`s discarding the `None` values and\n * keeping the `Some` values. It returns a new array containing the values of\n * the `Some` options.\n *\n * @example\n * import { compact } from 'fp-ts/Array'\n * import { option } from \"fp-ts\";\n *\n * assert.deepStrictEqual(compact([option.some(\"a\"), option.none, option.some(\"b\")]), [\"a\", \"b\"]);\n *\n * @category filtering\n * @since 2.0.0\n */\nexports.compact = (0, exports.filterMap)(function_1.identity);\n/**\n * Separate an array of `Either`s into `Left`s and `Right`s, creating two new arrays:\n * one containing all the left values and one containing all the right values.\n *\n * @example\n * import { separate } from 'fp-ts/Array'\n * import { either } from \"fp-ts\";\n *\n * assert.deepStrictEqual(separate([either.right(\"r1\"), either.left(\"l1\"), either.right(\"r2\")]), {\n *   left: [\"l1\"],\n *   right: [\"r1\", \"r2\"],\n * });\n *\n * @category filtering\n * @since 2.0.0\n */\nvar separate = function (fa) {\n    var left = [];\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 (0, Separated_1.separated)(left, right);\n};\nexports.separate = separate;\n/**\n * Given an iterating function that is a `Predicate` or a `Refinement`,\n * `filter` creates a new `Array` containing the elements of the original\n * `Array` for which the iterating function is `true`.\n *\n * @example\n * import { filter } from 'fp-ts/Array'\n * import { isString } from \"fp-ts/lib/string\";\n *\n * assert.deepStrictEqual(filter(isString)([\"a\", 1, {}, \"b\", 5]), [\"a\", \"b\"]);\n * assert.deepStrictEqual(filter((x:number) => x > 0)([-3, 1, -2, 5]), [1, 5]);\n *\n * @category filtering\n * @since 2.0.0\n */\nvar filter = function (predicate) {\n    return function (as) {\n        return as.filter(predicate);\n    };\n};\nexports.filter = filter;\n/**\n * Given an iterating function that is a `Predicate` or a `Refinement`,\n * `partition` creates two new `Array`s: `right` containing the elements of the original\n * `Array` for which the iterating function is `true`, `left` containing the elements\n * for which it is false.\n *\n * @example\n * import { partition } from 'fp-ts/Array'\n * import { isString } from \"fp-ts/lib/string\";\n *\n * assert.deepStrictEqual(partition(isString)([\"a\", 1, {}, \"b\", 5]), { left: [1, {}, 5], right: [\"a\", \"b\"] });\n * assert.deepStrictEqual(partition((x: number) => x > 0)([-3, 1, -2, 5]), { left: [-3, -2], right: [1, 5] });\n *\n * @category filtering\n * @since 2.0.0\n */\nvar partition = function (predicate) {\n    return (0, exports.partitionWithIndex)(function (_, a) { return predicate(a); });\n};\nexports.partition = partition;\n/**\n * Same as [`partition`](#partition), but passing also the index to the iterating function.\n *\n * @example\n * import { partitionWithIndex } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(partitionWithIndex((index, x: number) => index < 3 && x > 0)([-2, 5, 6, 7]), {\n *   left: [-2, 7],\n *   right: [5, 6],\n * });\n *\n * @category filtering\n * @since 2.0.0\n */\nvar partitionWithIndex = function (predicateWithIndex) {\n    return function (as) {\n        var left = [];\n        var right = [];\n        for (var i = 0; i < as.length; i++) {\n            var b = as[i];\n            if (predicateWithIndex(i, b)) {\n                right.push(b);\n            }\n            else {\n                left.push(b);\n            }\n        }\n        return (0, Separated_1.separated)(left, right);\n    };\n};\nexports.partitionWithIndex = partitionWithIndex;\n/**\n * Given an iterating function that returns an `Either`,\n * `partitionMap` applies the iterating function to each element and it creates two `Array`s:\n * `right` containing the values of `Right` results, `left` containing the values of `Left` results.\n *\n * @example\n * import { partitionMap } from 'fp-ts/Array'\n * import { Either, left, right } from \"fp-ts/lib/Either\";\n *\n * const upperIfString = <B>(x: B): Either<B, string> =>\n *   typeof x === \"string\" ? right(x.toUpperCase()) : left(x);\n * assert.deepStrictEqual(partitionMap(upperIfString)([-2, \"hello\", 6, 7, \"world\"]), {\n *   left: [-2, 6, 7],\n *   right: [ 'HELLO', 'WORLD' ],\n * });\n *\n * @category filtering\n * @since 2.0.0\n */\nvar partitionMap = function (f) { return (0, exports.partitionMapWithIndex)(function (_, a) { return f(a); }); };\nexports.partitionMap = partitionMap;\n/**\n * Same as [`partitionMap`](#partitionMap), but passing also the index to the iterating function.\n *\n * @example\n * import { partitionMapWithIndex } from 'fp-ts/Array'\n * import { Either, left, right } from \"fp-ts/lib/Either\";\n *\n * const upperIfStringBefore3 = <B>(index: number, x: B): Either<B, string> =>\n *   index < 3 && typeof x === \"string\" ? right(x.toUpperCase()) : left(x);\n * assert.deepStrictEqual(partitionMapWithIndex(upperIfStringBefore3)([-2, \"hello\", 6, 7, \"world\"]), {\n *   left: [-2, 6, 7, \"world\"],\n *   right: [\"HELLO\"],\n * });\n *\n * @category filtering\n * @since 2.0.0\n */\nvar partitionMapWithIndex = function (f) {\n    return function (fa) {\n        var left = [];\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 (0, Separated_1.separated)(left, right);\n    };\n};\nexports.partitionMapWithIndex = partitionMapWithIndex;\n/**\n * Less strict version of [`alt`](#alt).\n *\n * The `W` suffix (short for **W**idening) means that the return types will be merged.\n *\n * @example\n * import * as A from 'fp-ts/Array'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     [1, 2, 3],\n *     A.altW(() => ['a', 'b'])\n *   ),\n *   [1, 2, 3, 'a', 'b']\n * )\n *\n * @category error handling\n * @since 2.9.0\n */\nvar altW = function (that) {\n    return function (fa) {\n        return fa.concat(that());\n    };\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 `Array` concatenates the inputs into a single array.\n *\n * @example\n * import * as A from 'fp-ts/Array'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     [1, 2, 3],\n *     A.alt(() => [4, 5])\n *   ),\n *   [1, 2, 3, 4, 5]\n * )\n *\n * @category error handling\n * @since 2.0.0\n */\nexports.alt = exports.altW;\n/**\n * Same as [`filter`](#filter), but passing also the index to the iterating function.\n *\n * @example\n * import { filterWithIndex } from 'fp-ts/Array';\n *\n * const f = (index: number, x: number) => x > 0 && index <= 2;\n * assert.deepStrictEqual(filterWithIndex(f)([-3, 1, -2, 5]), [1]);\n *\n * @category filtering\n * @since 2.0.0\n */\nvar filterWithIndex = function (predicateWithIndex) {\n    return function (as) {\n        return as.filter(function (b, i) { return predicateWithIndex(i, b); });\n    };\n};\nexports.filterWithIndex = filterWithIndex;\n/**\n * Given an iterating function that takes `Array<A>` as input, `extend` returns\n * an array containing the results of the iterating function applied to the whole input\n * `Array`, then to the input `Array` without the first element, then to the input\n * `Array` without the first two elements, etc.\n *\n * @example\n * import { extend } from 'fp-ts/Array'\n *\n * const f = (a: string[]) => a.join(\",\");\n * assert.deepStrictEqual(extend(f)([\"a\", \"b\", \"c\"]), [\"a,b,c\", \"b,c\", \"c\"]);\n *\n * @since 2.0.0\n */\nvar extend = function (f) { return function (wa) {\n    return wa.map(function (_, i) { return f(wa.slice(i)); });\n}; };\nexports.extend = extend;\n/**\n * `duplicate` returns an array containing the whole input `Array`,\n * then to the input `Array` dropping the first element, then to the input\n * `Array` dropping the first two elements, etc.\n *\n * @example\n * import { duplicate } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(duplicate([\"a\", \"b\", \"c\"]), [[\"a\", \"b\", \"c\"], [\"b\", \"c\"], [\"c\"]]);\n *\n * @since 2.0.0\n */\nexports.duplicate = (0, exports.extend)(function_1.identity);\n/**\n * Map and fold an `Array`.\n * Map the `Array` passing each value to the iterating function.\n * Then fold the results using the provided `Monoid`.\n *\n * @example\n * import { foldMap } from 'fp-ts/Array'\n *\n * const monoid = { concat: (a: string, b: string) => a + b, empty: \"\" };\n * const f = (s: string) => s.toUpperCase()\n * assert.deepStrictEqual(foldMap(monoid)(f)([\"a\", \"b\", \"c\"]), \"ABC\");\n *\n * @category folding\n * @since 2.0.0\n */\nexports.foldMap = RA.foldMap;\n/**\n * Same as [`foldMap`](#foldMap) but passing also the index to the iterating function.\n *\n * @example\n * import { foldMapWithIndex } from 'fp-ts/Array'\n *\n * const monoid = { concat: (a: string, b: string) => a + b, empty: \"\" };\n * const f = (index:number, s: string) => `${s.toUpperCase()}(${index})`\n * assert.deepStrictEqual(foldMapWithIndex(monoid)(f)([\"a\", \"b\", \"c\"]), \"A(0)B(1)C(2)\");\n *\n * @category folding\n * @since 2.0.0\n */\nexports.foldMapWithIndex = RA.foldMapWithIndex;\n/**\n * Reduces an `Array`.\n *\n * `reduce` executes the supplied iterating function on each element of the array,\n * in order, passing in the element and the return value from the calculation on the preceding element.\n *\n * The first time that the iterating function is called there is no \"return value of the\n * previous calculation\", the initial value is used in its place.\n *\n * @example\n * import { reduce } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(reduce(5, (acc: number, cur: number) => acc * cur)([2, 3]), 5 * 2 * 3);\n *\n * @category folding\n * @since 2.0.0\n */\nexports.reduce = RA.reduce;\n/**\n * Same as [`reduce`](#reduce) but passing also the index to the iterating function.\n *\n * @example\n * import { reduceWithIndex } from 'fp-ts/Array'\n *\n * const f = (index: number, acc: string, cur: unknown) =>\n *   acc + (typeof cur === \"string\" ? cur.toUpperCase() + index : \"\");\n * assert.deepStrictEqual(reduceWithIndex(\"\", f)([2, \"a\", \"b\", null]), \"A1B2\");\n *\n * @category folding\n * @since 2.0.0\n */\nexports.reduceWithIndex = RA.reduceWithIndex;\n/**\n * Same as [`reduce`](#reduce) but applied from the end to the start.\n *\n * *Note*: the iterating function in this case takes the accumulator as the last argument.\n *\n * @example\n * import { reduceRight } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(reduceRight(\"\", (cur: string, acc: string) => acc + cur)([\"a\", \"b\", \"c\"]), \"cba\");\n *\n * @category folding\n * @since 2.0.0\n */\nexports.reduceRight = RA.reduceRight;\n/**\n * Same as [`reduceRight`](#reduceRight) but passing also the index to the iterating function.\n *\n * @example\n * import { reduceRightWithIndex } from 'fp-ts/Array'\n *\n * const f = (index: number, cur: unknown, acc: string) =>\n *   acc + (typeof cur === \"string\" ? cur.toUpperCase() + index : \"\");\n * assert.deepStrictEqual(reduceRightWithIndex(\"\", f)([2, \"a\", \"b\", null]), \"B2A1\");\n *\n * @category folding\n * @since 2.0.0\n */\nexports.reduceRightWithIndex = RA.reduceRightWithIndex;\n/**\n * Given an iterating function that returns a `HKT` (higher kinded type), `traverse`\n * applies the iterating function to each element of the `Array` and then [`sequence`](#sequence)-s\n * the results using the provided `Applicative`.\n *\n * E.g. suppose you have an `Array` and you want to format each element with a function\n * that returns a result or an error as `f = (a: A) => Either<Error, B>`, using `traverse`\n * you can apply `f` to all elements and directly obtain as a result an `Either<Error,Array<B>>`\n * i.e. an `Array<B>` if all the results are `B`, or an `Error` if some of the results\n * are `Error`s.\n *\n * @example\n * import { traverse } from 'fp-ts/Array'\n * import { Applicative, left, right } from \"fp-ts/lib/Either\";\n *\n * const f = (x: unknown) =>\n *   typeof x === \"string\" ? right(x.toUpperCase()) : left(new Error(\"not a string\"));\n * assert.deepStrictEqual(traverse(Applicative)(f)([\"a\", \"b\"]), right([\"A\", \"B\"]));\n * assert.deepStrictEqual(traverse(Applicative)(f)([\"a\", 5]), left(new Error(\"not a string\")));\n *\n * @category traversing\n * @since 2.6.3\n */\nvar traverse = function (F) {\n    var traverseWithIndexF = (0, exports.traverseWithIndex)(F);\n    return function (f) { return traverseWithIndexF(function (_, a) { return f(a); }); };\n};\nexports.traverse = traverse;\n/**\n * `sequence` takes an `Array` where elements are `HKT<A>` (higher kinded type) and,\n * using an applicative of that `HKT`, returns an `HKT` of `Array<A>`.\n * E.g. it can turn an `Array<Either<Error, string>>` into an `Either<Error, Array<string>>`.\n *\n * `sequence` requires an `Applicative` of the `HKT` you are targeting, e.g. to turn an\n * `Array<Either<E, A>>` into an `Either<E, Array<A>>`, it needs an\n * `Applicative` for `Either`, to to turn an `Array<Option<A>>` into an `Option<Array<A>>`,\n * it needs an `Applicative` for `Option`.\n *\n * @example\n * import { sequence } from 'fp-ts/Array'\n * import { Applicative, left, right } from \"fp-ts/lib/Either\";\n *\n * assert.deepStrictEqual(sequence(Applicative)([right(\"a\"), right(\"b\")]), right([\"a\", \"b\"]));\n * assert.deepStrictEqual(\n *   sequence(Applicative)([right(\"a\"), left(new Error(\"not a string\"))]),\n *   left(new Error(\"not a string\"))\n * );\n *\n * @category traversing\n * @since 2.6.3\n */\nvar sequence = function (F) {\n    return function (ta) {\n        return _reduce(ta, F.of((0, exports.zero)()), function (fas, fa) {\n            return F.ap(F.map(fas, function (as) { return function (a) { return (0, function_1.pipe)(as, (0, exports.append)(a)); }; }), fa);\n        });\n    };\n};\nexports.sequence = sequence;\n/**\n * Same as [`traverse`](#traverse) but passing also the index to the iterating function.\n *\n * @example\n * import { traverseWithIndex } from 'fp-ts/Array'\n * import { Applicative, left, right } from \"fp-ts/lib/Either\";\n *\n * const f = (index:number, x:unknown) =>\n *   typeof x === \"string\" ? right(x.toUpperCase() + index) : left(new Error(\"not a string\"));\n * assert.deepStrictEqual(traverseWithIndex(Applicative)(f)([\"a\", \"b\"]), right([\"A0\", \"B1\"]));\n * assert.deepStrictEqual(traverseWithIndex(Applicative)(f)([\"a\", 5]), left(new Error(\"not a string\")));\n *\n * @category sequencing\n * @since 2.6.3\n */\nvar traverseWithIndex = function (F) {\n    return function (f) {\n        return (0, exports.reduceWithIndex)(F.of((0, exports.zero)()), function (i, fbs, a) {\n            return F.ap(F.map(fbs, function (bs) { return function (b) { return (0, function_1.pipe)(bs, (0, exports.append)(b)); }; }), f(i, a));\n        });\n    };\n};\nexports.traverseWithIndex = traverseWithIndex;\n/**\n * @category filtering\n * @since 2.6.5\n */\nvar wither = function (F) {\n    var _witherF = _wither(F);\n    return function (f) { return function (fa) { return _witherF(fa, f); }; };\n};\nexports.wither = wither;\n/**\n * @category filtering\n * @since 2.6.5\n */\nvar wilt = function (F) {\n    var _wiltF = _wilt(F);\n    return function (f) { return function (fa) { return _wiltF(fa, f); }; };\n};\nexports.wilt = wilt;\n/**\n * `unfold` takes a function `f` which returns an `Option` of a tuple containing an outcome\n * value and an input for the following iteration.\n * `unfold` applies `f` to the initial value `b` and then recursively to the second\n * element of the tuple contained in the returned `option` of the previous\n * calculation until `f` returns `Option.none`.\n *\n * @example\n * import { unfold } from 'fp-ts/Array'\n * import { option } from 'fp-ts'\n *\n * const f = (n: number) => {\n *   if (n <= 0) return option.none;\n *   const returnValue = n * 2;\n *   const inputForNextRound = n - 1;\n *   return option.some([returnValue, inputForNextRound] as const);\n * };\n * assert.deepStrictEqual(unfold(5, f), [10, 8, 6, 4, 2]);\n *\n * @since 2.6.6\n */\nvar unfold = function (b, f) {\n    var out = [];\n    var bb = b;\n    // eslint-disable-next-line no-constant-condition\n    while (true) {\n        var mt = f(bb);\n        if (_.isSome(mt)) {\n            var _a = mt.value, a = _a[0], b_1 = _a[1];\n            out.push(a);\n            bb = b_1;\n        }\n        else {\n            break;\n        }\n    }\n    return out;\n};\nexports.unfold = unfold;\n/**\n * @category type lambdas\n * @since 2.0.0\n */\nexports.URI = 'Array';\n/**\n * `getShow` makes a `Show` for an `Array<A>` from a `Show` for\n * an `A`.\n *\n * @example\n * import { getShow } from 'fp-ts/Array'\n *\n * const numShow = { show: (n: number) => (n >= 0 ? `${n}` : `(${-n})`) };\n * assert.deepStrictEqual(getShow(numShow).show([-2, -1, 0, 1]), \"[(2), (1), 0, 1]\");\n *\n * @category instances\n * @since 2.0.0\n */\nexports.getShow = RA.getShow;\n/**\n * Get a `Semigroup` based on the concatenation of `Array`s.\n * See also [`getMonoid`](#getMonoid).\n *\n * @example\n * import { getSemigroup } from 'fp-ts/Array'\n *\n * const S = getSemigroup<number>();\n * assert.deepStrictEqual(S.concat([1, 2], [2, 3]), [1, 2, 2, 3]);\n *\n * @category instances\n * @since 2.10.0\n */\nvar getSemigroup = function () { return ({\n    concat: function (first, second) { return first.concat(second); }\n}); };\nexports.getSemigroup = getSemigroup;\n/**\n * Returns a `Monoid` for `Array<A>` based on the concatenation of `Array`s.\n *\n * @example\n * import { getMonoid } from 'fp-ts/Array'\n *\n * const M = getMonoid<number>()\n * assert.deepStrictEqual(M.concat([1, 2], [3, 4]), [1, 2, 3, 4])\n *\n * @category instances\n * @since 2.0.0\n */\nvar getMonoid = function () { return ({\n    concat: (0, exports.getSemigroup)().concat,\n    empty: []\n}); };\nexports.getMonoid = getMonoid;\n/**\n * Derives an `Eq` over the `Array` of a given element type from the `Eq` of that type. The derived `Eq` defines two\n * arrays as equal if all elements of both arrays are compared equal pairwise with the given `E`. In case of arrays of\n * different lengths, the result is non equality.\n *\n * @example\n * import * as S from 'fp-ts/string'\n * import { getEq } from 'fp-ts/Array'\n *\n * const E = getEq(S.Eq)\n * assert.strictEqual(E.equals(['a', 'b'], ['a', 'b']), true)\n * assert.strictEqual(E.equals(['a'], []), false)\n *\n * @category instances\n * @since 2.0.0\n */\nexports.getEq = RA.getEq;\n/**\n * Derives an `Ord` over the `Array` of a given element type from the `Ord` of that type. The ordering between two such\n * arrays is equal to: the first non equal comparison of each arrays elements taken pairwise in increasing order, in\n * case of equality over all the pairwise elements; the longest array is considered the greatest, if both arrays have\n * the same length, the result is equality.\n *\n * @example\n * import { getOrd } from 'fp-ts/Array'\n * import * as S from 'fp-ts/string'\n *\n * const O = getOrd(S.Ord)\n * assert.strictEqual(O.compare(['b'], ['a']), 1)\n * assert.strictEqual(O.compare(['a'], ['a']), 0)\n * assert.strictEqual(O.compare(['a'], ['b']), -1)\n *\n * @category instances\n * @since 2.0.0\n */\nexports.getOrd = RA.getOrd;\n/**\n * Get a `Semigroup` based on the union of the elements of `Array`s.\n * Elements which equal according to the provided `Eq` are included\n * only once in the result.\n * See also [`getUnionMonoid`](#getUnionMonoid).\n *\n * @example\n * import { getUnionSemigroup } from 'fp-ts/Array';\n * import { Eq } from 'fp-ts/number';\n *\n * const S = getUnionSemigroup<number>(Eq);\n * assert.deepStrictEqual(S.concat([1, 2], [2, 3]), [1, 2, 3]);\n *\n * @category instances\n * @since 2.11.0\n */\nvar getUnionSemigroup = function (E) {\n    var unionE = union(E);\n    return {\n        concat: function (first, second) { return unionE(second)(first); }\n    };\n};\nexports.getUnionSemigroup = getUnionSemigroup;\n/**\n * Get a `Monoid` based on the union of the elements of `Array`s.\n * Elements which equal according to the provided `Eq` are included\n * only once in the result.\n *\n * @example\n * import { getUnionMonoid } from 'fp-ts/Array'\n * import { Eq } from 'fp-ts/number';\n *\n * const M = getUnionMonoid<number>(Eq);\n * assert.deepStrictEqual(M.concat([1, 2], [2, 3]), [1, 2, 3]);\n * assert.deepStrictEqual(M.empty,[]);\n *\n * @category instances\n * @since 2.11.0\n */\nvar getUnionMonoid = function (E) { return ({\n    concat: (0, exports.getUnionSemigroup)(E).concat,\n    empty: []\n}); };\nexports.getUnionMonoid = getUnionMonoid;\n/**\n * Get a `Semigroup` based on the intersection of the elements of `Array`s.\n * Only elements present in the two arrays which are equal according to the\n * provided `Eq` are included in the result.\n *\n * @example\n * import { getIntersectionSemigroup } from 'fp-ts/Array'\n * import { Eq } from 'fp-ts/number';\n *\n * const S = getIntersectionSemigroup<number>(Eq);\n * assert.deepStrictEqual(S.concat([1, 2], [2, 3]), [2]);\n *\n * @category instances\n * @since 2.11.0\n */\nvar getIntersectionSemigroup = function (E) {\n    var intersectionE = intersection(E);\n    return {\n        concat: function (first, second) { return intersectionE(second)(first); }\n    };\n};\nexports.getIntersectionSemigroup = getIntersectionSemigroup;\n/**\n * Get a `Magma` for `Array` where the `concat` function is the differnce between\n * the first and the second array, i.e. the result contains all the elements of the\n * first array for which their is no equal element in the second array according\n * to the `Eq` provided.\n *\n *\n * @example\n * import { getDifferenceMagma } from 'fp-ts/Array'\n * import { Eq } from 'fp-ts/number';\n *\n * const S = getDifferenceMagma<number>(Eq);\n * assert.deepStrictEqual(S.concat([1, 2], [2, 3]), [1]);\n *\n * @category instances\n * @since 2.11.0\n */\nvar getDifferenceMagma = function (E) {\n    var differenceE = difference(E);\n    return {\n        concat: function (first, second) { return differenceE(second)(first); }\n    };\n};\nexports.getDifferenceMagma = getDifferenceMagma;\n/**\n * @category instances\n * @since 2.7.0\n */\nexports.Functor = {\n    URI: exports.URI,\n    map: _map\n};\n/**\n * Given an input an `Array` of functions, `flap` returns an `Array` containing\n * the results of applying each function to the given input.\n *\n * @example\n * import { flap } from 'fp-ts/Array'\n *\n * const funs = [\n *   (n: number) => `Double: ${n * 2}`,\n *   (n: number) => `Triple: ${n * 3}`,\n *   (n: number) => `Square: ${n * n}`,\n * ];\n * assert.deepStrictEqual(flap(4)(funs), ['Double: 8', 'Triple: 12', 'Square: 16']);\n *\n * @category mapping\n * @since 2.10.0\n */\nexports.flap = (0, Functor_1.flap)(exports.Functor);\n/**\n * @category instances\n * @since 2.10.0\n */\nexports.Pointed = {\n    URI: exports.URI,\n    of: exports.of\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.10.0\n */\nexports.Apply = {\n    URI: exports.URI,\n    map: _map,\n    ap: _ap\n};\n/**\n * Combine two effectful actions, keeping only the result of the first.\n *\n * @since 2.5.0\n */\nexports.apFirst = (0, Apply_1.apFirst)(exports.Apply);\n/**\n * Combine two effectful actions, keeping only the result of the second.\n *\n * @since 2.5.0\n */\nexports.apSecond = (0, Apply_1.apSecond)(exports.Apply);\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.10.0\n */\nexports.Chain = {\n    URI: exports.URI,\n    map: _map,\n    ap: _ap,\n    chain: exports.flatMap\n};\n/**\n * Composes computations in sequence, using the return value of one computation to determine the next computation and\n * keeping only the result of the first.\n *\n * @example\n * import * as A from 'fp-ts/Array'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     [1, 2, 3],\n *     A.chainFirst(() => ['a', 'b'])\n *   ),\n *   [1, 1, 2, 2, 3, 3]\n * )\n * assert.deepStrictEqual(\n *   pipe(\n *     [1, 2, 3],\n *     A.chainFirst(() => [])\n *   ),\n *   []\n * )\n *\n * @category sequencing\n * @since 2.0.0\n */\nexports.chainFirst = \n/*#__PURE__*/ (0, Chain_1.chainFirst)(exports.Chain);\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: exports.flatMap\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.11.0\n */\nexports.Zero = {\n    URI: exports.URI,\n    zero: exports.zero\n};\n/**\n * @category do notation\n * @since 2.11.0\n */\nexports.guard = (0, Zero_1.guard)(exports.Zero, exports.Pointed);\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};\nvar _wither = /*#__PURE__*/ (0, Witherable_1.witherDefault)(exports.Traversable, exports.Compactable);\nvar _wilt = /*#__PURE__*/ (0, Witherable_1.wiltDefault)(exports.Traversable, exports.Compactable);\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/**\n * @category sequencing\n * @since 2.11.0\n */\nexports.chainRecDepthFirst = RA.chainRecDepthFirst;\n/**\n * @category instances\n * @since 2.11.0\n */\nexports.ChainRecDepthFirst = {\n    URI: exports.URI,\n    map: _map,\n    ap: _ap,\n    chain: exports.flatMap,\n    chainRec: _chainRecDepthFirst\n};\n/**\n * @category sequencing\n * @since 2.11.0\n */\nexports.chainRecBreadthFirst = RA.chainRecBreadthFirst;\n/**\n * @category instances\n * @since 2.11.0\n */\nexports.ChainRecBreadthFirst = {\n    URI: exports.URI,\n    map: _map,\n    ap: _ap,\n    chain: exports.flatMap,\n    chainRec: _chainRecBreadthFirst\n};\n/**\n * Filter values inside a context.\n *\n * @since 2.11.0\n */\nexports.filterE = (0, Witherable_1.filterE)(exports.Witherable);\n/**\n * @category instances\n * @since 2.11.0\n */\nexports.FromEither = {\n    URI: exports.URI,\n    fromEither: exports.fromEither\n};\n/**\n * @category lifting\n * @since 2.11.0\n */\nexports.fromEitherK = (0, FromEither_1.fromEitherK)(exports.FromEither);\n// -------------------------------------------------------------------------------------\n// unsafe\n// -------------------------------------------------------------------------------------\n/**\n * @category unsafe\n * @since 2.0.0\n */\nexports.unsafeInsertAt = NEA.unsafeInsertAt;\n/**\n * @category unsafe\n * @since 2.0.0\n */\nvar unsafeUpdateAt = function (i, a, as) {\n    return (0, exports.isNonEmpty)(as) ? NEA.unsafeUpdateAt(i, a, as) : [];\n};\nexports.unsafeUpdateAt = unsafeUpdateAt;\n/**\n * @category unsafe\n * @since 2.0.0\n */\nvar unsafeDeleteAt = function (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 * `every` tells if the provided predicate holds true for every element in the `Array`.\n *\n * @example\n * import { every } from 'fp-ts/Array'\n *\n * assert.equal(every((x: number) => x >= 0)([1, 2, 3]), true);\n * assert.equal(every((x: number) => x >= 0)([-1, 2, 3]), false);\n *\n * @since 2.9.0\n */\nexports.every = RA.every;\n/**\n * `some` tells if the provided predicate holds true at least for one element in the `Array`.\n *\n * @example\n * import { some } from 'fp-ts/Array'\n *\n * assert.equal(some((x: number) => x >= 0)([1, 2, 3]), true);\n * assert.equal(some((x: number) => x >= 10)([1, 2, 3]), false);\n *\n * @since 2.9.0\n */\nvar some = function (predicate) {\n    return function (as) {\n        return as.some(predicate);\n    };\n};\nexports.some = some;\n/**\n * Alias of [`some`](#some)\n *\n * @since 2.11.0\n */\nexports.exists = exports.some;\n/**\n * Places an element in between members of an `Array`, then folds the results using the provided `Monoid`.\n *\n * @example\n * import * as S from 'fp-ts/string'\n * import { intercalate } from 'fp-ts/Array'\n *\n * assert.deepStrictEqual(intercalate(S.Monoid)('-')(['a', 'b', 'c']), 'a-b-c')\n *\n * @since 2.12.0\n */\nexports.intercalate = RA.intercalate;\n// -------------------------------------------------------------------------------------\n// do notation\n// -------------------------------------------------------------------------------------\n/**\n * @category do notation\n * @since 2.9.0\n */\nexports.Do = (0, exports.of)(_.emptyRecord);\n/**\n * @category do notation\n * @since 2.8.0\n */\nexports.bindTo = (0, Functor_1.bindTo)(exports.Functor);\nvar let_ = /*#__PURE__*/ (0, Functor_1.let)(exports.Functor);\nexports.let = let_;\n/**\n * @category do notation\n * @since 2.8.0\n */\nexports.bind = (0, Chain_1.bind)(exports.Chain);\n/**\n * @category do notation\n * @since 2.8.0\n */\nexports.apS = (0, Apply_1.apS)(exports.Apply);\n// -------------------------------------------------------------------------------------\n// legacy\n// -------------------------------------------------------------------------------------\n/**\n * Alias of `flatMap`.\n *\n * @category legacy\n * @since 2.0.0\n */\nexports.chain = exports.flatMap;\n// -------------------------------------------------------------------------------------\n// deprecated\n// -------------------------------------------------------------------------------------\n/**\n * Use `NonEmptyArray` module instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexports.range = NEA.range;\n/**\n * Use a new `[]` instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexports.empty = [];\n/**\n * Use `prepend` instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexports.cons = NEA.cons;\n/**\n * Use `append` instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexports.snoc = NEA.snoc;\n/**\n * Use `prependAll` instead\n *\n * @category zone of death\n * @since 2.9.0\n * @deprecated\n */\nexports.prependToAll = exports.prependAll;\n/**\n * This instance is deprecated, use small, specific instances instead.\n * For example if a function needs a `Functor` instance, pass `A.Functor` instead of `A.array`\n * (where `A` is from `import A from 'fp-ts/Array'`)\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexports.array = {\n    URI: exports.URI,\n    compact: exports.compact,\n    separate: exports.separate,\n    map: _map,\n    ap: _ap,\n    of: exports.of,\n    chain: exports.flatMap,\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"],"names":["this","exports","require$$0","require$$1","require$$2","require$$3","require$$4","require$$5","require$$6","require$$7","require$$8","require$$9","require$$10","init","bs","input","second","ys","_"],"mappings":"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","x_google_ignoreList":[0]}