@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/NonEmptyArray.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"NonEmptyArray.cjs","sources":["../../../../../../node_modules/fp-ts/es6/NonEmptyArray.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 { dual, identity, pipe } from './function';\nimport { bindTo as bindTo_, flap as flap_, let as let__ } from './Functor';\nimport * as _ from './internal';\nimport { getMonoid } from './Ord';\nimport * as RNEA from './ReadonlyNonEmptyArray';\n// -------------------------------------------------------------------------------------\n// internal\n// -------------------------------------------------------------------------------------\n/**\n * @internal\n */\nexport var isNonEmpty = function (as) { return as.length > 0; };\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    var xs = fromReadonlyNonEmptyArray(as);\n    xs[i] = a;\n    return xs;\n};\n/**\n * Remove duplicates from a `NonEmptyArray`, keeping the first occurrence of an element.\n *\n * @example\n * import { uniq } from 'fp-ts/NonEmptyArray'\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 copy(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 `NonEmptyArray` in increasing order, where elements are compared using first `ords[0]`, then `ords[1]`,\n * etc...\n *\n * @example\n * import * as NEA from 'fp-ts/NonEmptyArray'\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 = NEA.sortBy([byName, byAge])\n *\n * const persons: NEA.NonEmptyArray<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 copy;\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 `NonEmptyArray` by `n` steps.\n *\n * @example\n * import { rotate } from 'fp-ts/NonEmptyArray'\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 copy(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 * @category conversions\n * @since 2.10.0\n */\nexport var fromReadonlyNonEmptyArray = _.fromReadonlyNonEmptyArray;\n/**\n * Builds a `NonEmptyArray` from an `Array` returning `none` if `as` is an empty array\n *\n * @category conversions\n * @since 2.0.0\n */\nexport var fromArray = function (as) { return (isNonEmpty(as) ? _.some(as) : _.none); };\n/**\n * Return a `NonEmptyArray` 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/NonEmptyArray'\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 `NonEmptyArray` 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/NonEmptyArray'\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 `NonEmptyArray` containing a range of integers, including both endpoints.\n *\n * @example\n * import { range } from 'fp-ts/NonEmptyArray'\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/NonEmptyArray'\n *\n * assert.deepStrictEqual(unprepend([1, 2, 3]), [1, [2, 3]])\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/NonEmptyArray'\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)]; };\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.0.0\n */\nexport var reverse = function (as) { return __spreadArray([last(as)], as.slice(0, -1).reverse(), true); };\nexport function group(E) {\n    return function (as) {\n        var len = as.length;\n        if (len === 0) {\n            return [];\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/NonEmptyArray'\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.0.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.0.0\n */\nexport var sort = function (O) {\n    return function (as) {\n        return as.slice().sort(O.compare);\n    };\n};\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 * @since 2.0.0\n */\nexport var updateAt = function (i, a) {\n    return modifyAt(i, function () { return a; });\n};\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 * @since 2.0.0\n */\nexport var copy = fromReadonlyNonEmptyArray;\n/**\n * @category constructors\n * @since 2.0.0\n */\nexport var of = function (a) { return [a]; };\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 an array\n *\n * @example\n * import { prependAll } from 'fp-ts/NonEmptyArray'\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 an array\n *\n * @example\n * import { intersperse } from 'fp-ts/NonEmptyArray'\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))) : copy(as);\n    };\n};\n/**\n * @category folding\n * @since 2.0.0\n */\nexport var foldMapWithIndex = RNEA.foldMapWithIndex;\n/**\n * @category folding\n * @since 2.0.0\n */\nexport var foldMap = RNEA.foldMap;\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 * @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 `NonEmptyArray` 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 ? [copy(as), []] : [pipe(as.slice(1, m), prepend(head(as))), as.slice(m)];\n    };\n};\n/**\n * @since 2.10.0\n */\nexport var chunksOf = function (n) { return chop(splitAt(n)); };\n/* istanbul ignore next */\nvar _map = function (fa, f) { return pipe(fa, map(f)); };\n/* istanbul ignore next */\nvar _mapWithIndex = function (fa, f) { return pipe(fa, mapWithIndex(f)); };\n/* istanbul ignore next */\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 * 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 NEA from 'fp-ts/NonEmptyArray'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     [1, 2, 3] as NEA.NonEmptyArray<number>,\n *     NEA.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 `NonEmptyArray` concatenates the inputs into a single array.\n *\n * @example\n * import * as NEA from 'fp-ts/NonEmptyArray'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     [1, 2, 3],\n *     NEA.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 * Apply a function to an argument under a type constructor.\n *\n * @since 2.0.0\n */\nexport var ap = function (as) {\n    return flatMap(function (f) { return pipe(as, map(f)); });\n};\n/**\n * @example\n * import * as NEA from 'fp-ts/NonEmptyArray'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(\n *   pipe(\n *     [1, 2, 3],\n *     NEA.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.0.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 = /*#__PURE__*/ extend(identity);\n/**\n * @category sequencing\n * @since 2.5.0\n */\nexport var flatten = /*#__PURE__*/ flatMap(identity);\n/**\n * `map` can be used to turn functions `(a: A) => B` into functions `(fa: F<A>) => F<B>` whose argument and return types\n * use the type constructor `F` to represent some computational context.\n *\n * @category mapping\n * @since 2.0.0\n */\nexport var map = function (f) { return mapWithIndex(function (_, a) { return f(a); }); };\n/**\n * @category mapping\n * @since 2.0.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.0.0\n */\nexport var reduce = RNEA.reduce;\n/**\n * @category folding\n * @since 2.0.0\n */\nexport var reduceWithIndex = RNEA.reduceWithIndex;\n/**\n * @category folding\n * @since 2.0.0\n */\nexport var reduceRight = RNEA.reduceRight;\n/**\n * @category folding\n * @since 2.0.0\n */\nexport var reduceRightWithIndex = RNEA.reduceRightWithIndex;\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)(function (_, a) { return a; }); };\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 * @since 2.7.0\n */\nexport var extract = RNEA.head;\n/**\n * @category type lambdas\n * @since 2.0.0\n */\nexport var URI = 'NonEmptyArray';\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var getShow = RNEA.getShow;\n/**\n * Builds a `Semigroup` instance for `NonEmptyArray`\n *\n * @category instances\n * @since 2.0.0\n */\nexport var getSemigroup = function () { return ({\n    concat: concat\n}); };\n/**\n * @example\n * import { getEq } from 'fp-ts/NonEmptyArray'\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.0.0\n */\nexport var getEq = RNEA.getEq;\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 * @category sequencing\n * @since 2.5.0\n */\nexport var chainFirst = \n/*#__PURE__*/ chainFirst_(Chain);\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var 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.0.0\n */\nexport var head = RNEA.head;\n/**\n * @since 2.0.0\n */\nexport var tail = function (as) { return as.slice(1); };\n/**\n * @since 2.0.0\n */\nexport var last = RNEA.last;\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/NonEmptyArray'\n *\n * assert.deepStrictEqual(init([1, 2, 3]), [1, 2])\n * assert.deepStrictEqual(init([1]), [])\n *\n * @since 2.2.0\n */\nexport var init = function (as) { return as.slice(0, -1); };\n/**\n * @since 2.0.0\n */\nexport var min = RNEA.min;\n/**\n * @since 2.0.0\n */\nexport var max = RNEA.max;\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 an `Array` 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 an `Array` 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 `NonEmptyArray`.\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 `NonEmptyArray`.\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 `NonEmptyArray`.\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 `NonEmptyArray`.\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 `NonEmptyArray`, 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/NonEmptyArray'\n *\n * assert.deepStrictEqual(intercalate(S.Semigroup)('-')(['a', 'b', 'c']), 'a-b-c')\n *\n * @since 2.12.0\n */\nexport var intercalate = RNEA.intercalate;\n// -------------------------------------------------------------------------------------\n// legacy\n// -------------------------------------------------------------------------------------\n/**\n * Alias of `flatMap`.\n *\n * @category legacy\n * @since 2.0.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)) : []); };\n}\nexport function filter(predicate) {\n    return filterWithIndex(function (_, a) { return predicate(a); });\n}\n/**\n * Use [`filterWithIndex`](./Array.ts.html#filterwithindex) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var filterWithIndex = function (predicate) {\n    return function (as) {\n        return fromArray(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.9.0\n * @deprecated\n */\nexport var uncons = unprepend;\n/**\n * Use [`unappend`](#unappend) instead.\n *\n * @category zone of death\n * @since 2.9.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`](./Array.ts.html#append) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var snoc = function (init, end) { return pipe(init, append(end)); };\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 = RNEA.concatAll;\n/**\n * This instance is deprecated, use small, specific instances instead.\n * For example if a function needs a `Functor` instance, pass `NEA.Functor` instead of `NEA.nonEmptyArray`\n * (where `NEA` is from `import NEA from 'fp-ts/NonEmptyArray'`)\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var nonEmptyArray = {\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","head","tail","init","a","getMonoid","pipe","_.fromReadonlyNonEmptyArray","_.some","_.none","y","_.has","bs","RNEA.foldMapWithIndex","RNEA.foldMap","dual","identity","RNEA.reduce","RNEA.reduceWithIndex","RNEA.reduceRight","RNEA.reduceRightWithIndex","RNEA.head","RNEA.getShow","RNEA.getEq","flap_","apFirst_","apSecond_","chainFirst_","_.emptyRecord","bindTo_","let__","bind_","apS_","RNEA.last","RNEA.min","RNEA.max","RNEA.intercalate","RNEA.concatAll"],"mappings":"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","x_google_ignoreList":[0]}