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

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

@@ -1 +0,0 @@
-{"version":3,"file":"ReadonlyNonEmptyArray.js","sources":["../../../../../../node_modules/fp-ts/es6/ReadonlyNonEmptyArray.js"],"sourcesContent":["var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n        if (ar || !(i in from)) {\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n            ar[i] = from[i];\n        }\n    }\n    return to.concat(ar || Array.prototype.slice.call(from));\n};\nimport { apFirst as apFirst_, apS as apS_, apSecond as apSecond_ } from './Apply';\nimport { bind as bind_, chainFirst as chainFirst_ } from './Chain';\nimport { fromEquals } from './Eq';\nimport { dual, flow, identity, pipe, SK } from './function';\nimport { bindTo as bindTo_, flap as flap_, let as let__ } from './Functor';\nimport * as _ from './internal';\nimport { getMonoid } from './Ord';\nimport * as Se from './Semigroup';\n// -------------------------------------------------------------------------------------\n// internal\n// -------------------------------------------------------------------------------------\n/**\n * @internal\n */\nexport var empty = _.emptyReadonlyArray;\n/**\n * @internal\n */\nexport var isNonEmpty = _.isNonEmpty;\n/**\n * @internal\n */\nexport var isOutOfBound = function (i, as) { return i < 0 || i >= as.length; };\n/**\n * @internal\n */\nexport var prependW = function (head) {\n    return function (tail) {\n        return __spreadArray([head], tail, true);\n    };\n};\n/**\n * @internal\n */\nexport var prepend = prependW;\n/**\n * @internal\n */\nexport var appendW = function (end) {\n    return function (init) {\n        return __spreadArray(__spreadArray([], init, true), [end], false);\n    };\n};\n/**\n * @internal\n */\nexport var append = appendW;\n/**\n * @internal\n */\nexport var unsafeInsertAt = function (i, a, as) {\n    if (isNonEmpty(as)) {\n        var xs = _.fromReadonlyNonEmptyArray(as);\n        xs.splice(i, 0, a);\n        return xs;\n    }\n    return [a];\n};\n/**\n * @internal\n */\nexport var unsafeUpdateAt = function (i, a, as) {\n    if (as[i] === a) {\n        return as;\n    }\n    else {\n        var xs = _.fromReadonlyNonEmptyArray(as);\n        xs[i] = a;\n        return xs;\n    }\n};\n/**\n * Remove duplicates from a `ReadonlyNonEmptyArray`, keeping the first occurrence of an element.\n *\n * @example\n * import { uniq } from 'fp-ts/ReadonlyNonEmptyArray'\n * import * as N from 'fp-ts/number'\n *\n * assert.deepStrictEqual(uniq(N.Eq)([1, 2, 1]), [1, 2])\n *\n * @since 2.11.0\n */\nexport var uniq = function (E) {\n    return function (as) {\n        if (as.length === 1) {\n            return as;\n        }\n        var out = [head(as)];\n        var rest = tail(as);\n        var _loop_1 = function (a) {\n            if (out.every(function (o) { return !E.equals(o, a); })) {\n                out.push(a);\n            }\n        };\n        for (var _i = 0, rest_1 = rest; _i < rest_1.length; _i++) {\n            var a = rest_1[_i];\n            _loop_1(a);\n        }\n        return out;\n    };\n};\n/**\n * Sort the elements of a `ReadonlyNonEmptyArray` in increasing order, where elements are compared using first `ords[0]`, then `ords[1]`,\n * etc...\n *\n * @example\n * import * as RNEA from 'fp-ts/ReadonlyNonEmptyArray'\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 *   name: string\n *   age: number\n * }\n *\n * const byName = pipe(S.Ord, contramap((p: Person) => p.name))\n *\n * const byAge = pipe(N.Ord, contramap((p: Person) => p.age))\n *\n * const sortByNameByAge = RNEA.sortBy([byName, byAge])\n *\n * const persons: RNEA.ReadonlyNonEmptyArray<Person> = [\n *   { name: 'a', age: 1 },\n *   { name: 'b', age: 3 },\n *   { name: 'c', age: 2 },\n *   { name: 'b', age: 2 }\n * ]\n *\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.11.0\n */\nexport var sortBy = function (ords) {\n    if (isNonEmpty(ords)) {\n        var M = getMonoid();\n        return sort(ords.reduce(M.concat, M.empty));\n    }\n    return identity;\n};\n/**\n * @since 2.11.0\n */\nexport var union = function (E) {\n    var uniqE = uniq(E);\n    return function (second) { return function (first) { return uniqE(pipe(first, concat(second))); }; };\n};\n/**\n * Rotate a `ReadonlyNonEmptyArray` by `n` steps.\n *\n * @example\n * import { rotate } from 'fp-ts/ReadonlyNonEmptyArray'\n *\n * assert.deepStrictEqual(rotate(2)([1, 2, 3, 4, 5]), [4, 5, 1, 2, 3])\n * assert.deepStrictEqual(rotate(-2)([1, 2, 3, 4, 5]), [3, 4, 5, 1, 2])\n *\n * @since 2.11.0\n */\nexport var rotate = function (n) {\n    return function (as) {\n        var len = as.length;\n        var m = Math.round(n) % len;\n        if (isOutOfBound(Math.abs(m), as) || m === 0) {\n            return as;\n        }\n        if (m < 0) {\n            var _a = splitAt(-m)(as), f = _a[0], s = _a[1];\n            return pipe(s, concat(f));\n        }\n        else {\n            return rotate(m - len)(as);\n        }\n    };\n};\n// -------------------------------------------------------------------------------------\n// constructors\n// -------------------------------------------------------------------------------------\n/**\n * Return a `ReadonlyNonEmptyArray` from a `ReadonlyArray` returning `none` if the input is empty.\n *\n * @category conversions\n * @since 2.5.0\n */\nexport var fromReadonlyArray = function (as) {\n    return isNonEmpty(as) ? _.some(as) : _.none;\n};\n/**\n * Return a `ReadonlyNonEmptyArray` of length `n` with element `i` initialized with `f(i)`.\n *\n * **Note**. `n` is normalized to a natural number.\n *\n * @example\n * import { makeBy } from 'fp-ts/ReadonlyNonEmptyArray'\n * import { pipe } from 'fp-ts/function'\n *\n * const double = (n: number): number => n * 2\n * assert.deepStrictEqual(pipe(5, makeBy(double)), [0, 2, 4, 6, 8])\n *\n * @category constructors\n * @since 2.11.0\n */\nexport var makeBy = function (f) {\n    return function (n) {\n        var j = Math.max(0, Math.floor(n));\n        var out = [f(0)];\n        for (var i = 1; i < j; i++) {\n            out.push(f(i));\n        }\n        return out;\n    };\n};\n/**\n * Create a `ReadonlyNonEmptyArray` containing a value repeated the specified number of times.\n *\n * **Note**. `n` is normalized to a natural number.\n *\n * @example\n * import { replicate } from 'fp-ts/ReadonlyNonEmptyArray'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(pipe(3, replicate('a')), ['a', 'a', 'a'])\n *\n * @category constructors\n * @since 2.11.0\n */\nexport var replicate = function (a) { return makeBy(function () { return a; }); };\n/**\n * Create a `ReadonlyNonEmptyArray` containing a range of integers, including both endpoints.\n *\n * @example\n * import { range } from 'fp-ts/ReadonlyNonEmptyArray'\n *\n * assert.deepStrictEqual(range(1, 5), [1, 2, 3, 4, 5])\n *\n * @category constructors\n * @since 2.11.0\n */\nexport var range = function (start, end) {\n    return start <= end ? makeBy(function (i) { return start + i; })(end - start + 1) : [start];\n};\n/**\n * Return the tuple of the `head` and the `tail`.\n *\n * @example\n * import { unprepend } from 'fp-ts/ReadonlyNonEmptyArray'\n *\n * assert.deepStrictEqual(unprepend([1, 2, 3, 4]), [1, [2, 3, 4]])\n *\n * @since 2.9.0\n */\nexport var unprepend = function (as) { return [head(as), tail(as)]; };\n/**\n * Return the tuple of the `init` and the `last`.\n *\n * @example\n * import { unappend } from 'fp-ts/ReadonlyNonEmptyArray'\n *\n * assert.deepStrictEqual(unappend([1, 2, 3, 4]), [[1, 2, 3], 4])\n *\n * @since 2.9.0\n */\nexport var unappend = function (as) { return [init(as), last(as)]; };\n/**\n * @category conversions\n * @since 2.5.0\n */\nexport var fromArray = function (as) { return fromReadonlyArray(as.slice()); };\nexport function concatW(second) {\n    return function (first) { return first.concat(second); };\n}\nexport function concat(x, y) {\n    return y ? x.concat(y) : function (y) { return y.concat(x); };\n}\n/**\n * @since 2.5.0\n */\nexport var reverse = function (as) {\n    return as.length === 1 ? as : __spreadArray([last(as)], as.slice(0, -1).reverse(), true);\n};\nexport function group(E) {\n    return function (as) {\n        var len = as.length;\n        if (len === 0) {\n            return empty;\n        }\n        var out = [];\n        var head = as[0];\n        var nea = [head];\n        for (var i = 1; i < len; i++) {\n            var a = as[i];\n            if (E.equals(a, head)) {\n                nea.push(a);\n            }\n            else {\n                out.push(nea);\n                head = a;\n                nea = [head];\n            }\n        }\n        out.push(nea);\n        return out;\n    };\n}\n/**\n * Splits an array into sub-non-empty-arrays stored in an object, based on the result of calling a `string`-returning\n * function on each element, and grouping the results according to values returned\n *\n * @example\n * import { groupBy } from 'fp-ts/ReadonlyNonEmptyArray'\n *\n * assert.deepStrictEqual(groupBy((s: string) => String(s.length))(['a', 'b', 'ab']), {\n *   '1': ['a', 'b'],\n *   '2': ['ab']\n * })\n *\n * @since 2.5.0\n */\nexport var groupBy = function (f) {\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            var k = f(a);\n            if (_.has.call(out, k)) {\n                out[k].push(a);\n            }\n            else {\n                out[k] = [a];\n            }\n        }\n        return out;\n    };\n};\n/**\n * @since 2.5.0\n */\nexport var sort = function (O) {\n    return function (as) {\n        return as.length === 1 ? as : as.slice().sort(O.compare);\n    };\n};\n/**\n * @since 2.5.0\n */\nexport var updateAt = function (i, a) {\n    return modifyAt(i, function () { return a; });\n};\n/**\n * @since 2.5.0\n */\nexport var modifyAt = function (i, f) {\n    return function (as) {\n        return isOutOfBound(i, as) ? _.none : _.some(unsafeUpdateAt(i, f(as[i]), as));\n    };\n};\n/**\n * @since 2.5.1\n */\nexport var zipWith = function (as, bs, f) {\n    var cs = [f(as[0], bs[0])];\n    var len = Math.min(as.length, bs.length);\n    for (var i = 1; i < len; i++) {\n        cs[i] = f(as[i], bs[i]);\n    }\n    return cs;\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 * @since 2.5.1\n */\nexport var unzip = function (abs) {\n    var fa = [abs[0][0]];\n    var fb = [abs[0][1]];\n    for (var i = 1; i < abs.length; i++) {\n        fa[i] = abs[i][0];\n        fb[i] = abs[i][1];\n    }\n    return [fa, fb];\n};\n/**\n * Prepend an element to every member of a `ReadonlyNonEmptyArray`.\n *\n * @example\n * import { prependAll } from 'fp-ts/ReadonlyNonEmptyArray'\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    return function (as) {\n        var out = [middle, as[0]];\n        for (var i = 1; i < as.length; i++) {\n            out.push(middle, as[i]);\n        }\n        return out;\n    };\n};\n/**\n * Places an element in between members of a `ReadonlyNonEmptyArray`.\n *\n * @example\n * import { intersperse } from 'fp-ts/ReadonlyNonEmptyArray'\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    return function (as) {\n        var rest = tail(as);\n        return isNonEmpty(rest) ? pipe(rest, prependAll(middle), prepend(head(as))) : as;\n    };\n};\n/**\n * @category sequencing\n * @since 2.10.0\n */\nexport var chainWithIndex = function (f) {\n    return function (as) {\n        var out = _.fromReadonlyNonEmptyArray(f(0, head(as)));\n        for (var i = 1; i < as.length; i++) {\n            out.push.apply(out, f(i, as[i]));\n        }\n        return out;\n    };\n};\n/**\n * A useful recursion pattern for processing a `ReadonlyNonEmptyArray` to produce a new `ReadonlyNonEmptyArray`, often used for \"chopping\" up the input\n * `ReadonlyNonEmptyArray`. Typically `chop` is called with some function that will consume an initial prefix of the `ReadonlyNonEmptyArray` and produce a\n * value and the tail of the `ReadonlyNonEmptyArray`.\n *\n * @since 2.10.0\n */\nexport var chop = function (f) {\n    return function (as) {\n        var _a = f(as), b = _a[0], rest = _a[1];\n        var out = [b];\n        var next = rest;\n        while (isNonEmpty(next)) {\n            var _b = f(next), b_1 = _b[0], rest_2 = _b[1];\n            out.push(b_1);\n            next = rest_2;\n        }\n        return out;\n    };\n};\n/**\n * Splits a `ReadonlyNonEmptyArray` into two pieces, the first piece has max `n` elements.\n *\n * @since 2.10.0\n */\nexport var splitAt = function (n) {\n    return function (as) {\n        var m = Math.max(1, n);\n        return m >= as.length ? [as, empty] : [pipe(as.slice(1, m), prepend(head(as))), as.slice(m)];\n    };\n};\n/**\n * Splits a `ReadonlyNonEmptyArray` into length-`n` pieces. The last piece will be shorter if `n` does not evenly divide the length of\n * the `ReadonlyNonEmptyArray`.\n *\n * @since 2.10.0\n */\nexport var chunksOf = function (n) { return chop(splitAt(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 _extend = function (wa, f) { return pipe(wa, extend(f)); };\n/* istanbul ignore next */\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 _traverse = function (F) {\n    var traverseF = traverse(F);\n    return function (ta, f) { return pipe(ta, traverseF(f)); };\n};\n/* istanbul ignore next */\nvar _alt = function (fa, that) { return pipe(fa, alt(that)); };\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 _traverseWithIndex = function (F) {\n    var traverseWithIndexF = traverseWithIndex(F);\n    return function (ta, f) { return pipe(ta, traverseWithIndexF(f)); };\n};\n/**\n * @category constructors\n * @since 2.5.0\n */\nexport var of = _.singleton;\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 RNEA from 'fp-ts/ReadonlyNonEmptyArray'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     [1, 2, 3] as RNEA.ReadonlyNonEmptyArray<number>,\n *     RNEA.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 (as) {\n        return pipe(as, concatW(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 `ReadonlyNonEmptyArray` concatenates the inputs into a single array.\n *\n * @example\n * import * as RNEA from 'fp-ts/ReadonlyNonEmptyArray'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     [1, 2, 3],\n *     RNEA.alt(() => [4, 5])\n *   ),\n *   [1, 2, 3, 4, 5]\n * )\n *\n * @category error handling\n * @since 2.6.2\n */\nexport var alt = altW;\n/**\n * @since 2.5.0\n */\nexport var ap = function (as) { return flatMap(function (f) { return pipe(as, map(f)); }); };\n/**\n * @example\n * import * as RNEA from 'fp-ts/ReadonlyNonEmptyArray'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     [1, 2, 3],\n *     RNEA.flatMap((n) => [`a${n}`, `b${n}`])\n *   ),\n *   ['a1', 'b1', 'a2', 'b2', 'a3', 'b3']\n * )\n *\n * @category sequencing\n * @since 2.14.0\n */\nexport var flatMap = /*#__PURE__*/ dual(2, function (ma, f) {\n    return pipe(ma, chainWithIndex(function (i, a) { return f(a, i); }));\n});\n/**\n * @since 2.5.0\n */\nexport var extend = function (f) {\n    return function (as) {\n        var next = tail(as);\n        var out = [f(as)];\n        while (isNonEmpty(next)) {\n            out.push(f(next));\n            next = tail(next);\n        }\n        return out;\n    };\n};\n/**\n * @since 2.5.0\n */\nexport var duplicate = \n/*#__PURE__*/ extend(identity);\n/**\n * @category sequencing\n * @since 2.5.0\n */\nexport var flatten = \n/*#__PURE__*/ flatMap(identity);\n/**\n * `map` can be used to turn functions `(a: A) => B` into functions `(fa: F<A>) => F<B>` whose argument and return types\n * use the type constructor `F` to represent some computational context.\n *\n * @category mapping\n * @since 2.5.0\n */\nexport var map = function (f) {\n    return mapWithIndex(function (_, a) { return f(a); });\n};\n/**\n * @category mapping\n * @since 2.5.0\n */\nexport var mapWithIndex = function (f) {\n    return function (as) {\n        var out = [f(0, head(as))];\n        for (var i = 1; i < as.length; i++) {\n            out.push(f(i, as[i]));\n        }\n        return out;\n    };\n};\n/**\n * @category folding\n * @since 2.5.0\n */\nexport var reduce = function (b, f) {\n    return reduceWithIndex(b, function (_, b, a) { return f(b, a); });\n};\n/**\n * **Note**. The constraint is relaxed: a `Semigroup` instead of a `Monoid`.\n *\n * @category folding\n * @since 2.5.0\n */\nexport var foldMap = function (S) {\n    return function (f) {\n        return function (as) {\n            return as.slice(1).reduce(function (s, a) { return S.concat(s, f(a)); }, f(as[0]));\n        };\n    };\n};\n/**\n * @category folding\n * @since 2.5.0\n */\nexport var reduceRight = function (b, f) {\n    return reduceRightWithIndex(b, function (_, b, a) { return f(b, a); });\n};\n/**\n * @category folding\n * @since 2.5.0\n */\nexport var reduceWithIndex = function (b, f) {\n    return function (as) {\n        return as.reduce(function (b, a, i) { return f(i, b, a); }, b);\n    };\n};\n/**\n * **Note**. The constraint is relaxed: a `Semigroup` instead of a `Monoid`.\n *\n * @category folding\n * @since 2.5.0\n */\nexport var foldMapWithIndex = function (S) {\n    return function (f) {\n        return function (as) {\n            return as.slice(1).reduce(function (s, a, i) { return S.concat(s, f(i + 1, a)); }, f(0, as[0]));\n        };\n    };\n};\n/**\n * @category folding\n * @since 2.5.0\n */\nexport var reduceRightWithIndex = function (b, f) {\n    return function (as) {\n        return as.reduceRight(function (b, a, i) { return f(i, a, b); }, b);\n    };\n};\n/**\n * @category traversing\n * @since 2.6.3\n */\nexport var traverse = function (F) {\n    var traverseWithIndexF = traverseWithIndex(F);\n    return function (f) { return traverseWithIndexF(function (_, a) { return f(a); }); };\n};\n/**\n * @category traversing\n * @since 2.6.3\n */\nexport var sequence = function (F) { return traverseWithIndex(F)(SK); };\n/**\n * @category sequencing\n * @since 2.6.3\n */\nexport var traverseWithIndex = function (F) {\n    return function (f) {\n        return function (as) {\n            var out = F.map(f(0, head(as)), of);\n            for (var i = 1; i < as.length; i++) {\n                out = F.ap(F.map(out, function (bs) { return function (b) { return pipe(bs, append(b)); }; }), f(i, as[i]));\n            }\n            return out;\n        };\n    };\n};\n/**\n * @category Comonad\n * @since 2.6.3\n */\nexport var extract = _.head;\n/**\n * @category type lambdas\n * @since 2.5.0\n */\nexport var URI = 'ReadonlyNonEmptyArray';\n/**\n * @category instances\n * @since 2.5.0\n */\nexport var getShow = function (S) { return ({\n    show: function (as) { return \"[\".concat(as.map(S.show).join(', '), \"]\"); }\n}); };\n/**\n * Builds a `Semigroup` instance for `ReadonlyNonEmptyArray`\n *\n * @category instances\n * @since 2.5.0\n */\nexport var getSemigroup = function () { return ({\n    concat: concat\n}); };\n/**\n * @example\n * import { getEq } from 'fp-ts/ReadonlyNonEmptyArray'\n * import * as N from 'fp-ts/number'\n *\n * const E = getEq(N.Eq)\n * assert.strictEqual(E.equals([1, 2], [1, 2]), true)\n * assert.strictEqual(E.equals([1, 2], [1, 3]), false)\n *\n * @category instances\n * @since 2.5.0\n */\nexport var getEq = function (E) {\n    return fromEquals(function (xs, ys) { return xs.length === ys.length && xs.every(function (x, i) { return E.equals(x, ys[i]); }); });\n};\n/**\n * @since 2.11.0\n */\nexport var getUnionSemigroup = function (E) {\n    var unionE = union(E);\n    return {\n        concat: function (first, second) { return unionE(second)(first); }\n    };\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Functor = {\n    URI: URI,\n    map: _map\n};\n/**\n * @category mapping\n * @since 2.10.0\n */\nexport var flap = /*#__PURE__*/ flap_(Functor);\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var Pointed = {\n    URI: URI,\n    of: of\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var FunctorWithIndex = {\n    URI: URI,\n    map: _map,\n    mapWithIndex: _mapWithIndex\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var Apply = {\n    URI: URI,\n    map: _map,\n    ap: _ap\n};\n/**\n * Combine two effectful actions, keeping only the result of the first.\n *\n * @since 2.5.0\n */\nexport var apFirst = /*#__PURE__*/ apFirst_(Apply);\n/**\n * Combine two effectful actions, keeping only the result of the second.\n *\n * @since 2.5.0\n */\nexport var apSecond = /*#__PURE__*/ apSecond_(Apply);\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Applicative = {\n    URI: URI,\n    map: _map,\n    ap: _ap,\n    of: of\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var Chain = {\n    URI: URI,\n    map: _map,\n    ap: _ap,\n    chain: flatMap\n};\n/**\n * Composes computations in sequence, using the return value of one computation to determine the next computation and\n * keeping only the result of the first.\n *\n * @example\n * import * as RA from 'fp-ts/ReadonlyArray'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     [1, 2, 3],\n *     RA.chainFirst(() => ['a', 'b'])\n *   ),\n *   [1, 1, 2, 2, 3, 3]\n * )\n *\n * @category sequencing\n * @since 2.5.0\n */\nexport var chainFirst = /*#__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 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    traverse: _traverse,\n    sequence: sequence,\n    reduceWithIndex: _reduceWithIndex,\n    foldMapWithIndex: _foldMapWithIndex,\n    reduceRightWithIndex: _reduceRightWithIndex,\n    traverseWithIndex: _traverseWithIndex\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.7.0\n */\nexport var Comonad = {\n    URI: URI,\n    map: _map,\n    extend: _extend,\n    extract: extract\n};\n// -------------------------------------------------------------------------------------\n// do notation\n// -------------------------------------------------------------------------------------\n/**\n * @category do notation\n * @since 2.9.0\n */\nexport var Do = /*#__PURE__*/ of(_.emptyRecord);\n/**\n * @category do notation\n * @since 2.8.0\n */\nexport var bindTo = /*#__PURE__*/ bindTo_(Functor);\nvar let_ = /*#__PURE__*/ let__(Functor);\nexport { \n/**\n * @category do notation\n * @since 2.13.0\n */\nlet_ as let };\n/**\n * @category do notation\n * @since 2.8.0\n */\nexport var bind = /*#__PURE__*/ bind_(Chain);\n/**\n * @category do notation\n * @since 2.8.0\n */\nexport var apS = /*#__PURE__*/ apS_(Apply);\n// -------------------------------------------------------------------------------------\n// utils\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.5.0\n */\nexport var head = extract;\n/**\n * @since 2.5.0\n */\nexport var tail = _.tail;\n/**\n * @since 2.5.0\n */\nexport var last = function (as) { return as[as.length - 1]; };\n/**\n * Get all but the last element of a non empty array, creating a new array.\n *\n * @example\n * import { init } from 'fp-ts/ReadonlyNonEmptyArray'\n *\n * assert.deepStrictEqual(init([1, 2, 3]), [1, 2])\n * assert.deepStrictEqual(init([1]), [])\n *\n * @since 2.5.0\n */\nexport var init = function (as) { return as.slice(0, -1); };\n/**\n * @since 2.5.0\n */\nexport var min = function (O) {\n    var S = Se.min(O);\n    return function (as) { return as.reduce(S.concat); };\n};\n/**\n * @since 2.5.0\n */\nexport var max = function (O) {\n    var S = Se.max(O);\n    return function (as) { return as.reduce(S.concat); };\n};\n/**\n * @since 2.10.0\n */\nexport var concatAll = function (S) {\n    return function (as) {\n        return as.reduce(S.concat);\n    };\n};\n/**\n * Break a `ReadonlyArray` into its first element and remaining elements.\n *\n * @category pattern matching\n * @since 2.11.0\n */\nexport var matchLeft = function (f) {\n    return function (as) {\n        return f(head(as), tail(as));\n    };\n};\n/**\n * Break a `ReadonlyArray` into its initial elements and the last element.\n *\n * @category pattern matching\n * @since 2.11.0\n */\nexport var matchRight = function (f) {\n    return function (as) {\n        return f(init(as), last(as));\n    };\n};\n/**\n * Apply a function to the head, creating a new `ReadonlyNonEmptyArray`.\n *\n * @since 2.11.0\n */\nexport var modifyHead = function (f) {\n    return function (as) {\n        return __spreadArray([f(head(as))], tail(as), true);\n    };\n};\n/**\n * Change the head, creating a new `ReadonlyNonEmptyArray`.\n *\n * @since 2.11.0\n */\nexport var updateHead = function (a) { return modifyHead(function () { return a; }); };\n/**\n * Apply a function to the last element, creating a new `ReadonlyNonEmptyArray`.\n *\n * @since 2.11.0\n */\nexport var modifyLast = function (f) {\n    return function (as) {\n        return pipe(init(as), append(f(last(as))));\n    };\n};\n/**\n * Change the last element, creating a new `ReadonlyNonEmptyArray`.\n *\n * @since 2.11.0\n */\nexport var updateLast = function (a) { return modifyLast(function () { return a; }); };\n/**\n * Places an element in between members of a `ReadonlyNonEmptyArray`, then folds the results using the provided `Semigroup`.\n *\n * @example\n * import * as S from 'fp-ts/string'\n * import { intercalate } from 'fp-ts/ReadonlyNonEmptyArray'\n *\n * assert.deepStrictEqual(intercalate(S.Semigroup)('-')(['a', 'b', 'c']), 'a-b-c')\n *\n * @since 2.12.0\n */\nexport var intercalate = function (S) {\n    var concatAllS = concatAll(S);\n    return function (middle) { return flow(intersperse(middle), concatAllS); };\n};\n// -------------------------------------------------------------------------------------\n// legacy\n// -------------------------------------------------------------------------------------\n/**\n * Alias of `flatMap`.\n *\n * @category legacy\n * @since 2.5.0\n */\nexport var chain = flatMap;\nexport function groupSort(O) {\n    var sortO = sort(O);\n    var groupO = group(O);\n    return function (as) { return (isNonEmpty(as) ? groupO(sortO(as)) : empty); };\n}\nexport function filter(predicate) {\n    return filterWithIndex(function (_, a) { return predicate(a); });\n}\n/**\n * Use [`filterWithIndex`](./ReadonlyArray.ts.html#filterwithindex) instead.\n *\n * @category zone of death\n * @since 2.5.0\n * @deprecated\n */\nexport var filterWithIndex = function (predicate) {\n    return function (as) {\n        return fromReadonlyArray(as.filter(function (a, i) { return predicate(i, a); }));\n    };\n};\n/**\n * Use [`unprepend`](#unprepend) instead.\n *\n * @category zone of death\n * @since 2.10.0\n * @deprecated\n */\nexport var uncons = unprepend;\n/**\n * Use [`unappend`](#unappend) instead.\n *\n * @category zone of death\n * @since 2.10.0\n * @deprecated\n */\nexport var unsnoc = unappend;\nexport function cons(head, tail) {\n    return tail === undefined ? prepend(head) : pipe(tail, prepend(head));\n}\n/**\n * Use [`append`](./ReadonlyArray.ts.html#append) instead.\n *\n * @category zone of death\n * @since 2.5.0\n * @deprecated\n */\nexport var snoc = function (init, end) { return pipe(init, concat([end])); };\n/**\n * Use [`insertAt`](./ReadonlyArray.ts.html#insertat) instead.\n *\n * @category zone of death\n * @since 2.5.0\n * @deprecated\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 * Use [`prependAll`](#prependall) instead.\n *\n * @category zone of death\n * @since 2.9.0\n * @deprecated\n */\nexport var prependToAll = prependAll;\n/**\n * Use [`concatAll`](#concatall) instead.\n *\n * @category zone of death\n * @since 2.5.0\n * @deprecated\n */\nexport var fold = concatAll;\n/**\n * This instance is deprecated, use small, specific instances instead.\n * For example if a function needs a `Functor` instance, pass `RNEA.Functor` instead of `RNEA.readonlyNonEmptyArray`\n * (where `RNEA` is from `import RNEA from 'fp-ts/ReadonlyNonEmptyArray'`)\n *\n * @category zone of death\n * @since 2.5.0\n * @deprecated\n */\nexport var readonlyNonEmptyArray = {\n    URI: URI,\n    of: of,\n    map: _map,\n    mapWithIndex: _mapWithIndex,\n    ap: _ap,\n    chain: flatMap,\n    extend: _extend,\n    extract: extract,\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    alt: _alt\n};\n"],"names":["this","_.emptyReadonlyArray","_.isNonEmpty","head","tail","init","_.fromReadonlyNonEmptyArray","a","_.some","_.none","y","_.has","bs","_.singleton","b","_.head","flap_","apFirst_","apSecond_","chainFirst_","_.emptyRecord","bindTo_","let__","bind_","apS_","_.tail","Se.min","Se.max"],"mappings":"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","x_google_ignoreList":[0]}