@slicemachine/manager 0.22.2-alpha.dani-snippets.6 → 0.22.2-alpha.dani-repeatable-links-codegen.1

package/dist/_node_modules/fp-ts/es6/ReadonlyArray.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReadonlyArray.js","sources":["../../../../../../node_modules/fp-ts/es6/ReadonlyArray.js"],"sourcesContent":["var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n        if (ar || !(i in from)) {\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n            ar[i] = from[i];\n        }\n    }\n    return to.concat(ar || Array.prototype.slice.call(from));\n};\nimport { apFirst as apFirst_, apS as apS_, apSecond as apSecond_ } from './Apply';\nimport { bind as bind_, chainFirst as chainFirst_ } from './Chain';\nimport { fromEquals } from './Eq';\nimport { fromEitherK as fromEitherK_ } from './FromEither';\nimport { dual, identity, pipe } from './function';\nimport { bindTo as bindTo_, flap as flap_, let as let__ } from './Functor';\nimport * as _ from './internal';\nimport * as N from './number';\nimport { fromCompare } from './Ord';\nimport * as RNEA from './ReadonlyNonEmptyArray';\nimport { separated } from './Separated';\nimport { filterE as filterE_, wiltDefault, witherDefault } from './Witherable';\nimport { guard as guard_ } from './Zero';\n// -------------------------------------------------------------------------------------\n// refinements\n// -------------------------------------------------------------------------------------\n/**\n * Test whether a `ReadonlyArray` is empty.\n *\n * @example\n * import { isEmpty } from 'fp-ts/ReadonlyArray'\n *\n * assert.strictEqual(isEmpty([]), true)\n *\n * @category refinements\n * @since 2.5.0\n */\nexport var isEmpty = function (as) { return as.length === 0; };\n/**\n * Test whether a `ReadonlyArray` is non empty.\n *\n * @category refinements\n * @since 2.5.0\n */\nexport var isNonEmpty = RNEA.isNonEmpty;\n// -------------------------------------------------------------------------------------\n// constructors\n// -------------------------------------------------------------------------------------\n/**\n * Prepend an element to the front of a `ReadonlyArray`, creating a new `ReadonlyNonEmptyArray`.\n *\n * @example\n * import { prepend } from 'fp-ts/ReadonlyArray'\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 */\nexport var prepend = RNEA.prepend;\n/**\n * Less strict version of [`prepend`](#prepend).\n *\n * @since 2.11.0\n */\nexport var prependW = RNEA.prependW;\n/**\n * Append an element to the end of a `ReadonlyArray`, creating a new `ReadonlyNonEmptyArray`.\n *\n * @example\n * import { append } from 'fp-ts/ReadonlyArray'\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 */\nexport var append = RNEA.append;\n/**\n * Less strict version of [`append`](#append).\n *\n * @since 2.11.0\n */\nexport var appendW = RNEA.appendW;\n/**\n * Return a `ReadonlyArray` 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/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 */\nexport var makeBy = function (n, f) { return (n <= 0 ? empty : RNEA.makeBy(f)(n)); };\n/**\n * Create a `ReadonlyArray` 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/ReadonlyArray'\n *\n * assert.deepStrictEqual(replicate(3, 'a'), ['a', 'a', 'a'])\n *\n * @category constructors\n * @since 2.5.0\n */\nexport var replicate = function (n, a) { return makeBy(n, function () { return a; }); };\nexport function fromPredicate(predicate) {\n    return function (a) { return (predicate(a) ? [a] : empty); };\n}\n// -------------------------------------------------------------------------------------\n// conversions\n// -------------------------------------------------------------------------------------\n/**\n * @category conversions\n * @since 2.11.0\n */\nexport var fromOption = function (ma) { return (_.isNone(ma) ? empty : [ma.value]); };\n/**\n * Transforms an `Either` to a `ReadonlyArray`.\n *\n * @category conversions\n * @since 2.11.0\n */\nexport var fromEither = function (e) { return (_.isLeft(e) ? empty : [e.right]); };\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 * @category pattern matching\n * @since 2.11.0\n */\nexport var matchW = function (onEmpty, onNonEmpty) {\n    return function (as) {\n        return isNonEmpty(as) ? onNonEmpty(as) : onEmpty();\n    };\n};\n/**\n * @category pattern matching\n * @since 2.11.0\n */\nexport var match = matchW;\n/**\n * Less strict version of [`matchLeft`](#matchleft).\n *\n * @category pattern matching\n * @since 2.11.0\n */\nexport var matchLeftW = function (onEmpty, onNonEmpty) {\n    return function (as) {\n        return isNonEmpty(as) ? onNonEmpty(RNEA.head(as), RNEA.tail(as)) : onEmpty();\n    };\n};\n/**\n * Break a `ReadonlyArray` into its first element and remaining elements.\n *\n * @example\n * import { matchLeft } from 'fp-ts/ReadonlyArray'\n *\n * const len: <A>(as: ReadonlyArray<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 */\nexport var matchLeft = matchLeftW;\n/**\n * Alias of [`matchLeft`](#matchleft).\n *\n * @category pattern matching\n * @since 2.5.0\n */\nexport var foldLeft = matchLeft;\n/**\n * Less strict version of [`matchRight`](#matchright).\n *\n * @category pattern matching\n * @since 2.11.0\n */\nexport var matchRightW = function (onEmpty, onNonEmpty) {\n    return function (as) {\n        return isNonEmpty(as) ? onNonEmpty(RNEA.init(as), RNEA.last(as)) : onEmpty();\n    };\n};\n/**\n * Break a `ReadonlyArray` into its initial elements and the last element.\n *\n * @category pattern matching\n * @since 2.10.0\n */\nexport var matchRight = matchRightW;\n/**\n * Alias of [`matchRight`](#matchright).\n *\n * @category pattern matching\n * @since 2.5.0\n */\nexport var foldRight = matchRight;\n// -------------------------------------------------------------------------------------\n// combinators\n// -------------------------------------------------------------------------------------\n/**\n * @category sequencing\n * @since 2.7.0\n */\nexport var chainWithIndex = function (f) {\n    return function (as) {\n        if (isEmpty(as)) {\n            return empty;\n        }\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};\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 * @since 2.5.0\n */\nexport var 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};\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 * @since 2.5.0\n */\nexport var 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};\n/**\n * Calculate the number of elements in a `ReadonlyArray`.\n *\n * @since 2.10.0\n */\nexport var size = function (as) { return as.length; };\n/**\n * Test whether an array contains a particular index\n *\n * @since 2.5.0\n */\nexport var isOutOfBound = RNEA.isOutOfBound;\nexport function lookup(i, as) {\n    return as === undefined ? function (as) { return lookup(i, as); } : isOutOfBound(i, as) ? _.none : _.some(as[i]);\n}\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 */\nexport var head = function (as) { return (isNonEmpty(as) ? _.some(RNEA.head(as)) : _.none); };\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 */\nexport var last = function (as) { return (isNonEmpty(as) ? _.some(RNEA.last(as)) : _.none); };\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 */\nexport var tail = function (as) {\n    return isNonEmpty(as) ? _.some(RNEA.tail(as)) : _.none;\n};\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 */\nexport var init = function (as) {\n    return isNonEmpty(as) ? _.some(RNEA.init(as)) : _.none;\n};\n/**\n * Keep only a max number of elements from the start of an `ReadonlyArray`, creating a new `ReadonlyArray`.\n *\n * **Note**. `n` is normalized to a non negative integer.\n *\n * @example\n * import * as RA from 'fp-ts/ReadonlyArray'\n * import { pipe } from 'fp-ts/function'\n *\n * const input: ReadonlyArray<number> = [1, 2, 3]\n * assert.deepStrictEqual(pipe(input, RA.takeLeft(2)), [1, 2])\n *\n * // out of bounds\n * assert.strictEqual(pipe(input, RA.takeLeft(4)), input)\n * assert.strictEqual(pipe(input, RA.takeLeft(-1)), input)\n *\n * @since 2.5.0\n */\nexport var takeLeft = function (n) {\n    return function (as) {\n        return isOutOfBound(n, as) ? as : n === 0 ? empty : as.slice(0, n);\n    };\n};\n/**\n * Keep only a max number of elements from the end of an `ReadonlyArray`, creating a new `ReadonlyArray`.\n *\n * **Note**. `n` is normalized to a non negative integer.\n *\n * @example\n * import * as RA from 'fp-ts/ReadonlyArray'\n * import { pipe } from 'fp-ts/function'\n *\n * const input: ReadonlyArray<number> = [1, 2, 3]\n * assert.deepStrictEqual(pipe(input, RA.takeRight(2)), [2, 3])\n *\n * // out of bounds\n * assert.strictEqual(pipe(input, RA.takeRight(4)), input)\n * assert.strictEqual(pipe(input, RA.takeRight(-1)), input)\n *\n * @since 2.5.0\n */\nexport var takeRight = function (n) {\n    return function (as) {\n        return isOutOfBound(n, as) ? as : n === 0 ? empty : as.slice(-n);\n    };\n};\nexport function 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        var len = out.length;\n        return len === as.length ? as : len === 0 ? empty : out;\n    };\n}\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};\nexport function spanLeft(predicate) {\n    return function (as) {\n        var _a = splitAt(spanLeftIndex(as, predicate))(as), init = _a[0], rest = _a[1];\n        return { init: init, rest: rest };\n    };\n}\n/**\n * Drop a max number of elements from the start of an `ReadonlyArray`, creating a new `ReadonlyArray`.\n *\n * **Note**. `n` is normalized to a non negative integer.\n *\n * @example\n * import * as RA from 'fp-ts/ReadonlyArray'\n * import { pipe } from 'fp-ts/function'\n *\n * const input: ReadonlyArray<number> = [1, 2, 3]\n * assert.deepStrictEqual(pipe(input, RA.dropLeft(2)), [3])\n * assert.strictEqual(pipe(input, RA.dropLeft(0)), input)\n * assert.strictEqual(pipe(input, RA.dropLeft(-1)), input)\n *\n * @since 2.5.0\n */\nexport var dropLeft = function (n) {\n    return function (as) {\n        return n <= 0 || isEmpty(as) ? as : n >= as.length ? empty : as.slice(n, as.length);\n    };\n};\n/**\n * Drop a max number of elements from the end of an `ReadonlyArray`, creating a new `ReadonlyArray`.\n *\n * **Note**. `n` is normalized to a non negative integer.\n *\n * @example\n * import * as RA from 'fp-ts/ReadonlyArray'\n * import { pipe } from 'fp-ts/function'\n *\n * const input: ReadonlyArray<number> = [1, 2, 3]\n * assert.deepStrictEqual(pipe(input, RA.dropRight(2)), [1])\n * assert.strictEqual(pipe(input, RA.dropRight(0)), input)\n * assert.strictEqual(pipe(input, RA.dropRight(-1)), input)\n *\n * @since 2.5.0\n */\nexport var dropRight = function (n) {\n    return function (as) {\n        return n <= 0 || isEmpty(as) ? as : n >= as.length ? empty : as.slice(0, as.length - n);\n    };\n};\nexport function dropLeftWhile(predicate) {\n    return function (as) {\n        var i = spanLeftIndex(as, predicate);\n        return i === 0 ? as : i === as.length ? empty : as.slice(i);\n    };\n}\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 */\nexport var findIndex = function (predicate) {\n    return function (as) {\n        for (var i = 0; i < as.length; i++) {\n            if (predicate(as[i])) {\n                return _.some(i);\n            }\n        }\n        return _.none;\n    };\n};\nexport function findFirst(predicate) {\n    return function (as) {\n        for (var i = 0; i < as.length; i++) {\n            if (predicate(as[i])) {\n                return _.some(as[i]);\n            }\n        }\n        return _.none;\n    };\n}\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 *   readonly name: string\n *   readonly 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 */\nexport var findFirstMap = function (f) {\n    return function (as) {\n        for (var i = 0; i < as.length; i++) {\n            var out = f(as[i]);\n            if (_.isSome(out)) {\n                return out;\n            }\n        }\n        return _.none;\n    };\n};\nexport function findLast(predicate) {\n    return function (as) {\n        for (var i = as.length - 1; i >= 0; i--) {\n            if (predicate(as[i])) {\n                return _.some(as[i]);\n            }\n        }\n        return _.none;\n    };\n}\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 *   readonly name: string\n *   readonly 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 */\nexport var findLastMap = function (f) {\n    return function (as) {\n        for (var i = as.length - 1; i >= 0; i--) {\n            var out = f(as[i]);\n            if (_.isSome(out)) {\n                return out;\n            }\n        }\n        return _.none;\n    };\n};\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 *   readonly a: number\n *   readonly b: number\n * }\n * const xs: ReadonlyArray<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 *\n * @since 2.5.0\n */\nexport var findLastIndex = function (predicate) {\n    return function (as) {\n        for (var i = as.length - 1; i >= 0; i--) {\n            if (predicate(as[i])) {\n                return _.some(i);\n            }\n        }\n        return _.none;\n    };\n};\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 */\nexport var insertAt = function (i, a) {\n    return function (as) {\n        return i < 0 || i > as.length ? _.none : _.some(RNEA.unsafeInsertAt(i, a, as));\n    };\n};\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 */\nexport var updateAt = function (i, a) {\n    return modifyAt(i, function () { return a; });\n};\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 */\nexport var deleteAt = function (i) {\n    return function (as) {\n        return isOutOfBound(i, as) ? _.none : _.some(unsafeDeleteAt(i, as));\n    };\n};\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 */\nexport var modifyAt = function (i, f) {\n    return function (as) {\n        return isOutOfBound(i, as) ? _.none : _.some(unsafeUpdateAt(i, f(as[i]), as));\n    };\n};\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 * @since 2.5.0\n */\nexport var reverse = function (as) { return (as.length <= 1 ? as : as.slice().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 * @since 2.5.0\n */\nexport var 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};\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 */\nexport var 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};\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 * as N from 'fp-ts/number'\n *\n * assert.deepStrictEqual(sort(N.Ord)([3, 2, 1]), [1, 2, 3])\n *\n * @since 2.5.0\n */\nexport var sort = function (O) {\n    return function (as) {\n        return as.length <= 1 ? as : as.slice().sort(O.compare);\n    };\n};\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 * @since 2.5.0\n */\nexport var 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};\nexport function 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}\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 */\nexport var 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};\n/**\n * Prepend an element to every member of an array\n *\n * @example\n * import { prependAll } from 'fp-ts/ReadonlyArray'\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 */\nexport var prependAll = function (middle) {\n    var f = RNEA.prependAll(middle);\n    return function (as) { return (isNonEmpty(as) ? f(as) : as); };\n};\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 * @since 2.9.0\n */\nexport var intersperse = function (middle) {\n    var f = RNEA.intersperse(middle);\n    return function (as) { return (isNonEmpty(as) ? f(as) : as); };\n};\n/**\n * Rotate a `ReadonlyArray` 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 * @since 2.5.0\n */\nexport var rotate = function (n) {\n    var f = RNEA.rotate(n);\n    return function (as) { return (isNonEmpty(as) ? f(as) : as); };\n};\nexport function 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        for (; i < as.length; i++) {\n            if (predicate(as[i])) {\n                return true;\n            }\n        }\n        return false;\n    };\n}\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 * as N from 'fp-ts/number'\n *\n * assert.deepStrictEqual(uniq(N.Eq)([1, 2, 1]), [1, 2])\n *\n * @since 2.5.0\n */\nexport var uniq = function (E) {\n    var f = RNEA.uniq(E);\n    return function (as) { return (isNonEmpty(as) ? f(as) : as); };\n};\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 { 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.5.0\n */\nexport var sortBy = function (ords) {\n    var f = RNEA.sortBy(ords);\n    return function (as) { return (isNonEmpty(as) ? f(as) : as); };\n};\n/**\n * A useful recursion pattern for processing a `ReadonlyArray` to produce a new `ReadonlyArray`, often used for \"chopping\" up the input\n * `ReadonlyArray`. Typically `chop` is called with some function that will consume an initial prefix of the `ReadonlyArray` and produce a\n * value and the tail of the `ReadonlyArray`.\n *\n * @example\n * import { Eq } from 'fp-ts/Eq'\n * import * as RA from 'fp-ts/ReadonlyArray'\n * import * as N from 'fp-ts/number'\n * import { pipe } from 'fp-ts/function'\n *\n * const group = <A>(S: Eq<A>): ((as: ReadonlyArray<A>) => ReadonlyArray<ReadonlyArray<A>>) => {\n *   return RA.chop(as => {\n *     const { init, rest } = pipe(as, RA.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.5.0\n */\nexport var chop = function (f) {\n    var g = RNEA.chop(f);\n    return function (as) { return (isNonEmpty(as) ? g(as) : empty); };\n};\n/**\n * Splits a `ReadonlyArray` into two pieces, the first piece has max `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 */\nexport var splitAt = function (n) {\n    return function (as) {\n        return n >= 1 && isNonEmpty(as) ? RNEA.splitAt(n)(as) : isEmpty(as) ? [as, empty] : [empty, as];\n    };\n};\n/**\n * Splits a `ReadonlyArray` into length-`n` pieces. The last piece will be shorter if `n` does not evenly divide the length of\n * the `ReadonlyArray`. 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 `as`.\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 * @since 2.5.0\n */\nexport var chunksOf = function (n) {\n    var f = RNEA.chunksOf(n);\n    return function (as) { return (isNonEmpty(as) ? f(as) : empty); };\n};\n/**\n * @category lifting\n * @since 2.11.0\n */\nexport var 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 fromOption(f.apply(void 0, a));\n    };\n};\nexport function comprehension(input, f, g) {\n    if (g === void 0) { g = function () { return true; }; }\n    var go = function (scope, input) {\n        return isNonEmpty(input)\n            ? flatMap(RNEA.head(input), function (a) { return go(pipe(scope, append(a)), RNEA.tail(input)); })\n            : g.apply(void 0, scope) ? [f.apply(void 0, scope)]\n                : empty;\n    };\n    return go(empty, input);\n}\n/**\n * @since 2.11.0\n */\nexport var concatW = function (second) {\n    return function (first) {\n        return isEmpty(first) ? second : isEmpty(second) ? first : first.concat(second);\n    };\n};\n/**\n * @since 2.11.0\n */\nexport var concat = concatW;\nexport function union(E) {\n    var unionE = RNEA.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 isNonEmpty(first) && isNonEmpty(second) ? unionE(second)(first) : isNonEmpty(first) ? first : second;\n    };\n}\nexport function 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}\nexport function 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}\nvar _map = function (fa, f) { return pipe(fa, map(f)); };\nvar _mapWithIndex = function (fa, f) { return pipe(fa, mapWithIndex(f)); };\nvar _ap = function (fab, fa) { return pipe(fab, ap(fa)); };\nvar _filter = function (fa, predicate) {\n    return pipe(fa, filter(predicate));\n};\nvar _filterMap = function (fa, f) { return pipe(fa, filterMap(f)); };\nvar _partition = function (fa, predicate) {\n    return pipe(fa, partition(predicate));\n};\nvar _partitionMap = function (fa, f) { return pipe(fa, partitionMap(f)); };\nvar _partitionWithIndex = function (fa, predicateWithIndex) { return pipe(fa, partitionWithIndex(predicateWithIndex)); };\nvar _partitionMapWithIndex = function (fa, f) { return pipe(fa, partitionMapWithIndex(f)); };\nvar _alt = function (fa, that) { return pipe(fa, alt(that)); };\nvar _reduce = function (fa, b, f) { return pipe(fa, reduce(b, f)); };\nvar _foldMap = function (M) {\n    var foldMapM = foldMap(M);\n    return function (fa, f) { return pipe(fa, foldMapM(f)); };\n};\nvar _reduceRight = function (fa, b, f) { return pipe(fa, reduceRight(b, f)); };\nvar _reduceWithIndex = function (fa, b, f) {\n    return pipe(fa, reduceWithIndex(b, f));\n};\nvar _foldMapWithIndex = function (M) {\n    var foldMapWithIndexM = foldMapWithIndex(M);\n    return function (fa, f) { return pipe(fa, foldMapWithIndexM(f)); };\n};\nvar _reduceRightWithIndex = function (fa, b, f) {\n    return pipe(fa, reduceRightWithIndex(b, f));\n};\nvar _filterMapWithIndex = function (fa, f) { return pipe(fa, filterMapWithIndex(f)); };\nvar _filterWithIndex = function (fa, predicateWithIndex) { return pipe(fa, filterWithIndex(predicateWithIndex)); };\nvar _extend = function (fa, f) { return pipe(fa, extend(f)); };\nvar _traverse = function (F) {\n    var traverseF = traverse(F);\n    return function (ta, f) { return pipe(ta, traverseF(f)); };\n};\n/* istanbul ignore next */\nvar _traverseWithIndex = function (F) {\n    var traverseWithIndexF = traverseWithIndex(F);\n    return function (ta, f) { return pipe(ta, traverseWithIndexF(f)); };\n};\n/** @internal */\nexport var _chainRecDepthFirst = function (a, f) { return pipe(a, chainRecDepthFirst(f)); };\n/** @internal */\nexport var _chainRecBreadthFirst = function (a, f) { return pipe(a, chainRecBreadthFirst(f)); };\n/**\n * @category constructors\n * @since 2.5.0\n */\nexport var of = RNEA.of;\n/**\n * @since 2.7.0\n */\nexport var zero = function () { return empty; };\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 RA from 'fp-ts/ReadonlyArray'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     [1, 2, 3],\n *     RA.altW(() => ['a', 'b'])\n *   ),\n *   [1, 2, 3, 'a', 'b']\n * )\n *\n * @category error handling\n * @since 2.9.0\n */\nexport var altW = function (that) {\n    return function (fa) {\n        return fa.concat(that());\n    };\n};\n/**\n * Identifies an associative operation on a type constructor. It is similar to `Semigroup`, except that it applies to\n * types of kind `* -> *`.\n *\n * In case of `ReadonlyArray` concatenates the inputs into a single array.\n *\n * @example\n * import * as RA from 'fp-ts/ReadonlyArray'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     [1, 2, 3],\n *     RA.alt(() => [4, 5])\n *   ),\n *   [1, 2, 3, 4, 5]\n * )\n *\n * @category error handling\n * @since 2.5.0\n */\nexport var alt = altW;\n/**\n * @since 2.5.0\n */\nexport var ap = function (fa) {\n    return flatMap(function (f) { return pipe(fa, map(f)); });\n};\n/**\n * Composes computations in sequence, using the return value of one computation to determine the next computation.\n *\n * @example\n * import * as RA from 'fp-ts/ReadonlyArray'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     [1, 2, 3],\n *     RA.flatMap((n) => [`a${n}`, `b${n}`])\n *   ),\n *   ['a1', 'b1', 'a2', 'b2', 'a3', 'b3']\n * )\n * assert.deepStrictEqual(\n *   pipe(\n *     [1, 2, 3],\n *     RA.flatMap(() => [])\n *   ),\n *   []\n * )\n *\n * @category sequencing\n * @since 2.14.0\n */\nexport var flatMap = /*#__PURE__*/ dual(2, function (ma, f) {\n    return pipe(ma, chainWithIndex(function (i, a) { return f(a, i); }));\n});\n/**\n * @category sequencing\n * @since 2.5.0\n */\nexport var flatten = /*#__PURE__*/ flatMap(identity);\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 mapping\n * @since 2.5.0\n */\nexport var map = function (f) { return function (fa) {\n    return fa.map(function (a) { return f(a); });\n}; };\n/**\n * @category mapping\n * @since 2.5.0\n */\nexport var mapWithIndex = function (f) { return function (fa) {\n    return fa.map(function (a, i) { return f(i, a); });\n}; };\n/**\n * @category filtering\n * @since 2.5.0\n */\nexport var 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 separated(left, right);\n};\n/**\n * @category filtering\n * @since 2.5.0\n */\nexport var filter = function (predicate) {\n    return function (as) {\n        return as.filter(predicate);\n    };\n};\n/**\n * @category filtering\n * @since 2.5.0\n */\nexport var 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};\n/**\n * @category filtering\n * @since 2.5.0\n */\nexport var filterMap = function (f) {\n    return filterMapWithIndex(function (_, a) { return f(a); });\n};\n/**\n * @category filtering\n * @since 2.5.0\n */\nexport var compact = /*#__PURE__*/ filterMap(identity);\n/**\n * @category filtering\n * @since 2.5.0\n */\nexport var partition = function (predicate) {\n    return partitionWithIndex(function (_, a) { return predicate(a); });\n};\n/**\n * @category filtering\n * @since 2.5.0\n */\nexport var partitionWithIndex = function (predicateWithIndex) {\n    return function (as) {\n        var left = [];\n        var right = [];\n        for (var i = 0; i < as.length; i++) {\n            var a = as[i];\n            if (predicateWithIndex(i, a)) {\n                right.push(a);\n            }\n            else {\n                left.push(a);\n            }\n        }\n        return separated(left, right);\n    };\n};\n/**\n * @category filtering\n * @since 2.5.0\n */\nexport var partitionMap = function (f) {\n    return partitionMapWithIndex(function (_, a) { return f(a); });\n};\n/**\n * @category filtering\n * @since 2.5.0\n */\nexport var 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 separated(left, right);\n    };\n};\n/**\n * @category filtering\n * @since 2.5.0\n */\nexport var filterWithIndex = function (predicateWithIndex) {\n    return function (as) {\n        return as.filter(function (a, i) { return predicateWithIndex(i, a); });\n    };\n};\n/**\n * @since 2.5.0\n */\nexport var extend = function (f) { return function (wa) {\n    return wa.map(function (_, i) { return f(wa.slice(i)); });\n}; };\n/**\n * @since 2.5.0\n */\nexport var duplicate = /*#__PURE__*/ extend(identity);\n/**\n * @category folding\n * @since 2.5.0\n */\nexport var foldMapWithIndex = function (M) {\n    return function (f) {\n        return function (fa) {\n            return fa.reduce(function (b, a, i) { return M.concat(b, f(i, a)); }, M.empty);\n        };\n    };\n};\n/**\n * @category folding\n * @since 2.5.0\n */\nexport var reduce = function (b, f) {\n    return reduceWithIndex(b, function (_, b, a) { return f(b, a); });\n};\n/**\n * @category folding\n * @since 2.5.0\n */\nexport var foldMap = function (M) {\n    var foldMapWithIndexM = foldMapWithIndex(M);\n    return function (f) { return foldMapWithIndexM(function (_, a) { return f(a); }); };\n};\n/**\n * @category folding\n * @since 2.5.0\n */\nexport var reduceWithIndex = function (b, f) { return function (fa) {\n    var len = fa.length;\n    var out = b;\n    for (var i = 0; i < len; i++) {\n        out = f(i, out, fa[i]);\n    }\n    return out;\n}; };\n/**\n * @category folding\n * @since 2.5.0\n */\nexport var reduceRight = function (b, f) {\n    return reduceRightWithIndex(b, function (_, a, b) { return f(a, b); });\n};\n/**\n * @category folding\n * @since 2.5.0\n */\nexport var reduceRightWithIndex = function (b, f) { return function (fa) {\n    return fa.reduceRight(function (b, a, i) { return f(i, a, b); }, b);\n}; };\n/**\n * @category traversing\n * @since 2.6.3\n */\nexport var traverse = function (F) {\n    var traverseWithIndexF = traverseWithIndex(F);\n    return function (f) { return traverseWithIndexF(function (_, a) { return f(a); }); };\n};\n/**\n * @category traversing\n * @since 2.6.3\n */\nexport var sequence = function (F) {\n    return function (ta) {\n        return _reduce(ta, F.of(zero()), function (fas, fa) {\n            return F.ap(F.map(fas, function (as) { return function (a) { return pipe(as, append(a)); }; }), fa);\n        });\n    };\n};\n/**\n * @category sequencing\n * @since 2.6.3\n */\nexport var traverseWithIndex = function (F) {\n    return function (f) {\n        return reduceWithIndex(F.of(zero()), function (i, fbs, a) {\n            return F.ap(F.map(fbs, function (bs) { return function (b) { return pipe(bs, append(b)); }; }), f(i, a));\n        });\n    };\n};\n/**\n * @category filtering\n * @since 2.6.5\n */\nexport var wither = function (F) {\n    var _witherF = _wither(F);\n    return function (f) { return function (fa) { return _witherF(fa, f); }; };\n};\n/**\n * @category filtering\n * @since 2.6.5\n */\nexport var wilt = function (F) {\n    var _wiltF = _wilt(F);\n    return function (f) { return function (fa) { return _wiltF(fa, f); }; };\n};\n/**\n * @since 2.6.6\n */\nexport var 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};\n/**\n * @category type lambdas\n * @since 2.5.0\n */\nexport var URI = 'ReadonlyArray';\n/**\n * @category instances\n * @since 2.5.0\n */\nexport var getShow = function (S) { return ({\n    show: function (as) { return \"[\".concat(as.map(S.show).join(', '), \"]\"); }\n}); };\n/**\n * @category instances\n * @since 2.5.0\n */\nexport var getSemigroup = function () { return ({\n    concat: function (first, second) { return (isEmpty(first) ? second : isEmpty(second) ? first : first.concat(second)); }\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 */\nexport var getMonoid = function () { return ({\n    concat: getSemigroup().concat,\n    empty: empty\n}); };\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 * as S from 'fp-ts/string'\n * import { getEq } from 'fp-ts/ReadonlyArray'\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.5.0\n */\nexport var getEq = function (E) {\n    return fromEquals(function (xs, ys) { return xs.length === ys.length && xs.every(function (x, i) { return E.equals(x, ys[i]); }); });\n};\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 * 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 *\n * @category instances\n * @since 2.5.0\n */\nexport var getOrd = function (O) {\n    return 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 N.Ord.compare(aLen, bLen);\n    });\n};\n/**\n * @category instances\n * @since 2.11.0\n */\nexport var getUnionSemigroup = function (E) {\n    var unionE = union(E);\n    return {\n        concat: function (first, second) { return unionE(second)(first); }\n    };\n};\n/**\n * @category instances\n * @since 2.11.0\n */\nexport var getUnionMonoid = function (E) { return ({\n    concat: getUnionSemigroup(E).concat,\n    empty: empty\n}); };\n/**\n * @category instances\n * @since 2.11.0\n */\nexport var getIntersectionSemigroup = function (E) {\n    var intersectionE = intersection(E);\n    return {\n        concat: function (first, second) { return intersectionE(second)(first); }\n    };\n};\n/**\n * @category instances\n * @since 2.11.0\n */\nexport var getDifferenceMagma = function (E) {\n    var differenceE = difference(E);\n    return {\n        concat: function (first, second) { return differenceE(second)(first); }\n    };\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Functor = {\n    URI: URI,\n    map: _map\n};\n/**\n * @category mapping\n * @since 2.10.0\n */\nexport var flap = /*#__PURE__*/ flap_(Functor);\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var Pointed = {\n    URI: URI,\n    of: of\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var FunctorWithIndex = {\n    URI: URI,\n    map: _map,\n    mapWithIndex: _mapWithIndex\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var Apply = {\n    URI: 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 */\nexport var apFirst = /*#__PURE__*/ apFirst_(Apply);\n/**\n * Combine two effectful actions, keeping only the result of the second.\n *\n * @since 2.5.0\n */\nexport var apSecond = /*#__PURE__*/ apSecond_(Apply);\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Applicative = {\n    URI: URI,\n    map: _map,\n    ap: _ap,\n    of: of\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var Chain = {\n    URI: URI,\n    map: _map,\n    ap: _ap,\n    chain: flatMap\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Monad = {\n    URI: URI,\n    map: _map,\n    ap: _ap,\n    of: of,\n    chain: flatMap\n};\n/**\n * 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 RA from 'fp-ts/ReadonlyArray'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     [1, 2, 3],\n *     RA.chainFirst(() => ['a', 'b'])\n *   ),\n *   [1, 1, 2, 2, 3, 3]\n * )\n * assert.deepStrictEqual(\n *   pipe(\n *     [1, 2, 3],\n *     RA.chainFirst(() => [])\n *   ),\n *   []\n * )\n *\n * @category sequencing\n * @since 2.5.0\n */\nexport var chainFirst = \n/*#__PURE__*/ chainFirst_(Chain);\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Unfoldable = {\n    URI: URI,\n    unfold: unfold\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Alt = {\n    URI: URI,\n    map: _map,\n    alt: _alt\n};\n/**\n * @category instances\n * @since 2.11.0\n */\nexport var Zero = {\n    URI: URI,\n    zero: zero\n};\n/**\n * @category do notation\n * @since 2.11.0\n */\nexport var guard = /*#__PURE__*/ guard_(Zero, Pointed);\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Alternative = {\n    URI: URI,\n    map: _map,\n    ap: _ap,\n    of: of,\n    alt: _alt,\n    zero: zero\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Extend = {\n    URI: URI,\n    map: _map,\n    extend: _extend\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Compactable = {\n    URI: URI,\n    compact: compact,\n    separate: separate\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Filterable = {\n    URI: URI,\n    map: _map,\n    compact: compact,\n    separate: separate,\n    filter: _filter,\n    filterMap: _filterMap,\n    partition: _partition,\n    partitionMap: _partitionMap\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var FilterableWithIndex = {\n    URI: URI,\n    map: _map,\n    mapWithIndex: _mapWithIndex,\n    compact: compact,\n    separate: separate,\n    filter: _filter,\n    filterMap: _filterMap,\n    partition: _partition,\n    partitionMap: _partitionMap,\n    partitionMapWithIndex: _partitionMapWithIndex,\n    partitionWithIndex: _partitionWithIndex,\n    filterMapWithIndex: _filterMapWithIndex,\n    filterWithIndex: _filterWithIndex\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Foldable = {\n    URI: URI,\n    reduce: _reduce,\n    foldMap: _foldMap,\n    reduceRight: _reduceRight\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var FoldableWithIndex = {\n    URI: URI,\n    reduce: _reduce,\n    foldMap: _foldMap,\n    reduceRight: _reduceRight,\n    reduceWithIndex: _reduceWithIndex,\n    foldMapWithIndex: _foldMapWithIndex,\n    reduceRightWithIndex: _reduceRightWithIndex\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Traversable = {\n    URI: URI,\n    map: _map,\n    reduce: _reduce,\n    foldMap: _foldMap,\n    reduceRight: _reduceRight,\n    traverse: _traverse,\n    sequence: sequence\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var TraversableWithIndex = {\n    URI: URI,\n    map: _map,\n    mapWithIndex: _mapWithIndex,\n    reduce: _reduce,\n    foldMap: _foldMap,\n    reduceRight: _reduceRight,\n    reduceWithIndex: _reduceWithIndex,\n    foldMapWithIndex: _foldMapWithIndex,\n    reduceRightWithIndex: _reduceRightWithIndex,\n    traverse: _traverse,\n    sequence: sequence,\n    traverseWithIndex: _traverseWithIndex\n};\n/**\n * @category sequencing\n * @since 2.11.0\n */\nexport var chainRecDepthFirst = function (f) {\n    return function (a) {\n        var todo = __spreadArray([], f(a), true);\n        var out = [];\n        while (todo.length > 0) {\n            var e = todo.shift();\n            if (_.isLeft(e)) {\n                todo.unshift.apply(todo, f(e.left));\n            }\n            else {\n                out.push(e.right);\n            }\n        }\n        return out;\n    };\n};\n/**\n * @category instances\n * @since 2.11.0\n */\nexport var ChainRecDepthFirst = {\n    URI: URI,\n    map: _map,\n    ap: _ap,\n    chain: flatMap,\n    chainRec: _chainRecDepthFirst\n};\n/**\n * @category sequencing\n * @since 2.11.0\n */\nexport var chainRecBreadthFirst = function (f) {\n    return function (a) {\n        var initial = f(a);\n        var todo = [];\n        var out = [];\n        function go(e) {\n            if (_.isLeft(e)) {\n                f(e.left).forEach(function (v) { return todo.push(v); });\n            }\n            else {\n                out.push(e.right);\n            }\n        }\n        for (var _i = 0, initial_1 = initial; _i < initial_1.length; _i++) {\n            var e = initial_1[_i];\n            go(e);\n        }\n        while (todo.length > 0) {\n            go(todo.shift());\n        }\n        return out;\n    };\n};\n/**\n * @category instances\n * @since 2.11.0\n */\nexport var ChainRecBreadthFirst = {\n    URI: URI,\n    map: _map,\n    ap: _ap,\n    chain: flatMap,\n    chainRec: _chainRecBreadthFirst\n};\nvar _wither = /*#__PURE__*/ witherDefault(Traversable, Compactable);\nvar _wilt = /*#__PURE__*/ wiltDefault(Traversable, Compactable);\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Witherable = {\n    URI: URI,\n    map: _map,\n    compact: compact,\n    separate: separate,\n    filter: _filter,\n    filterMap: _filterMap,\n    partition: _partition,\n    partitionMap: _partitionMap,\n    reduce: _reduce,\n    foldMap: _foldMap,\n    reduceRight: _reduceRight,\n    traverse: _traverse,\n    sequence: sequence,\n    wither: _wither,\n    wilt: _wilt\n};\n/**\n * Filter values inside a context.\n *\n * @example\n * import { pipe } from 'fp-ts/function'\n * import * as RA from 'fp-ts/ReadonlyArray'\n * import * as T from 'fp-ts/Task'\n *\n * const filterE = RA.filterE(T.ApplicativePar)\n * async function test() {\n *   assert.deepStrictEqual(\n *     await pipe(\n *       [-1, 2, 3],\n *       filterE((n) => T.of(n > 0))\n *     )(),\n *     [2, 3]\n *   )\n * }\n * test()\n *\n * @since 2.11.0\n */\nexport var filterE = /*#__PURE__*/ filterE_(Witherable);\n/**\n * @category instances\n * @since 2.11.0\n */\nexport var FromEither = {\n    URI: URI,\n    fromEither: fromEither\n};\n/**\n * @category lifting\n * @since 2.11.0\n */\nexport var fromEitherK = /*#__PURE__*/ fromEitherK_(FromEither);\n// -------------------------------------------------------------------------------------\n// unsafe\n// -------------------------------------------------------------------------------------\n/**\n * @category unsafe\n * @since 2.5.0\n */\nexport var unsafeInsertAt = RNEA.unsafeInsertAt;\n/**\n * @category unsafe\n * @since 2.5.0\n */\nexport var unsafeUpdateAt = function (i, a, as) {\n    return isNonEmpty(as) ? RNEA.unsafeUpdateAt(i, a, as) : as;\n};\n/**\n * @category unsafe\n * @since 2.5.0\n */\nexport var unsafeDeleteAt = function (i, as) {\n    var xs = as.slice();\n    xs.splice(i, 1);\n    return xs;\n};\n/**\n * @category conversions\n * @since 2.5.0\n */\nexport var toArray = function (as) { return as.slice(); };\n/**\n * @category conversions\n * @since 2.5.0\n */\nexport var fromArray = function (as) { return (isEmpty(as) ? empty : as.slice()); };\n// -------------------------------------------------------------------------------------\n// utils\n// -------------------------------------------------------------------------------------\n/**\n * An empty array\n *\n * @since 2.5.0\n */\nexport var empty = RNEA.empty;\nexport function every(predicate) {\n    return function (as) { return as.every(predicate); };\n}\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 */\nexport var some = function (predicate) {\n    return function (as) {\n        return as.some(predicate);\n    };\n};\n/**\n * Alias of [`some`](#some)\n *\n * @since 2.11.0\n */\nexport var exists = some;\n/**\n * Places an element in between members of a `ReadonlyArray`, 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/ReadonlyArray'\n *\n * assert.deepStrictEqual(intercalate(S.Monoid)('-')(['a', 'b', 'c']), 'a-b-c')\n *\n * @since 2.12.0\n */\nexport var intercalate = function (M) {\n    var intercalateM = RNEA.intercalate(M);\n    return function (middle) { return match(function () { return M.empty; }, intercalateM(middle)); };\n};\n// -------------------------------------------------------------------------------------\n// do notation\n// -------------------------------------------------------------------------------------\n/**\n * @category do notation\n * @since 2.9.0\n */\nexport var Do = /*#__PURE__*/ of(_.emptyRecord);\n/**\n * @category do notation\n * @since 2.8.0\n */\nexport var bindTo = /*#__PURE__*/ bindTo_(Functor);\nvar let_ = /*#__PURE__*/ let__(Functor);\nexport { \n/**\n * @category do notation\n * @since 2.13.0\n */\nlet_ as let };\n/**\n * @category do notation\n * @since 2.8.0\n */\nexport var bind = /*#__PURE__*/ bind_(Chain);\n/**\n * @category do notation\n * @since 2.8.0\n */\nexport var apS = /*#__PURE__*/ apS_(Apply);\n// -------------------------------------------------------------------------------------\n// legacy\n// -------------------------------------------------------------------------------------\n/**\n * Alias of `flatMap`.\n *\n * @category legacy\n * @since 2.5.0\n */\nexport var chain = flatMap;\n// -------------------------------------------------------------------------------------\n// deprecated\n// -------------------------------------------------------------------------------------\n/**\n * Use `ReadonlyNonEmptyArray` module instead.\n *\n * @category zone of death\n * @since 2.5.0\n * @deprecated\n */\nexport var range = RNEA.range;\n/**\n * Use [`prepend`](#prepend) instead.\n *\n * @category zone of death\n * @since 2.5.0\n * @deprecated\n */\nexport var cons = RNEA.cons;\n/**\n * Use [`append`](#append) instead.\n *\n * @category zone of death\n * @since 2.5.0\n * @deprecated\n */\nexport var snoc = RNEA.snoc;\n/**\n * Use [`prependAll`](#prependall) instead.\n *\n * @category zone of death\n * @since 2.9.0\n * @deprecated\n */\nexport var prependToAll = prependAll;\n/**\n * This instance is deprecated, use small, specific instances instead.\n * For example if a function needs a `Functor` instance, pass `RA.Functor` instead of `RA.readonlyArray`\n * (where `RA` is from `import RA from 'fp-ts/ReadonlyArray'`)\n *\n * @category zone of death\n * @since 2.5.0\n * @deprecated\n */\nexport var readonlyArray = {\n    URI: URI,\n    compact: compact,\n    separate: separate,\n    map: _map,\n    ap: _ap,\n    of: of,\n    chain: 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: zero,\n    unfold: unfold,\n    reduce: _reduce,\n    foldMap: _foldMap,\n    reduceRight: _reduceRight,\n    traverse: _traverse,\n    sequence: sequence,\n    reduceWithIndex: _reduceWithIndex,\n    foldMapWithIndex: _foldMapWithIndex,\n    reduceRightWithIndex: _reduceRightWithIndex,\n    traverseWithIndex: _traverseWithIndex,\n    extend: _extend,\n    wither: _wither,\n    wilt: _wilt\n};\n"],"names":["this","RNEA.isNonEmpty","RNEA.prepend","RNEA.prependW","RNEA.append","RNEA.appendW","RNEA.makeBy","_.isNone","_.isLeft","RNEA.head","RNEA.tail","RNEA.init","RNEA.last","RNEA.isOutOfBound","as","_.none","_.some","init","_.isSome","RNEA.unsafeInsertAt","bs","RNEA.prependAll","RNEA.intersperse","RNEA.rotate","RNEA.uniq","RNEA.sortBy","RNEA.chop","RNEA.splitAt","RNEA.chunksOf","input","RNEA.union","second","ys","RNEA.of","b","N.Ord","flap_","apFirst_","apSecond_","chainFirst_","guard_","e","filterE_","fromEitherK_","RNEA.unsafeUpdateAt","RNEA.empty","RNEA.intercalate","_.emptyRecord","bindTo_","let__","bind_","apS_","RNEA.range","RNEA.cons","RNEA.snoc"],"mappings":"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","x_google_ignoreList":[0]}