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

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

package/dist/_node_modules/fp-ts/es6/Bifunctor.cjs

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=Bifunctor.cjs.map

package/dist/_node_modules/fp-ts/es6/Bifunctor.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Bifunctor.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/_node_modules/fp-ts/es6/Bifunctor.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=Bifunctor.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Bifunctor.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/_node_modules/fp-ts/es6/BooleanAlgebra.cjs

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const _function = require("./function.cjs");
+var reverse = function(B) {
+  return {
+    meet: function(x, y) {
+      return B.join(x, y);
+    },
+    join: function(x, y) {
+      return B.meet(x, y);
+    },
+    zero: B.one,
+    one: B.zero,
+    implies: function(x, y) {
+      return B.join(B.not(x), y);
+    },
+    not: B.not
+  };
+};
+var booleanAlgebraVoid = {
+  meet: function() {
+    return void 0;
+  },
+  join: function() {
+    return void 0;
+  },
+  zero: void 0,
+  one: void 0,
+  implies: function() {
+    return void 0;
+  },
+  not: function() {
+    return void 0;
+  }
+};
+var getDualBooleanAlgebra = reverse;
+var booleanAlgebraBoolean = {
+  meet: function(x, y) {
+    return x && y;
+  },
+  join: function(x, y) {
+    return x || y;
+  },
+  zero: false,
+  one: true,
+  implies: function(x, y) {
+    return !x || y;
+  },
+  not: function(x) {
+    return !x;
+  }
+};
+var getFunctionBooleanAlgebra = _function.getBooleanAlgebra;
+exports.booleanAlgebraBoolean = booleanAlgebraBoolean;
+exports.booleanAlgebraVoid = booleanAlgebraVoid;
+exports.getDualBooleanAlgebra = getDualBooleanAlgebra;
+exports.getFunctionBooleanAlgebra = getFunctionBooleanAlgebra;
+exports.reverse = reverse;
+//# sourceMappingURL=BooleanAlgebra.cjs.map

package/dist/_node_modules/fp-ts/es6/BooleanAlgebra.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"BooleanAlgebra.cjs","sources":["../../../../../../node_modules/fp-ts/es6/BooleanAlgebra.js"],"sourcesContent":["/**\n * Boolean algebras are Heyting algebras with the additional constraint that the law of the excluded middle is true\n * (equivalently, double-negation is true).\n *\n * Instances should satisfy the following laws in addition to the `HeytingAlgebra` laws:\n *\n * - Excluded middle: `a ∨ ¬a <-> 1`\n *\n * Boolean algebras generalize classical logic: one is equivalent to \"true\" and zero is equivalent to \"false\".\n *\n * @since 2.0.0\n */\nimport { getBooleanAlgebra } from './function';\n// -------------------------------------------------------------------------------------\n// combinators\n// -------------------------------------------------------------------------------------\n/**\n * Every boolean algebras has a dual algebra, which involves reversing one/zero as well as join/meet.\n *\n * @since 2.10.0\n */\nexport var reverse = function (B) { return ({\n    meet: function (x, y) { return B.join(x, y); },\n    join: function (x, y) { return B.meet(x, y); },\n    zero: B.one,\n    one: B.zero,\n    implies: function (x, y) { return B.join(B.not(x), y); },\n    not: B.not\n}); };\n// -------------------------------------------------------------------------------------\n// instances\n// -------------------------------------------------------------------------------------\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var booleanAlgebraVoid = {\n    meet: function () { return undefined; },\n    join: function () { return undefined; },\n    zero: undefined,\n    one: undefined,\n    implies: function () { return undefined; },\n    not: function () { return undefined; }\n};\n// -------------------------------------------------------------------------------------\n// deprecated\n// -------------------------------------------------------------------------------------\n/**\n * Use [`reverse`](#reverse) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getDualBooleanAlgebra = reverse;\n/**\n * Use [`BooleanAlgebra`](./boolean.ts.html#booleanalgebra) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var booleanAlgebraBoolean = {\n    meet: function (x, y) { return x && y; },\n    join: function (x, y) { return x || y; },\n    zero: false,\n    one: true,\n    implies: function (x, y) { return !x || y; },\n    not: function (x) { return !x; }\n};\n/**\n * Use [`getBooleanAlgebra`](./function.ts.html#getbooleanalgebra) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getFunctionBooleanAlgebra = getBooleanAlgebra;\n"],"names":["getBooleanAlgebra"],"mappings":";;;AAqBU,IAAC,UAAU,SAAU,GAAG;AAAE,SAAQ;AAAA,IACxC,MAAM,SAAU,GAAG,GAAG;AAAE,aAAO,EAAE,KAAK,GAAG,CAAC;AAAA,IAAI;AAAA,IAC9C,MAAM,SAAU,GAAG,GAAG;AAAE,aAAO,EAAE,KAAK,GAAG,CAAC;AAAA,IAAI;AAAA,IAC9C,MAAM,EAAE;AAAA,IACR,KAAK,EAAE;AAAA,IACP,SAAS,SAAU,GAAG,GAAG;AAAE,aAAO,EAAE,KAAK,EAAE,IAAI,CAAC,GAAG,CAAC;AAAA,IAAI;AAAA,IACxD,KAAK,EAAE;AAAA,EACX;AAAM;AAQI,IAAC,qBAAqB;AAAA,EAC5B,MAAM,WAAY;AAAE,WAAO;AAAA,EAAY;AAAA,EACvC,MAAM,WAAY;AAAE,WAAO;AAAA,EAAY;AAAA,EACvC,MAAM;AAAA,EACN,KAAK;AAAA,EACL,SAAS,WAAY;AAAE,WAAO;AAAA,EAAY;AAAA,EAC1C,KAAK,WAAY;AAAE,WAAO;AAAA,EAAY;AAC1C;AAWU,IAAC,wBAAwB;AAQzB,IAAC,wBAAwB;AAAA,EAC/B,MAAM,SAAU,GAAG,GAAG;AAAE,WAAO,KAAK;AAAA,EAAI;AAAA,EACxC,MAAM,SAAU,GAAG,GAAG;AAAE,WAAO,KAAK;AAAA,EAAI;AAAA,EACxC,MAAM;AAAA,EACN,KAAK;AAAA,EACL,SAAS,SAAU,GAAG,GAAG;AAAE,WAAO,CAAC,KAAK;AAAA,EAAI;AAAA,EAC5C,KAAK,SAAU,GAAG;AAAE,WAAO,CAAC;AAAA,EAAI;AACpC;AAQU,IAAC,4BAA4BA,UAAAA;;;;;;","x_google_ignoreList":[0]}

package/dist/_node_modules/fp-ts/es6/BooleanAlgebra.js

@@ -0,0 +1,59 @@
+import { getBooleanAlgebra } from "./function.js";
+var reverse = function(B) {
+  return {
+    meet: function(x, y) {
+      return B.join(x, y);
+    },
+    join: function(x, y) {
+      return B.meet(x, y);
+    },
+    zero: B.one,
+    one: B.zero,
+    implies: function(x, y) {
+      return B.join(B.not(x), y);
+    },
+    not: B.not
+  };
+};
+var booleanAlgebraVoid = {
+  meet: function() {
+    return void 0;
+  },
+  join: function() {
+    return void 0;
+  },
+  zero: void 0,
+  one: void 0,
+  implies: function() {
+    return void 0;
+  },
+  not: function() {
+    return void 0;
+  }
+};
+var getDualBooleanAlgebra = reverse;
+var booleanAlgebraBoolean = {
+  meet: function(x, y) {
+    return x && y;
+  },
+  join: function(x, y) {
+    return x || y;
+  },
+  zero: false,
+  one: true,
+  implies: function(x, y) {
+    return !x || y;
+  },
+  not: function(x) {
+    return !x;
+  }
+};
+var getFunctionBooleanAlgebra = getBooleanAlgebra;
+export {
+  booleanAlgebraBoolean,
+  booleanAlgebraVoid,
+  getDualBooleanAlgebra,
+  getFunctionBooleanAlgebra,
+  reverse
+};
+//# sourceMappingURL=BooleanAlgebra.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BooleanAlgebra.js","sources":["../../../../../../node_modules/fp-ts/es6/BooleanAlgebra.js"],"sourcesContent":["/**\n * Boolean algebras are Heyting algebras with the additional constraint that the law of the excluded middle is true\n * (equivalently, double-negation is true).\n *\n * Instances should satisfy the following laws in addition to the `HeytingAlgebra` laws:\n *\n * - Excluded middle: `a ∨ ¬a <-> 1`\n *\n * Boolean algebras generalize classical logic: one is equivalent to \"true\" and zero is equivalent to \"false\".\n *\n * @since 2.0.0\n */\nimport { getBooleanAlgebra } from './function';\n// -------------------------------------------------------------------------------------\n// combinators\n// -------------------------------------------------------------------------------------\n/**\n * Every boolean algebras has a dual algebra, which involves reversing one/zero as well as join/meet.\n *\n * @since 2.10.0\n */\nexport var reverse = function (B) { return ({\n    meet: function (x, y) { return B.join(x, y); },\n    join: function (x, y) { return B.meet(x, y); },\n    zero: B.one,\n    one: B.zero,\n    implies: function (x, y) { return B.join(B.not(x), y); },\n    not: B.not\n}); };\n// -------------------------------------------------------------------------------------\n// instances\n// -------------------------------------------------------------------------------------\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var booleanAlgebraVoid = {\n    meet: function () { return undefined; },\n    join: function () { return undefined; },\n    zero: undefined,\n    one: undefined,\n    implies: function () { return undefined; },\n    not: function () { return undefined; }\n};\n// -------------------------------------------------------------------------------------\n// deprecated\n// -------------------------------------------------------------------------------------\n/**\n * Use [`reverse`](#reverse) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getDualBooleanAlgebra = reverse;\n/**\n * Use [`BooleanAlgebra`](./boolean.ts.html#booleanalgebra) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var booleanAlgebraBoolean = {\n    meet: function (x, y) { return x && y; },\n    join: function (x, y) { return x || y; },\n    zero: false,\n    one: true,\n    implies: function (x, y) { return !x || y; },\n    not: function (x) { return !x; }\n};\n/**\n * Use [`getBooleanAlgebra`](./function.ts.html#getbooleanalgebra) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getFunctionBooleanAlgebra = getBooleanAlgebra;\n"],"names":[],"mappings":";AAqBU,IAAC,UAAU,SAAU,GAAG;AAAE,SAAQ;AAAA,IACxC,MAAM,SAAU,GAAG,GAAG;AAAE,aAAO,EAAE,KAAK,GAAG,CAAC;AAAA,IAAI;AAAA,IAC9C,MAAM,SAAU,GAAG,GAAG;AAAE,aAAO,EAAE,KAAK,GAAG,CAAC;AAAA,IAAI;AAAA,IAC9C,MAAM,EAAE;AAAA,IACR,KAAK,EAAE;AAAA,IACP,SAAS,SAAU,GAAG,GAAG;AAAE,aAAO,EAAE,KAAK,EAAE,IAAI,CAAC,GAAG,CAAC;AAAA,IAAI;AAAA,IACxD,KAAK,EAAE;AAAA,EACX;AAAM;AAQI,IAAC,qBAAqB;AAAA,EAC5B,MAAM,WAAY;AAAE,WAAO;AAAA,EAAY;AAAA,EACvC,MAAM,WAAY;AAAE,WAAO;AAAA,EAAY;AAAA,EACvC,MAAM;AAAA,EACN,KAAK;AAAA,EACL,SAAS,WAAY;AAAE,WAAO;AAAA,EAAY;AAAA,EAC1C,KAAK,WAAY;AAAE,WAAO;AAAA,EAAY;AAC1C;AAWU,IAAC,wBAAwB;AAQzB,IAAC,wBAAwB;AAAA,EAC/B,MAAM,SAAU,GAAG,GAAG;AAAE,WAAO,KAAK;AAAA,EAAI;AAAA,EACxC,MAAM,SAAU,GAAG,GAAG;AAAE,WAAO,KAAK;AAAA,EAAI;AAAA,EACxC,MAAM;AAAA,EACN,KAAK;AAAA,EACL,SAAS,SAAU,GAAG,GAAG;AAAE,WAAO,CAAC,KAAK;AAAA,EAAI;AAAA,EAC5C,KAAK,SAAU,GAAG;AAAE,WAAO,CAAC;AAAA,EAAI;AACpC;AAQU,IAAC,4BAA4B;","x_google_ignoreList":[0]}

package/dist/_node_modules/fp-ts/es6/Bounded.cjs

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Ord = require("./Ord.cjs");
+var clamp = function(B) {
+  return Ord.clamp(B)(B.bottom, B.top);
+};
+var reverse = function(B) {
+  var R = Ord.reverse(B);
+  return {
+    equals: R.equals,
+    compare: R.compare,
+    top: B.bottom,
+    bottom: B.top
+  };
+};
+var boundedNumber = {
+  equals: Ord.ordNumber.equals,
+  compare: Ord.ordNumber.compare,
+  top: Infinity,
+  bottom: -Infinity
+};
+exports.boundedNumber = boundedNumber;
+exports.clamp = clamp;
+exports.reverse = reverse;
+//# sourceMappingURL=Bounded.cjs.map

package/dist/_node_modules/fp-ts/es6/Bounded.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Bounded.cjs","sources":["../../../../../../node_modules/fp-ts/es6/Bounded.js"],"sourcesContent":["/**\n * The `Bounded` type class represents totally ordered types that have an upper and lower boundary.\n *\n * Instances should satisfy the following law in addition to the `Ord` laws:\n *\n * - Bounded: `bottom <= a <= top`\n *\n * @since 2.0.0\n */\nimport * as O from './Ord';\n// -------------------------------------------------------------------------------------\n// utils\n// -------------------------------------------------------------------------------------\n/**\n * Clamp a value between bottom and top values.\n *\n * @category utils\n * @since 2.12.0\n */\nexport var clamp = function (B) { return O.clamp(B)(B.bottom, B.top); };\n/**\n * Reverses the Ord of a bound and swaps top and bottom values.\n *\n * @category utils\n * @since 2.12.0\n */\nexport var reverse = function (B) {\n    var R = O.reverse(B);\n    return {\n        equals: R.equals,\n        compare: R.compare,\n        top: B.bottom,\n        bottom: B.top\n    };\n};\n// -------------------------------------------------------------------------------------\n// deprecated\n// -------------------------------------------------------------------------------------\n/**\n * Use [`Bounded`](./number.ts.html#bounded) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var boundedNumber = {\n    equals: O.ordNumber.equals,\n    compare: O.ordNumber.compare,\n    top: Infinity,\n    bottom: -Infinity\n};\n"],"names":["O.clamp","O.reverse","O.ordNumber"],"mappings":";;;AAmBU,IAAC,QAAQ,SAAU,GAAG;AAAE,SAAOA,UAAQ,CAAC,EAAE,EAAE,QAAQ,EAAE,GAAG;AAAK;AAO9D,IAAC,UAAU,SAAU,GAAG;AAC9B,MAAI,IAAIC,YAAU,CAAC;AACnB,SAAO;AAAA,IACH,QAAQ,EAAE;AAAA,IACV,SAAS,EAAE;AAAA,IACX,KAAK,EAAE;AAAA,IACP,QAAQ,EAAE;AAAA,EAClB;AACA;AAWU,IAAC,gBAAgB;AAAA,EACvB,QAAQC,IAAW,UAAC;AAAA,EACpB,SAASA,IAAW,UAAC;AAAA,EACrB,KAAK;AAAA,EACL,QAAQ;AACZ;;;;","x_google_ignoreList":[0]}

package/dist/_node_modules/fp-ts/es6/Bounded.js

@@ -0,0 +1,25 @@
+import { clamp as clamp$1, reverse as reverse$1, ordNumber } from "./Ord.js";
+var clamp = function(B) {
+  return clamp$1(B)(B.bottom, B.top);
+};
+var reverse = function(B) {
+  var R = reverse$1(B);
+  return {
+    equals: R.equals,
+    compare: R.compare,
+    top: B.bottom,
+    bottom: B.top
+  };
+};
+var boundedNumber = {
+  equals: ordNumber.equals,
+  compare: ordNumber.compare,
+  top: Infinity,
+  bottom: -Infinity
+};
+export {
+  boundedNumber,
+  clamp,
+  reverse
+};
+//# sourceMappingURL=Bounded.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Bounded.js","sources":["../../../../../../node_modules/fp-ts/es6/Bounded.js"],"sourcesContent":["/**\n * The `Bounded` type class represents totally ordered types that have an upper and lower boundary.\n *\n * Instances should satisfy the following law in addition to the `Ord` laws:\n *\n * - Bounded: `bottom <= a <= top`\n *\n * @since 2.0.0\n */\nimport * as O from './Ord';\n// -------------------------------------------------------------------------------------\n// utils\n// -------------------------------------------------------------------------------------\n/**\n * Clamp a value between bottom and top values.\n *\n * @category utils\n * @since 2.12.0\n */\nexport var clamp = function (B) { return O.clamp(B)(B.bottom, B.top); };\n/**\n * Reverses the Ord of a bound and swaps top and bottom values.\n *\n * @category utils\n * @since 2.12.0\n */\nexport var reverse = function (B) {\n    var R = O.reverse(B);\n    return {\n        equals: R.equals,\n        compare: R.compare,\n        top: B.bottom,\n        bottom: B.top\n    };\n};\n// -------------------------------------------------------------------------------------\n// deprecated\n// -------------------------------------------------------------------------------------\n/**\n * Use [`Bounded`](./number.ts.html#bounded) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var boundedNumber = {\n    equals: O.ordNumber.equals,\n    compare: O.ordNumber.compare,\n    top: Infinity,\n    bottom: -Infinity\n};\n"],"names":["O.clamp","O.reverse","O.ordNumber"],"mappings":";AAmBU,IAAC,QAAQ,SAAU,GAAG;AAAE,SAAOA,QAAQ,CAAC,EAAE,EAAE,QAAQ,EAAE,GAAG;AAAK;AAO9D,IAAC,UAAU,SAAU,GAAG;AAC9B,MAAI,IAAIC,UAAU,CAAC;AACnB,SAAO;AAAA,IACH,QAAQ,EAAE;AAAA,IACV,SAAS,EAAE;AAAA,IACX,KAAK,EAAE;AAAA,IACP,QAAQ,EAAE;AAAA,EAClB;AACA;AAWU,IAAC,gBAAgB;AAAA,EACvB,QAAQC,UAAY;AAAA,EACpB,SAASA,UAAY;AAAA,EACrB,KAAK;AAAA,EACL,QAAQ;AACZ;","x_google_ignoreList":[0]}

package/dist/_node_modules/fp-ts/es6/BoundedDistributiveLattice.cjs

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const DistributiveLattice = require("./DistributiveLattice.cjs");
+function getMinMaxBoundedDistributiveLattice(O) {
+  var L = DistributiveLattice.getMinMaxDistributiveLattice(O);
+  return function(min, max) {
+    return {
+      join: L.join,
+      meet: L.meet,
+      zero: min,
+      one: max
+    };
+  };
+}
+exports.getMinMaxBoundedDistributiveLattice = getMinMaxBoundedDistributiveLattice;
+//# sourceMappingURL=BoundedDistributiveLattice.cjs.map

package/dist/_node_modules/fp-ts/es6/BoundedDistributiveLattice.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"BoundedDistributiveLattice.cjs","sources":["../../../../../../node_modules/fp-ts/es6/BoundedDistributiveLattice.js"],"sourcesContent":["import { getMinMaxDistributiveLattice } from './DistributiveLattice';\n// -------------------------------------------------------------------------------------\n// constructors\n// -------------------------------------------------------------------------------------\n/**\n * @category constructors\n * @since 2.0.0\n */\nexport function getMinMaxBoundedDistributiveLattice(O) {\n    var L = getMinMaxDistributiveLattice(O);\n    return function (min, max) { return ({\n        join: L.join,\n        meet: L.meet,\n        zero: min,\n        one: max\n    }); };\n}\n"],"names":["getMinMaxDistributiveLattice"],"mappings":";;;AAQO,SAAS,oCAAoC,GAAG;AACnD,MAAI,IAAIA,iDAA6B,CAAC;AACtC,SAAO,SAAU,KAAK,KAAK;AAAE,WAAQ;AAAA,MACjC,MAAM,EAAE;AAAA,MACR,MAAM,EAAE;AAAA,MACR,MAAM;AAAA,MACN,KAAK;AAAA,IACR;AAAA;AACL;;","x_google_ignoreList":[0]}

package/dist/_node_modules/fp-ts/es6/BoundedDistributiveLattice.js

@@ -0,0 +1,16 @@
+import { getMinMaxDistributiveLattice } from "./DistributiveLattice.js";
+function getMinMaxBoundedDistributiveLattice(O) {
+  var L = getMinMaxDistributiveLattice(O);
+  return function(min, max) {
+    return {
+      join: L.join,
+      meet: L.meet,
+      zero: min,
+      one: max
+    };
+  };
+}
+export {
+  getMinMaxBoundedDistributiveLattice
+};
+//# sourceMappingURL=BoundedDistributiveLattice.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BoundedDistributiveLattice.js","sources":["../../../../../../node_modules/fp-ts/es6/BoundedDistributiveLattice.js"],"sourcesContent":["import { getMinMaxDistributiveLattice } from './DistributiveLattice';\n// -------------------------------------------------------------------------------------\n// constructors\n// -------------------------------------------------------------------------------------\n/**\n * @category constructors\n * @since 2.0.0\n */\nexport function getMinMaxBoundedDistributiveLattice(O) {\n    var L = getMinMaxDistributiveLattice(O);\n    return function (min, max) { return ({\n        join: L.join,\n        meet: L.meet,\n        zero: min,\n        one: max\n    }); };\n}\n"],"names":[],"mappings":";AAQO,SAAS,oCAAoC,GAAG;AACnD,MAAI,IAAI,6BAA6B,CAAC;AACtC,SAAO,SAAU,KAAK,KAAK;AAAE,WAAQ;AAAA,MACjC,MAAM,EAAE;AAAA,MACR,MAAM,EAAE;AAAA,MACR,MAAM;AAAA,MACN,KAAK;AAAA,IACR;AAAA;AACL;","x_google_ignoreList":[0]}

package/dist/_node_modules/fp-ts/es6/BoundedJoinSemilattice.cjs

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=BoundedJoinSemilattice.cjs.map

package/dist/_node_modules/fp-ts/es6/BoundedJoinSemilattice.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"BoundedJoinSemilattice.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/_node_modules/fp-ts/es6/BoundedJoinSemilattice.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=BoundedJoinSemilattice.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BoundedJoinSemilattice.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/_node_modules/fp-ts/es6/BoundedLattice.cjs

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=BoundedLattice.cjs.map

package/dist/_node_modules/fp-ts/es6/BoundedLattice.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"BoundedLattice.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/_node_modules/fp-ts/es6/BoundedLattice.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=BoundedLattice.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BoundedLattice.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/_node_modules/fp-ts/es6/BoundedMeetSemilattice.cjs

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=BoundedMeetSemilattice.cjs.map

package/dist/_node_modules/fp-ts/es6/BoundedMeetSemilattice.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"BoundedMeetSemilattice.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/_node_modules/fp-ts/es6/BoundedMeetSemilattice.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=BoundedMeetSemilattice.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BoundedMeetSemilattice.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/_node_modules/fp-ts/es6/Category.cjs

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=Category.cjs.map

package/dist/_node_modules/fp-ts/es6/Category.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Category.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/_node_modules/fp-ts/es6/Category.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=Category.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Category.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/_node_modules/fp-ts/es6/Chain.cjs

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function chainFirst(M) {
+  var tapM = tap(M);
+  return function(f) {
+    return function(first) {
+      return tapM(first, f);
+    };
+  };
+}
+function tap(M) {
+  return function(first, f) {
+    return M.chain(first, function(a) {
+      return M.map(f(a), function() {
+        return a;
+      });
+    });
+  };
+}
+function bind(M) {
+  return function(name, f) {
+    return function(ma) {
+      return M.chain(ma, function(a) {
+        return M.map(f(a), function(b) {
+          var _a;
+          return Object.assign({}, a, (_a = {}, _a[name] = b, _a));
+        });
+      });
+    };
+  };
+}
+exports.bind = bind;
+exports.chainFirst = chainFirst;
+exports.tap = tap;
+//# sourceMappingURL=Chain.cjs.map

package/dist/_node_modules/fp-ts/es6/Chain.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Chain.cjs","sources":["../../../../../../node_modules/fp-ts/es6/Chain.js"],"sourcesContent":["export function chainFirst(M) {\n    var tapM = tap(M);\n    return function (f) { return function (first) { return tapM(first, f); }; };\n}\n/** @internal */\nexport function tap(M) {\n    return function (first, f) { return M.chain(first, function (a) { return M.map(f(a), function () { return a; }); }); };\n}\nexport function bind(M) {\n    return function (name, f) { return function (ma) { return M.chain(ma, function (a) { return M.map(f(a), function (b) {\n        var _a;\n        return Object.assign({}, a, (_a = {}, _a[name] = b, _a));\n    }); }); }; };\n}\n"],"names":[],"mappings":";;AAAO,SAAS,WAAW,GAAG;AAC1B,MAAI,OAAO,IAAI,CAAC;AAChB,SAAO,SAAU,GAAG;AAAE,WAAO,SAAU,OAAO;AAAE,aAAO,KAAK,OAAO,CAAC;AAAA,IAAE;AAAA,EAAG;AAC7E;AAEO,SAAS,IAAI,GAAG;AACnB,SAAO,SAAU,OAAO,GAAG;AAAE,WAAO,EAAE,MAAM,OAAO,SAAU,GAAG;AAAE,aAAO,EAAE,IAAI,EAAE,CAAC,GAAG,WAAY;AAAE,eAAO;AAAA,OAAI;AAAA,KAAI;AAAA;AACtH;AACO,SAAS,KAAK,GAAG;AACpB,SAAO,SAAU,MAAM,GAAG;AAAE,WAAO,SAAU,IAAI;AAAE,aAAO,EAAE,MAAM,IAAI,SAAU,GAAG;AAAE,eAAO,EAAE,IAAI,EAAE,CAAC,GAAG,SAAU,GAAG;AACjH,cAAI;AACJ,iBAAO,OAAO,OAAO,CAAE,GAAE,IAAI,KAAK,IAAI,GAAG,IAAI,IAAI,GAAG,GAAE;AAAA,QACzD,CAAA;AAAA,MAAI,CAAA;AAAA,IAAI;AAAA;AACb;;;;","x_google_ignoreList":[0]}