@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/ReadonlyArray.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ReadonlyArray.js","sources":["../../../../../../node_modules/fp-ts/lib/ReadonlyArray.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};\nvar __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};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.sort = exports.lefts = exports.rights = exports.reverse = exports.modifyAt = exports.deleteAt = exports.updateAt = exports.insertAt = exports.findLastIndex = exports.findLastMap = exports.findLast = exports.findFirstMap = exports.findFirst = exports.findIndex = exports.dropLeftWhile = exports.dropRight = exports.dropLeft = exports.spanLeft = exports.takeLeftWhile = exports.takeRight = exports.takeLeft = exports.init = exports.tail = exports.last = exports.head = exports.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.sequence = exports.traverse = exports.reduceRightWithIndex = exports.reduceRight = exports.reduceWithIndex = exports.foldMap = exports.reduce = exports.foldMapWithIndex = exports.duplicate = exports.extend = exports.filterWithIndex = exports.partitionMapWithIndex = exports.partitionMap = exports.partitionWithIndex = exports.partition = exports.compact = exports.filterMap = exports.filterMapWithIndex = exports.filter = exports.separate = exports.mapWithIndex = exports.map = exports.flatten = exports.flatMap = exports.ap = exports.alt = exports.altW = exports.zero = exports.of = exports._chainRecBreadthFirst = exports._chainRecDepthFirst = 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 = void 0;\nexports.toArray = exports.unsafeDeleteAt = exports.unsafeUpdateAt = exports.unsafeInsertAt = exports.fromEitherK = exports.FromEither = exports.filterE = exports.Witherable = exports.ChainRecBreadthFirst = exports.chainRecBreadthFirst = exports.ChainRecDepthFirst = exports.chainRecDepthFirst = 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.chainFirst = exports.Monad = 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 = exports.traverseWithIndex = void 0;\nexports.readonlyArray = exports.prependToAll = exports.snoc = exports.cons = exports.range = exports.chain = exports.apS = exports.bind = exports.let = exports.bindTo = exports.Do = exports.intercalate = exports.exists = exports.some = exports.every = exports.empty = exports.fromArray = void 0;\nvar Apply_1 = require(\"./Apply\");\nvar Chain_1 = require(\"./Chain\");\nvar Eq_1 = require(\"./Eq\");\nvar FromEither_1 = require(\"./FromEither\");\nvar function_1 = require(\"./function\");\nvar Functor_1 = require(\"./Functor\");\nvar _ = __importStar(require(\"./internal\"));\nvar N = __importStar(require(\"./number\"));\nvar Ord_1 = require(\"./Ord\");\nvar RNEA = __importStar(require(\"./ReadonlyNonEmptyArray\"));\nvar Separated_1 = require(\"./Separated\");\nvar Witherable_1 = require(\"./Witherable\");\nvar Zero_1 = require(\"./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 */\nvar isEmpty = function (as) { return as.length === 0; };\nexports.isEmpty = isEmpty;\n/**\n * Test whether a `ReadonlyArray` is non empty.\n *\n * @category refinements\n * @since 2.5.0\n */\nexports.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 */\nexports.prepend = RNEA.prepend;\n/**\n * Less strict version of [`prepend`](#prepend).\n *\n * @since 2.11.0\n */\nexports.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 */\nexports.append = RNEA.append;\n/**\n * Less strict version of [`append`](#append).\n *\n * @since 2.11.0\n */\nexports.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 */\nvar makeBy = function (n, f) { return (n <= 0 ? exports.empty : RNEA.makeBy(f)(n)); };\nexports.makeBy = makeBy;\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 */\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] : exports.empty); };\n}\nexports.fromPredicate = fromPredicate;\n// -------------------------------------------------------------------------------------\n// conversions\n// -------------------------------------------------------------------------------------\n/**\n * @category conversions\n * @since 2.11.0\n */\nvar fromOption = function (ma) { return (_.isNone(ma) ? exports.empty : [ma.value]); };\nexports.fromOption = fromOption;\n/**\n * Transforms an `Either` to a `ReadonlyArray`.\n *\n * @category conversions\n * @since 2.11.0\n */\nvar fromEither = function (e) { return (_.isLeft(e) ? exports.empty : [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 * @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 * @category pattern matching\n * @since 2.11.0\n */\nexports.match = exports.matchW;\n/**\n * Less strict version of [`matchLeft`](#matchleft).\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(RNEA.head(as), RNEA.tail(as)) : onEmpty();\n    };\n};\nexports.matchLeftW = matchLeftW;\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 */\nexports.matchLeft = exports.matchLeftW;\n/**\n * Alias of [`matchLeft`](#matchleft).\n *\n * @category pattern matching\n * @since 2.5.0\n */\nexports.foldLeft = exports.matchLeft;\n/**\n * Less strict version of [`matchRight`](#matchright).\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(RNEA.init(as), RNEA.last(as)) : onEmpty();\n    };\n};\nexports.matchRightW = matchRightW;\n/**\n * Break a `ReadonlyArray` into its initial elements and the last element.\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.5.0\n */\nexports.foldRight = exports.matchRight;\n// -------------------------------------------------------------------------------------\n// combinators\n// -------------------------------------------------------------------------------------\n/**\n * @category sequencing\n * @since 2.7.0\n */\nvar chainWithIndex = function (f) {\n    return function (as) {\n        if ((0, exports.isEmpty)(as)) {\n            return exports.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};\nexports.chainWithIndex = chainWithIndex;\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 */\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/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 */\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 `ReadonlyArray`.\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 * @since 2.5.0\n */\nexports.isOutOfBound = RNEA.isOutOfBound;\nfunction lookup(i, as) {\n    return as === undefined ? function (as) { return lookup(i, as); } : (0, exports.isOutOfBound)(i, as) ? _.none : _.some(as[i]);\n}\nexports.lookup = 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/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 */\nvar head = function (as) { return ((0, exports.isNonEmpty)(as) ? _.some(RNEA.head(as)) : _.none); };\nexports.head = head;\n/**\n * Get the last element in an array, or `None` if the array is empty\n *\n * @example\n * import { last } from 'fp-ts/ReadonlyArray'\n * import { some, none } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(last([1, 2, 3]), some(3))\n * assert.deepStrictEqual(last([]), none)\n *\n * @since 2.5.0\n */\nvar last = function (as) { return ((0, exports.isNonEmpty)(as) ? _.some(RNEA.last(as)) : _.none); };\nexports.last = last;\n/**\n * Get all but the first element of an array, creating a new array, or `None` if the array is empty\n *\n * @example\n * import { tail } from 'fp-ts/ReadonlyArray'\n * import { some, none } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(tail([1, 2, 3]), some([2, 3]))\n * assert.deepStrictEqual(tail([]), none)\n *\n * @since 2.5.0\n */\nvar tail = function (as) {\n    return (0, exports.isNonEmpty)(as) ? _.some(RNEA.tail(as)) : _.none;\n};\nexports.tail = tail;\n/**\n * Get all but the last element of an array, creating a new array, or `None` if the array is empty\n *\n * @example\n * import { init } from 'fp-ts/ReadonlyArray'\n * import { some, none } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(init([1, 2, 3]), some([1, 2]))\n * assert.deepStrictEqual(init([]), none)\n *\n * @since 2.5.0\n */\nvar init = function (as) {\n    return (0, exports.isNonEmpty)(as) ? _.some(RNEA.init(as)) : _.none;\n};\nexports.init = init;\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 */\nvar takeLeft = function (n) {\n    return function (as) {\n        return (0, exports.isOutOfBound)(n, as) ? as : n === 0 ? exports.empty : as.slice(0, n);\n    };\n};\nexports.takeLeft = takeLeft;\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 */\nvar takeRight = function (n) {\n    return function (as) {\n        return (0, exports.isOutOfBound)(n, as) ? as : n === 0 ? exports.empty : 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        var len = out.length;\n        return len === as.length ? as : len === 0 ? exports.empty : 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 * 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 */\nvar dropLeft = function (n) {\n    return function (as) {\n        return n <= 0 || (0, exports.isEmpty)(as) ? as : n >= as.length ? exports.empty : as.slice(n, as.length);\n    };\n};\nexports.dropLeft = dropLeft;\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 */\nvar dropRight = function (n) {\n    return function (as) {\n        return n <= 0 || (0, exports.isEmpty)(as) ? as : n >= as.length ? exports.empty : as.slice(0, as.length - n);\n    };\n};\nexports.dropRight = dropRight;\nfunction dropLeftWhile(predicate) {\n    return function (as) {\n        var i = spanLeftIndex(as, predicate);\n        return i === 0 ? as : i === as.length ? exports.empty : as.slice(i);\n    };\n}\nexports.dropLeftWhile = dropLeftWhile;\n/**\n * Find the first index for which a predicate holds\n *\n * @example\n * import { findIndex } from 'fp-ts/ReadonlyArray'\n * import { some, none } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(findIndex((n: number) => n === 2)([1, 2, 3]), some(1))\n * assert.deepStrictEqual(findIndex((n: number) => n === 2)([]), none)\n *\n * @since 2.5.0\n */\nvar 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};\nexports.findIndex = findIndex;\nfunction 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}\nexports.findFirst = findFirst;\n/**\n * Find the first element returned by an option based selector function\n *\n * @example\n * import { findFirstMap } from 'fp-ts/ReadonlyArray'\n * import { some, none } from 'fp-ts/Option'\n *\n * interface Person {\n *   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 */\nvar 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};\nexports.findFirstMap = findFirstMap;\nfunction 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}\nexports.findLast = findLast;\n/**\n * Find the last element returned by an option based selector function\n *\n * @example\n * import { findLastMap } from 'fp-ts/ReadonlyArray'\n * import { some, none } from 'fp-ts/Option'\n *\n * interface Person {\n *   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 */\nvar 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};\nexports.findLastMap = findLastMap;\n/**\n * Returns the index of the last element of the list which matches the predicate\n *\n * @example\n * import { findLastIndex } from 'fp-ts/ReadonlyArray'\n * import { some, none } from 'fp-ts/Option'\n *\n * interface X {\n *   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 */\nvar 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};\nexports.findLastIndex = findLastIndex;\n/**\n * Insert an element at the specified index, creating a new array, or returning `None` if the index is out of bounds\n *\n * @example\n * import { insertAt } from 'fp-ts/ReadonlyArray'\n * import { some } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(insertAt(2, 5)([1, 2, 3, 4]), some([1, 2, 5, 3, 4]))\n *\n * @since 2.5.0\n */\nvar insertAt = function (i, a) {\n    return function (as) {\n        return i < 0 || i > as.length ? _.none : _.some(RNEA.unsafeInsertAt(i, a, as));\n    };\n};\nexports.insertAt = insertAt;\n/**\n * Change the element at the specified index, creating a new array, or returning `None` if the index is out of bounds\n *\n * @example\n * import { updateAt } from 'fp-ts/ReadonlyArray'\n * import { some, none } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(updateAt(1, 1)([1, 2, 3]), some([1, 1, 3]))\n * assert.deepStrictEqual(updateAt(1, 1)([]), none)\n *\n * @since 2.5.0\n */\nvar updateAt = function (i, a) {\n    return (0, exports.modifyAt)(i, function () { return a; });\n};\nexports.updateAt = updateAt;\n/**\n * Delete the element at the specified index, creating a new array, or returning `None` if the index is out of bounds\n *\n * @example\n * import { deleteAt } from 'fp-ts/ReadonlyArray'\n * import { some, none } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(deleteAt(0)([1, 2, 3]), some([2, 3]))\n * assert.deepStrictEqual(deleteAt(1)([]), none)\n *\n * @since 2.5.0\n */\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/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 */\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/ReadonlyArray'\n *\n * assert.deepStrictEqual(reverse([1, 2, 3]), [3, 2, 1])\n *\n * @since 2.5.0\n */\nvar reverse = function (as) { return (as.length <= 1 ? as : as.slice().reverse()); };\nexports.reverse = reverse;\n/**\n * Extracts from an array of `Either` all the `Right` elements. All the `Right` elements are extracted in order\n *\n * @example\n * import { rights } from 'fp-ts/ReadonlyArray'\n * import { right, left } from 'fp-ts/Either'\n *\n * assert.deepStrictEqual(rights([right(1), left('foo'), right(2)]), [1, 2])\n *\n * @since 2.5.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 * 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 */\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/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 */\nvar sort = function (O) {\n    return function (as) {\n        return as.length <= 1 ? as : as.slice().sort(O.compare);\n    };\n};\nexports.sort = sort;\n// TODO: curry and make data-last in v3\n/**\n * Apply a function to pairs of elements at the same index in two arrays, collecting the results in a new array. If one\n * input array is short, excess elements of the longer array are discarded.\n *\n * @example\n * import { zipWith } from 'fp-ts/ReadonlyArray'\n *\n * assert.deepStrictEqual(zipWith([1, 2, 3], ['a', 'b', 'c', 'd'], (n, s) => s + n), ['a1', 'b2', 'c3'])\n *\n * @since 2.5.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/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 */\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 * 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 */\nvar prependAll = function (middle) {\n    var f = RNEA.prependAll(middle);\n    return function (as) { return ((0, exports.isNonEmpty)(as) ? f(as) : as); };\n};\nexports.prependAll = prependAll;\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 */\nvar intersperse = function (middle) {\n    var f = RNEA.intersperse(middle);\n    return function (as) { return ((0, exports.isNonEmpty)(as) ? f(as) : as); };\n};\nexports.intersperse = intersperse;\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 */\nvar rotate = function (n) {\n    var f = RNEA.rotate(n);\n    return function (as) { return ((0, exports.isNonEmpty)(as) ? f(as) : as); };\n};\nexports.rotate = rotate;\nfunction elem(E) {\n    return function (a, as) {\n        if (as === undefined) {\n            var elemE_1 = elem(E);\n            return function (as) { return elemE_1(a, as); };\n        }\n        var predicate = function (element) { return E.equals(element, a); };\n        var i = 0;\n        for (; i < as.length; i++) {\n            if (predicate(as[i])) {\n                return true;\n            }\n        }\n        return false;\n    };\n}\nexports.elem = elem;\n/**\n * Remove duplicates from an array, keeping the first occurrence of an element.\n *\n * @example\n * import { uniq } from 'fp-ts/ReadonlyArray'\n * import * 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 */\nvar uniq = function (E) {\n    var f = RNEA.uniq(E);\n    return function (as) { return ((0, exports.isNonEmpty)(as) ? f(as) : 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/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 */\nvar sortBy = function (ords) {\n    var f = RNEA.sortBy(ords);\n    return function (as) { return ((0, exports.isNonEmpty)(as) ? f(as) : as); };\n};\nexports.sortBy = sortBy;\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 */\nvar chop = function (f) {\n    var g = RNEA.chop(f);\n    return function (as) { return ((0, exports.isNonEmpty)(as) ? g(as) : exports.empty); };\n};\nexports.chop = chop;\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 */\nvar splitAt = function (n) {\n    return function (as) {\n        return n >= 1 && (0, exports.isNonEmpty)(as) ? RNEA.splitAt(n)(as) : (0, exports.isEmpty)(as) ? [as, exports.empty] : [exports.empty, as];\n    };\n};\nexports.splitAt = splitAt;\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 */\nvar chunksOf = function (n) {\n    var f = RNEA.chunksOf(n);\n    return function (as) { return ((0, exports.isNonEmpty)(as) ? f(as) : exports.empty); };\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)(RNEA.head(input), function (a) { return go((0, function_1.pipe)(scope, (0, exports.append)(a)), RNEA.tail(input)); })\n            : g.apply(void 0, scope) ? [f.apply(void 0, scope)]\n                : exports.empty;\n    };\n    return go(exports.empty, 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) ? second : (0, exports.isEmpty)(second) ? 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 = 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 (0, exports.isNonEmpty)(first) && (0, exports.isNonEmpty)(second) ? unionE(second)(first) : (0, exports.isNonEmpty)(first) ? first : second;\n    };\n}\nexports.union = union;\nfunction intersection(E) {\n    var elemE = elem(E);\n    return function (xs, ys) {\n        if (ys === undefined) {\n            var intersectionE_1 = intersection(E);\n            return function (ys) { return intersectionE_1(ys, xs); };\n        }\n        return xs.filter(function (a) { return elemE(a, ys); });\n    };\n}\nexports.intersection = intersection;\nfunction difference(E) {\n    var elemE = elem(E);\n    return function (xs, ys) {\n        if (ys === undefined) {\n            var differenceE_1 = difference(E);\n            return function (ys) { return differenceE_1(ys, xs); };\n        }\n        return xs.filter(function (a) { return !elemE(a, ys); });\n    };\n}\nexports.difference = difference;\nvar _map = function (fa, f) { return (0, function_1.pipe)(fa, (0, exports.map)(f)); };\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)); };\nvar _filter = function (fa, predicate) {\n    return (0, function_1.pipe)(fa, (0, exports.filter)(predicate));\n};\nvar _filterMap = function (fa, f) { return (0, function_1.pipe)(fa, (0, exports.filterMap)(f)); };\nvar _partition = function (fa, predicate) {\n    return (0, function_1.pipe)(fa, (0, exports.partition)(predicate));\n};\nvar _partitionMap = function (fa, f) { return (0, function_1.pipe)(fa, (0, exports.partitionMap)(f)); };\nvar _partitionWithIndex = function (fa, predicateWithIndex) { return (0, function_1.pipe)(fa, (0, exports.partitionWithIndex)(predicateWithIndex)); };\nvar _partitionMapWithIndex = function (fa, f) { return (0, function_1.pipe)(fa, (0, exports.partitionMapWithIndex)(f)); };\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)); };\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};\nvar _reduceRight = function (fa, b, f) { return (0, function_1.pipe)(fa, (0, exports.reduceRight)(b, f)); };\nvar _reduceWithIndex = function (fa, b, f) {\n    return (0, function_1.pipe)(fa, (0, exports.reduceWithIndex)(b, f));\n};\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};\nvar _reduceRightWithIndex = function (fa, b, f) {\n    return (0, function_1.pipe)(fa, (0, exports.reduceRightWithIndex)(b, f));\n};\nvar _filterMapWithIndex = function (fa, f) { return (0, function_1.pipe)(fa, (0, exports.filterMapWithIndex)(f)); };\nvar _filterWithIndex = function (fa, predicateWithIndex) { return (0, function_1.pipe)(fa, (0, exports.filterWithIndex)(predicateWithIndex)); };\nvar _extend = function (fa, f) { return (0, function_1.pipe)(fa, (0, exports.extend)(f)); };\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};\n/** @internal */\nvar _chainRecDepthFirst = function (a, f) { return (0, function_1.pipe)(a, (0, exports.chainRecDepthFirst)(f)); };\nexports._chainRecDepthFirst = _chainRecDepthFirst;\n/** @internal */\nvar _chainRecBreadthFirst = function (a, f) { return (0, function_1.pipe)(a, (0, exports.chainRecBreadthFirst)(f)); };\nexports._chainRecBreadthFirst = _chainRecBreadthFirst;\n/**\n * @category constructors\n * @since 2.5.0\n */\nexports.of = RNEA.of;\n/**\n * @since 2.7.0\n */\nvar zero = function () { return exports.empty; };\nexports.zero = zero;\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 */\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 `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 */\nexports.alt = exports.altW;\n/**\n * @since 2.5.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 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 */\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 * @category sequencing\n * @since 2.5.0\n */\nexports.flatten = (0, exports.flatMap)(function_1.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 */\nvar map = function (f) { return function (fa) {\n    return fa.map(function (a) { return f(a); });\n}; };\nexports.map = map;\n/**\n * @category mapping\n * @since 2.5.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 * @category filtering\n * @since 2.5.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 * @category filtering\n * @since 2.5.0\n */\nvar filter = function (predicate) {\n    return function (as) {\n        return as.filter(predicate);\n    };\n};\nexports.filter = filter;\n/**\n * @category filtering\n * @since 2.5.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 * @category filtering\n * @since 2.5.0\n */\nvar filterMap = function (f) {\n    return (0, exports.filterMapWithIndex)(function (_, a) { return f(a); });\n};\nexports.filterMap = filterMap;\n/**\n * @category filtering\n * @since 2.5.0\n */\nexports.compact = (0, exports.filterMap)(function_1.identity);\n/**\n * @category filtering\n * @since 2.5.0\n */\nvar partition = function (predicate) {\n    return (0, exports.partitionWithIndex)(function (_, a) { return predicate(a); });\n};\nexports.partition = partition;\n/**\n * @category filtering\n * @since 2.5.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 a = as[i];\n            if (predicateWithIndex(i, a)) {\n                right.push(a);\n            }\n            else {\n                left.push(a);\n            }\n        }\n        return (0, Separated_1.separated)(left, right);\n    };\n};\nexports.partitionWithIndex = partitionWithIndex;\n/**\n * @category filtering\n * @since 2.5.0\n */\nvar partitionMap = function (f) {\n    return (0, exports.partitionMapWithIndex)(function (_, a) { return f(a); });\n};\nexports.partitionMap = partitionMap;\n/**\n * @category filtering\n * @since 2.5.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 * @category filtering\n * @since 2.5.0\n */\nvar filterWithIndex = function (predicateWithIndex) {\n    return function (as) {\n        return as.filter(function (a, i) { return predicateWithIndex(i, a); });\n    };\n};\nexports.filterWithIndex = filterWithIndex;\n/**\n * @since 2.5.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 * @since 2.5.0\n */\nexports.duplicate = (0, exports.extend)(function_1.identity);\n/**\n * @category folding\n * @since 2.5.0\n */\nvar 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};\nexports.foldMapWithIndex = foldMapWithIndex;\n/**\n * @category folding\n * @since 2.5.0\n */\nvar reduce = function (b, f) {\n    return (0, exports.reduceWithIndex)(b, function (_, b, a) { return f(b, a); });\n};\nexports.reduce = reduce;\n/**\n * @category folding\n * @since 2.5.0\n */\nvar foldMap = function (M) {\n    var foldMapWithIndexM = (0, exports.foldMapWithIndex)(M);\n    return function (f) { return foldMapWithIndexM(function (_, a) { return f(a); }); };\n};\nexports.foldMap = foldMap;\n/**\n * @category folding\n * @since 2.5.0\n */\nvar 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}; };\nexports.reduceWithIndex = reduceWithIndex;\n/**\n * @category folding\n * @since 2.5.0\n */\nvar reduceRight = function (b, f) {\n    return (0, exports.reduceRightWithIndex)(b, function (_, a, b) { return f(a, b); });\n};\nexports.reduceRight = reduceRight;\n/**\n * @category folding\n * @since 2.5.0\n */\nvar reduceRightWithIndex = function (b, f) { return function (fa) {\n    return fa.reduceRight(function (b, a, i) { return f(i, a, b); }, b);\n}; };\nexports.reduceRightWithIndex = reduceRightWithIndex;\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 * @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 * @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 * @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.5.0\n */\nexports.URI = 'ReadonlyArray';\n/**\n * @category instances\n * @since 2.5.0\n */\nvar getShow = function (S) { return ({\n    show: function (as) { return \"[\".concat(as.map(S.show).join(', '), \"]\"); }\n}); };\nexports.getShow = getShow;\n/**\n * @category instances\n * @since 2.5.0\n */\nvar getSemigroup = function () { return ({\n    concat: function (first, second) { return ((0, exports.isEmpty)(first) ? second : (0, exports.isEmpty)(second) ? first : first.concat(second)); }\n}); };\nexports.getSemigroup = getSemigroup;\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 */\nvar getMonoid = function () { return ({\n    concat: (0, exports.getSemigroup)().concat,\n    empty: exports.empty\n}); };\nexports.getMonoid = getMonoid;\n/**\n * Derives an `Eq` over the `ReadonlyArray` of a given element type from the `Eq` of that type. The derived `Eq` defines two\n * arrays as equal if all elements of both arrays are compared equal pairwise with the given `E`. In case of arrays of\n * different lengths, the result is non equality.\n *\n * @example\n * import * 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 */\nvar getEq = function (E) {\n    return (0, Eq_1.fromEquals)(function (xs, ys) { return xs.length === ys.length && xs.every(function (x, i) { return E.equals(x, ys[i]); }); });\n};\nexports.getEq = getEq;\n/**\n * Derives an `Ord` over the `ReadonlyArray` of a given element type from the `Ord` of that type. The ordering between two such\n * arrays is equal to: the first non equal comparison of each arrays elements taken pairwise in increasing order, in\n * case of equality over all the pairwise elements; the longest array is considered the greatest, if both arrays have\n * the same length, the result is equality.\n *\n * @example\n * import { getOrd } from 'fp-ts/ReadonlyArray'\n * import * 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 */\nvar getOrd = function (O) {\n    return (0, Ord_1.fromCompare)(function (a, b) {\n        var aLen = a.length;\n        var bLen = b.length;\n        var len = Math.min(aLen, bLen);\n        for (var i = 0; i < len; i++) {\n            var ordering = O.compare(a[i], b[i]);\n            if (ordering !== 0) {\n                return ordering;\n            }\n        }\n        return N.Ord.compare(aLen, bLen);\n    });\n};\nexports.getOrd = getOrd;\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 * @category instances\n * @since 2.11.0\n */\nvar getUnionMonoid = function (E) { return ({\n    concat: (0, exports.getUnionSemigroup)(E).concat,\n    empty: exports.empty\n}); };\nexports.getUnionMonoid = getUnionMonoid;\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 * @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 * @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 * @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 * 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 */\nexports.chainFirst = \n/*#__PURE__*/ (0, Chain_1.chainFirst)(exports.Chain);\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};\n/**\n * @category sequencing\n * @since 2.11.0\n */\nvar 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};\nexports.chainRecDepthFirst = 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: exports._chainRecDepthFirst\n};\n/**\n * @category sequencing\n * @since 2.11.0\n */\nvar 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};\nexports.chainRecBreadthFirst = 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: exports._chainRecBreadthFirst\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 * 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 */\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.5.0\n */\nexports.unsafeInsertAt = RNEA.unsafeInsertAt;\n/**\n * @category unsafe\n * @since 2.5.0\n */\nvar unsafeUpdateAt = function (i, a, as) {\n    return (0, exports.isNonEmpty)(as) ? RNEA.unsafeUpdateAt(i, a, as) : as;\n};\nexports.unsafeUpdateAt = unsafeUpdateAt;\n/**\n * @category unsafe\n * @since 2.5.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 * @category conversions\n * @since 2.5.0\n */\nvar toArray = function (as) { return as.slice(); };\nexports.toArray = toArray;\n/**\n * @category conversions\n * @since 2.5.0\n */\nvar fromArray = function (as) { return ((0, exports.isEmpty)(as) ? exports.empty : as.slice()); };\nexports.fromArray = fromArray;\n// -------------------------------------------------------------------------------------\n// utils\n// -------------------------------------------------------------------------------------\n/**\n * An empty array\n *\n * @since 2.5.0\n */\nexports.empty = RNEA.empty;\nfunction every(predicate) {\n    return function (as) { return as.every(predicate); };\n}\nexports.every = every;\n/**\n * Check if a predicate holds true for any array member.\n *\n * @example\n * import { some } from 'fp-ts/ReadonlyArray'\n * import { pipe } from 'fp-ts/function'\n *\n * const isPositive = (n: number): boolean => n > 0\n *\n * assert.deepStrictEqual(pipe([-1, -2, 3], some(isPositive)), true)\n * assert.deepStrictEqual(pipe([-1, -2, -3], some(isPositive)), false)\n *\n * @since 2.9.0\n */\nvar some = function (predicate) {\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 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 */\nvar intercalate = function (M) {\n    var intercalateM = RNEA.intercalate(M);\n    return function (middle) { return (0, exports.match)(function () { return M.empty; }, intercalateM(middle)); };\n};\nexports.intercalate = 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.5.0\n */\nexports.chain = exports.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 */\nexports.range = RNEA.range;\n/**\n * Use [`prepend`](#prepend) instead.\n *\n * @category zone of death\n * @since 2.5.0\n * @deprecated\n */\nexports.cons = RNEA.cons;\n/**\n * Use [`append`](#append) instead.\n *\n * @category zone of death\n * @since 2.5.0\n * @deprecated\n */\nexports.snoc = RNEA.snoc;\n/**\n * Use [`prependAll`](#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 `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 */\nexports.readonlyArray = {\n    URI: exports.URI,\n    compact: exports.compact,\n    separate: exports.separate,\n    map: _map,\n    ap: _ap,\n    of: exports.of,\n    chain: 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","require$$0","require$$1","require$$2","require$$3","require$$4","require$$5","require$$6","require$$7","require$$8","require$$9","require$$10","require$$11","require$$12","as","init","bs","input","second","ys","_","b","e"],"mappings":"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","x_google_ignoreList":[0]}