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

package/dist/_node_modules/fp-ts/lib/NonEmptyArray.cjs

@@ -0,0 +1,732 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const _commonjsHelpers = require("../../../_virtual/_commonjsHelpers.cjs");
+const NonEmptyArray = require("../../../_virtual/NonEmptyArray.cjs");
+const Apply = require("./Apply.cjs");
+const Chain = require("./Chain.cjs");
+const _function = require("./function.cjs");
+const Functor = require("./Functor.cjs");
+const internal = require("./internal.cjs");
+const Ord = require("./Ord.cjs");
+const ReadonlyNonEmptyArray = require("./ReadonlyNonEmptyArray.cjs");
+var hasRequiredNonEmptyArray;
+function requireNonEmptyArray() {
+  if (hasRequiredNonEmptyArray)
+    return NonEmptyArray.__exports;
+  hasRequiredNonEmptyArray = 1;
+  (function(exports2) {
+    var __createBinding = _commonjsHelpers.commonjsGlobal && _commonjsHelpers.commonjsGlobal.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = _commonjsHelpers.commonjsGlobal && _commonjsHelpers.commonjsGlobal.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = _commonjsHelpers.commonjsGlobal && _commonjsHelpers.commonjsGlobal.__importStar || function(mod) {
+      if (mod && mod.__esModule)
+        return mod;
+      var result = {};
+      if (mod != null) {
+        for (var k in mod)
+          if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
+            __createBinding(result, mod, k);
+      }
+      __setModuleDefault(result, mod);
+      return result;
+    };
+    var __spreadArray = _commonjsHelpers.commonjsGlobal && _commonjsHelpers.commonjsGlobal.__spreadArray || function(to, from, pack) {
+      if (pack || arguments.length === 2)
+        for (var i = 0, l = from.length, ar; i < l; i++) {
+          if (ar || !(i in from)) {
+            if (!ar)
+              ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+          }
+        }
+      return to.concat(ar || Array.prototype.slice.call(from));
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.mapWithIndex = exports2.map = exports2.flatten = exports2.duplicate = exports2.extend = exports2.flatMap = exports2.ap = exports2.alt = exports2.altW = exports2.chunksOf = exports2.splitAt = exports2.chop = exports2.chainWithIndex = exports2.foldMap = exports2.foldMapWithIndex = exports2.intersperse = exports2.prependAll = exports2.unzip = exports2.zip = exports2.zipWith = exports2.of = exports2.copy = exports2.modifyAt = exports2.updateAt = exports2.insertAt = exports2.sort = exports2.groupBy = exports2.group = exports2.reverse = exports2.concat = exports2.concatW = exports2.unappend = exports2.unprepend = exports2.range = exports2.replicate = exports2.makeBy = exports2.fromArray = exports2.fromReadonlyNonEmptyArray = exports2.rotate = exports2.union = exports2.sortBy = exports2.uniq = exports2.unsafeUpdateAt = exports2.unsafeInsertAt = exports2.append = exports2.appendW = exports2.prepend = exports2.prependW = exports2.isOutOfBound = exports2.isNonEmpty = void 0;
+    exports2.chain = exports2.intercalate = exports2.updateLast = exports2.modifyLast = exports2.updateHead = exports2.modifyHead = exports2.matchRight = exports2.matchLeft = exports2.concatAll = exports2.max = exports2.min = exports2.init = exports2.last = exports2.tail = exports2.head = exports2.apS = exports2.bind = exports2.let = exports2.bindTo = exports2.Do = exports2.Comonad = exports2.Alt = exports2.TraversableWithIndex = exports2.Traversable = exports2.FoldableWithIndex = exports2.Foldable = exports2.Monad = exports2.chainFirst = exports2.Chain = exports2.Applicative = exports2.apSecond = exports2.apFirst = exports2.Apply = exports2.FunctorWithIndex = exports2.Pointed = exports2.flap = exports2.Functor = exports2.getUnionSemigroup = exports2.getEq = exports2.getSemigroup = exports2.getShow = exports2.URI = exports2.extract = exports2.traverseWithIndex = exports2.sequence = exports2.traverse = exports2.reduceRightWithIndex = exports2.reduceRight = exports2.reduceWithIndex = exports2.reduce = void 0;
+    exports2.nonEmptyArray = exports2.fold = exports2.prependToAll = exports2.snoc = exports2.cons = exports2.unsnoc = exports2.uncons = exports2.filterWithIndex = exports2.filter = exports2.groupSort = void 0;
+    var Apply_1 = Apply.__require();
+    var Chain_1 = Chain.__require();
+    var function_1 = _function.__require();
+    var Functor_1 = Functor.__require();
+    var _ = __importStar(internal.__require());
+    var Ord_1 = Ord.__require();
+    var RNEA = __importStar(ReadonlyNonEmptyArray.__require());
+    var isNonEmpty = function(as) {
+      return as.length > 0;
+    };
+    exports2.isNonEmpty = isNonEmpty;
+    var isOutOfBound = function(i, as) {
+      return i < 0 || i >= as.length;
+    };
+    exports2.isOutOfBound = isOutOfBound;
+    var prependW = function(head) {
+      return function(tail2) {
+        return __spreadArray([head], tail2, true);
+      };
+    };
+    exports2.prependW = prependW;
+    exports2.prepend = exports2.prependW;
+    var appendW = function(end) {
+      return function(init2) {
+        return __spreadArray(__spreadArray([], init2, true), [end], false);
+      };
+    };
+    exports2.appendW = appendW;
+    exports2.append = exports2.appendW;
+    var unsafeInsertAt = function(i, a, as) {
+      if ((0, exports2.isNonEmpty)(as)) {
+        var xs = (0, exports2.fromReadonlyNonEmptyArray)(as);
+        xs.splice(i, 0, a);
+        return xs;
+      }
+      return [a];
+    };
+    exports2.unsafeInsertAt = unsafeInsertAt;
+    var unsafeUpdateAt = function(i, a, as) {
+      var xs = (0, exports2.fromReadonlyNonEmptyArray)(as);
+      xs[i] = a;
+      return xs;
+    };
+    exports2.unsafeUpdateAt = unsafeUpdateAt;
+    var uniq = function(E) {
+      return function(as) {
+        if (as.length === 1) {
+          return (0, exports2.copy)(as);
+        }
+        var out = [(0, exports2.head)(as)];
+        var rest = (0, exports2.tail)(as);
+        var _loop_1 = function(a2) {
+          if (out.every(function(o) {
+            return !E.equals(o, a2);
+          })) {
+            out.push(a2);
+          }
+        };
+        for (var _i = 0, rest_1 = rest; _i < rest_1.length; _i++) {
+          var a = rest_1[_i];
+          _loop_1(a);
+        }
+        return out;
+      };
+    };
+    exports2.uniq = uniq;
+    var sortBy = function(ords) {
+      if ((0, exports2.isNonEmpty)(ords)) {
+        var M = (0, Ord_1.getMonoid)();
+        return (0, exports2.sort)(ords.reduce(M.concat, M.empty));
+      }
+      return exports2.copy;
+    };
+    exports2.sortBy = sortBy;
+    var union = function(E) {
+      var uniqE = (0, exports2.uniq)(E);
+      return function(second) {
+        return function(first) {
+          return uniqE((0, function_1.pipe)(first, concat(second)));
+        };
+      };
+    };
+    exports2.union = union;
+    var rotate = function(n) {
+      return function(as) {
+        var len = as.length;
+        var m = Math.round(n) % len;
+        if ((0, exports2.isOutOfBound)(Math.abs(m), as) || m === 0) {
+          return (0, exports2.copy)(as);
+        }
+        if (m < 0) {
+          var _a = (0, exports2.splitAt)(-m)(as), f = _a[0], s = _a[1];
+          return (0, function_1.pipe)(s, concat(f));
+        } else {
+          return (0, exports2.rotate)(m - len)(as);
+        }
+      };
+    };
+    exports2.rotate = rotate;
+    exports2.fromReadonlyNonEmptyArray = _.fromReadonlyNonEmptyArray;
+    var fromArray = function(as) {
+      return (0, exports2.isNonEmpty)(as) ? _.some(as) : _.none;
+    };
+    exports2.fromArray = fromArray;
+    var makeBy = function(f) {
+      return function(n) {
+        var j = Math.max(0, Math.floor(n));
+        var out = [f(0)];
+        for (var i = 1; i < j; i++) {
+          out.push(f(i));
+        }
+        return out;
+      };
+    };
+    exports2.makeBy = makeBy;
+    var replicate = function(a) {
+      return (0, exports2.makeBy)(function() {
+        return a;
+      });
+    };
+    exports2.replicate = replicate;
+    var range = function(start, end) {
+      return start <= end ? (0, exports2.makeBy)(function(i) {
+        return start + i;
+      })(end - start + 1) : [start];
+    };
+    exports2.range = range;
+    var unprepend = function(as) {
+      return [(0, exports2.head)(as), (0, exports2.tail)(as)];
+    };
+    exports2.unprepend = unprepend;
+    var unappend = function(as) {
+      return [(0, exports2.init)(as), (0, exports2.last)(as)];
+    };
+    exports2.unappend = unappend;
+    function concatW(second) {
+      return function(first) {
+        return first.concat(second);
+      };
+    }
+    exports2.concatW = concatW;
+    function concat(x, y) {
+      return y ? x.concat(y) : function(y2) {
+        return y2.concat(x);
+      };
+    }
+    exports2.concat = concat;
+    var reverse = function(as) {
+      return __spreadArray([(0, exports2.last)(as)], as.slice(0, -1).reverse(), true);
+    };
+    exports2.reverse = reverse;
+    function group(E) {
+      return function(as) {
+        var len = as.length;
+        if (len === 0) {
+          return [];
+        }
+        var out = [];
+        var head = as[0];
+        var nea = [head];
+        for (var i = 1; i < len; i++) {
+          var a = as[i];
+          if (E.equals(a, head)) {
+            nea.push(a);
+          } else {
+            out.push(nea);
+            head = a;
+            nea = [head];
+          }
+        }
+        out.push(nea);
+        return out;
+      };
+    }
+    exports2.group = group;
+    var groupBy = function(f) {
+      return function(as) {
+        var out = {};
+        for (var _i = 0, as_1 = as; _i < as_1.length; _i++) {
+          var a = as_1[_i];
+          var k = f(a);
+          if (_.has.call(out, k)) {
+            out[k].push(a);
+          } else {
+            out[k] = [a];
+          }
+        }
+        return out;
+      };
+    };
+    exports2.groupBy = groupBy;
+    var sort = function(O) {
+      return function(as) {
+        return as.slice().sort(O.compare);
+      };
+    };
+    exports2.sort = sort;
+    var insertAt = function(i, a) {
+      return function(as) {
+        return i < 0 || i > as.length ? _.none : _.some((0, exports2.unsafeInsertAt)(i, a, as));
+      };
+    };
+    exports2.insertAt = insertAt;
+    var updateAt = function(i, a) {
+      return (0, exports2.modifyAt)(i, function() {
+        return a;
+      });
+    };
+    exports2.updateAt = updateAt;
+    var modifyAt = function(i, f) {
+      return function(as) {
+        return (0, exports2.isOutOfBound)(i, as) ? _.none : _.some((0, exports2.unsafeUpdateAt)(i, f(as[i]), as));
+      };
+    };
+    exports2.modifyAt = modifyAt;
+    exports2.copy = exports2.fromReadonlyNonEmptyArray;
+    var of = function(a) {
+      return [a];
+    };
+    exports2.of = of;
+    var zipWith = function(as, bs, f) {
+      var cs = [f(as[0], bs[0])];
+      var len = Math.min(as.length, bs.length);
+      for (var i = 1; i < len; i++) {
+        cs[i] = f(as[i], bs[i]);
+      }
+      return cs;
+    };
+    exports2.zipWith = zipWith;
+    function zip(as, bs) {
+      if (bs === void 0) {
+        return function(bs2) {
+          return zip(bs2, as);
+        };
+      }
+      return (0, exports2.zipWith)(as, bs, function(a, b) {
+        return [a, b];
+      });
+    }
+    exports2.zip = zip;
+    var unzip = function(abs) {
+      var fa = [abs[0][0]];
+      var fb = [abs[0][1]];
+      for (var i = 1; i < abs.length; i++) {
+        fa[i] = abs[i][0];
+        fb[i] = abs[i][1];
+      }
+      return [fa, fb];
+    };
+    exports2.unzip = unzip;
+    var prependAll = function(middle) {
+      return function(as) {
+        var out = [middle, as[0]];
+        for (var i = 1; i < as.length; i++) {
+          out.push(middle, as[i]);
+        }
+        return out;
+      };
+    };
+    exports2.prependAll = prependAll;
+    var intersperse = function(middle) {
+      return function(as) {
+        var rest = (0, exports2.tail)(as);
+        return (0, exports2.isNonEmpty)(rest) ? (0, function_1.pipe)(rest, (0, exports2.prependAll)(middle), (0, exports2.prepend)((0, exports2.head)(as))) : (0, exports2.copy)(as);
+      };
+    };
+    exports2.intersperse = intersperse;
+    exports2.foldMapWithIndex = RNEA.foldMapWithIndex;
+    exports2.foldMap = RNEA.foldMap;
+    var chainWithIndex = function(f) {
+      return function(as) {
+        var out = (0, exports2.fromReadonlyNonEmptyArray)(f(0, (0, exports2.head)(as)));
+        for (var i = 1; i < as.length; i++) {
+          out.push.apply(out, f(i, as[i]));
+        }
+        return out;
+      };
+    };
+    exports2.chainWithIndex = chainWithIndex;
+    var chop = function(f) {
+      return function(as) {
+        var _a = f(as), b = _a[0], rest = _a[1];
+        var out = [b];
+        var next = rest;
+        while ((0, exports2.isNonEmpty)(next)) {
+          var _b = f(next), b_1 = _b[0], rest_2 = _b[1];
+          out.push(b_1);
+          next = rest_2;
+        }
+        return out;
+      };
+    };
+    exports2.chop = chop;
+    var splitAt = function(n) {
+      return function(as) {
+        var m = Math.max(1, n);
+        return m >= as.length ? [(0, exports2.copy)(as), []] : [(0, function_1.pipe)(as.slice(1, m), (0, exports2.prepend)((0, exports2.head)(as))), as.slice(m)];
+      };
+    };
+    exports2.splitAt = splitAt;
+    var chunksOf = function(n) {
+      return (0, exports2.chop)((0, exports2.splitAt)(n));
+    };
+    exports2.chunksOf = chunksOf;
+    var _map = function(fa, f) {
+      return (0, function_1.pipe)(fa, (0, exports2.map)(f));
+    };
+    var _mapWithIndex = function(fa, f) {
+      return (0, function_1.pipe)(fa, (0, exports2.mapWithIndex)(f));
+    };
+    var _ap = function(fab, fa) {
+      return (0, function_1.pipe)(fab, (0, exports2.ap)(fa));
+    };
+    var _extend = function(wa, f) {
+      return (0, function_1.pipe)(wa, (0, exports2.extend)(f));
+    };
+    var _reduce = function(fa, b, f) {
+      return (0, function_1.pipe)(fa, (0, exports2.reduce)(b, f));
+    };
+    var _foldMap = function(M) {
+      var foldMapM = (0, exports2.foldMap)(M);
+      return function(fa, f) {
+        return (0, function_1.pipe)(fa, foldMapM(f));
+      };
+    };
+    var _reduceRight = function(fa, b, f) {
+      return (0, function_1.pipe)(fa, (0, exports2.reduceRight)(b, f));
+    };
+    var _traverse = function(F) {
+      var traverseF = (0, exports2.traverse)(F);
+      return function(ta, f) {
+        return (0, function_1.pipe)(ta, traverseF(f));
+      };
+    };
+    var _alt = function(fa, that) {
+      return (0, function_1.pipe)(fa, (0, exports2.alt)(that));
+    };
+    var _reduceWithIndex = function(fa, b, f) {
+      return (0, function_1.pipe)(fa, (0, exports2.reduceWithIndex)(b, f));
+    };
+    var _foldMapWithIndex = function(M) {
+      var foldMapWithIndexM = (0, exports2.foldMapWithIndex)(M);
+      return function(fa, f) {
+        return (0, function_1.pipe)(fa, foldMapWithIndexM(f));
+      };
+    };
+    var _reduceRightWithIndex = function(fa, b, f) {
+      return (0, function_1.pipe)(fa, (0, exports2.reduceRightWithIndex)(b, f));
+    };
+    var _traverseWithIndex = function(F) {
+      var traverseWithIndexF = (0, exports2.traverseWithIndex)(F);
+      return function(ta, f) {
+        return (0, function_1.pipe)(ta, traverseWithIndexF(f));
+      };
+    };
+    var altW = function(that) {
+      return function(as) {
+        return (0, function_1.pipe)(as, concatW(that()));
+      };
+    };
+    exports2.altW = altW;
+    exports2.alt = exports2.altW;
+    var ap = function(as) {
+      return (0, exports2.flatMap)(function(f) {
+        return (0, function_1.pipe)(as, (0, exports2.map)(f));
+      });
+    };
+    exports2.ap = ap;
+    exports2.flatMap = (0, function_1.dual)(2, function(ma, f) {
+      return (0, function_1.pipe)(ma, (0, exports2.chainWithIndex)(function(i, a) {
+        return f(a, i);
+      }));
+    });
+    var extend = function(f) {
+      return function(as) {
+        var next = (0, exports2.tail)(as);
+        var out = [f(as)];
+        while ((0, exports2.isNonEmpty)(next)) {
+          out.push(f(next));
+          next = (0, exports2.tail)(next);
+        }
+        return out;
+      };
+    };
+    exports2.extend = extend;
+    exports2.duplicate = (0, exports2.extend)(function_1.identity);
+    exports2.flatten = (0, exports2.flatMap)(function_1.identity);
+    var map = function(f) {
+      return (0, exports2.mapWithIndex)(function(_2, a) {
+        return f(a);
+      });
+    };
+    exports2.map = map;
+    var mapWithIndex = function(f) {
+      return function(as) {
+        var out = [f(0, (0, exports2.head)(as))];
+        for (var i = 1; i < as.length; i++) {
+          out.push(f(i, as[i]));
+        }
+        return out;
+      };
+    };
+    exports2.mapWithIndex = mapWithIndex;
+    exports2.reduce = RNEA.reduce;
+    exports2.reduceWithIndex = RNEA.reduceWithIndex;
+    exports2.reduceRight = RNEA.reduceRight;
+    exports2.reduceRightWithIndex = RNEA.reduceRightWithIndex;
+    var traverse = function(F) {
+      var traverseWithIndexF = (0, exports2.traverseWithIndex)(F);
+      return function(f) {
+        return traverseWithIndexF(function(_2, a) {
+          return f(a);
+        });
+      };
+    };
+    exports2.traverse = traverse;
+    var sequence = function(F) {
+      return (0, exports2.traverseWithIndex)(F)(function(_2, a) {
+        return a;
+      });
+    };
+    exports2.sequence = sequence;
+    var traverseWithIndex = function(F) {
+      return function(f) {
+        return function(as) {
+          var out = F.map(f(0, (0, exports2.head)(as)), exports2.of);
+          for (var i = 1; i < as.length; i++) {
+            out = F.ap(F.map(out, function(bs) {
+              return function(b) {
+                return (0, function_1.pipe)(bs, (0, exports2.append)(b));
+              };
+            }), f(i, as[i]));
+          }
+          return out;
+        };
+      };
+    };
+    exports2.traverseWithIndex = traverseWithIndex;
+    exports2.extract = RNEA.head;
+    exports2.URI = "NonEmptyArray";
+    exports2.getShow = RNEA.getShow;
+    var getSemigroup = function() {
+      return {
+        concat
+      };
+    };
+    exports2.getSemigroup = getSemigroup;
+    exports2.getEq = RNEA.getEq;
+    var getUnionSemigroup = function(E) {
+      var unionE = (0, exports2.union)(E);
+      return {
+        concat: function(first, second) {
+          return unionE(second)(first);
+        }
+      };
+    };
+    exports2.getUnionSemigroup = getUnionSemigroup;
+    exports2.Functor = {
+      URI: exports2.URI,
+      map: _map
+    };
+    exports2.flap = (0, Functor_1.flap)(exports2.Functor);
+    exports2.Pointed = {
+      URI: exports2.URI,
+      of: exports2.of
+    };
+    exports2.FunctorWithIndex = {
+      URI: exports2.URI,
+      map: _map,
+      mapWithIndex: _mapWithIndex
+    };
+    exports2.Apply = {
+      URI: exports2.URI,
+      map: _map,
+      ap: _ap
+    };
+    exports2.apFirst = (0, Apply_1.apFirst)(exports2.Apply);
+    exports2.apSecond = (0, Apply_1.apSecond)(exports2.Apply);
+    exports2.Applicative = {
+      URI: exports2.URI,
+      map: _map,
+      ap: _ap,
+      of: exports2.of
+    };
+    exports2.Chain = {
+      URI: exports2.URI,
+      map: _map,
+      ap: _ap,
+      chain: exports2.flatMap
+    };
+    exports2.chainFirst = /* @__PURE__ */ (0, Chain_1.chainFirst)(exports2.Chain);
+    exports2.Monad = {
+      URI: exports2.URI,
+      map: _map,
+      ap: _ap,
+      of: exports2.of,
+      chain: exports2.flatMap
+    };
+    exports2.Foldable = {
+      URI: exports2.URI,
+      reduce: _reduce,
+      foldMap: _foldMap,
+      reduceRight: _reduceRight
+    };
+    exports2.FoldableWithIndex = {
+      URI: exports2.URI,
+      reduce: _reduce,
+      foldMap: _foldMap,
+      reduceRight: _reduceRight,
+      reduceWithIndex: _reduceWithIndex,
+      foldMapWithIndex: _foldMapWithIndex,
+      reduceRightWithIndex: _reduceRightWithIndex
+    };
+    exports2.Traversable = {
+      URI: exports2.URI,
+      map: _map,
+      reduce: _reduce,
+      foldMap: _foldMap,
+      reduceRight: _reduceRight,
+      traverse: _traverse,
+      sequence: exports2.sequence
+    };
+    exports2.TraversableWithIndex = {
+      URI: exports2.URI,
+      map: _map,
+      mapWithIndex: _mapWithIndex,
+      reduce: _reduce,
+      foldMap: _foldMap,
+      reduceRight: _reduceRight,
+      traverse: _traverse,
+      sequence: exports2.sequence,
+      reduceWithIndex: _reduceWithIndex,
+      foldMapWithIndex: _foldMapWithIndex,
+      reduceRightWithIndex: _reduceRightWithIndex,
+      traverseWithIndex: _traverseWithIndex
+    };
+    exports2.Alt = {
+      URI: exports2.URI,
+      map: _map,
+      alt: _alt
+    };
+    exports2.Comonad = {
+      URI: exports2.URI,
+      map: _map,
+      extend: _extend,
+      extract: exports2.extract
+    };
+    exports2.Do = (0, exports2.of)(_.emptyRecord);
+    exports2.bindTo = (0, Functor_1.bindTo)(exports2.Functor);
+    var let_ = /* @__PURE__ */ (0, Functor_1.let)(exports2.Functor);
+    exports2.let = let_;
+    exports2.bind = (0, Chain_1.bind)(exports2.Chain);
+    exports2.apS = (0, Apply_1.apS)(exports2.Apply);
+    exports2.head = RNEA.head;
+    var tail = function(as) {
+      return as.slice(1);
+    };
+    exports2.tail = tail;
+    exports2.last = RNEA.last;
+    var init = function(as) {
+      return as.slice(0, -1);
+    };
+    exports2.init = init;
+    exports2.min = RNEA.min;
+    exports2.max = RNEA.max;
+    var concatAll = function(S) {
+      return function(as) {
+        return as.reduce(S.concat);
+      };
+    };
+    exports2.concatAll = concatAll;
+    var matchLeft = function(f) {
+      return function(as) {
+        return f((0, exports2.head)(as), (0, exports2.tail)(as));
+      };
+    };
+    exports2.matchLeft = matchLeft;
+    var matchRight = function(f) {
+      return function(as) {
+        return f((0, exports2.init)(as), (0, exports2.last)(as));
+      };
+    };
+    exports2.matchRight = matchRight;
+    var modifyHead = function(f) {
+      return function(as) {
+        return __spreadArray([f((0, exports2.head)(as))], (0, exports2.tail)(as), true);
+      };
+    };
+    exports2.modifyHead = modifyHead;
+    var updateHead = function(a) {
+      return (0, exports2.modifyHead)(function() {
+        return a;
+      });
+    };
+    exports2.updateHead = updateHead;
+    var modifyLast = function(f) {
+      return function(as) {
+        return (0, function_1.pipe)((0, exports2.init)(as), (0, exports2.append)(f((0, exports2.last)(as))));
+      };
+    };
+    exports2.modifyLast = modifyLast;
+    var updateLast = function(a) {
+      return (0, exports2.modifyLast)(function() {
+        return a;
+      });
+    };
+    exports2.updateLast = updateLast;
+    exports2.intercalate = RNEA.intercalate;
+    exports2.chain = exports2.flatMap;
+    function groupSort(O) {
+      var sortO = (0, exports2.sort)(O);
+      var groupO = group(O);
+      return function(as) {
+        return (0, exports2.isNonEmpty)(as) ? groupO(sortO(as)) : [];
+      };
+    }
+    exports2.groupSort = groupSort;
+    function filter(predicate) {
+      return (0, exports2.filterWithIndex)(function(_2, a) {
+        return predicate(a);
+      });
+    }
+    exports2.filter = filter;
+    var filterWithIndex = function(predicate) {
+      return function(as) {
+        return (0, exports2.fromArray)(as.filter(function(a, i) {
+          return predicate(i, a);
+        }));
+      };
+    };
+    exports2.filterWithIndex = filterWithIndex;
+    exports2.uncons = exports2.unprepend;
+    exports2.unsnoc = exports2.unappend;
+    function cons(head, tail2) {
+      return tail2 === void 0 ? (0, exports2.prepend)(head) : (0, function_1.pipe)(tail2, (0, exports2.prepend)(head));
+    }
+    exports2.cons = cons;
+    var snoc = function(init2, end) {
+      return (0, function_1.pipe)(init2, (0, exports2.append)(end));
+    };
+    exports2.snoc = snoc;
+    exports2.prependToAll = exports2.prependAll;
+    exports2.fold = RNEA.concatAll;
+    exports2.nonEmptyArray = {
+      URI: exports2.URI,
+      of: exports2.of,
+      map: _map,
+      mapWithIndex: _mapWithIndex,
+      ap: _ap,
+      chain: exports2.flatMap,
+      extend: _extend,
+      extract: exports2.extract,
+      reduce: _reduce,
+      foldMap: _foldMap,
+      reduceRight: _reduceRight,
+      traverse: _traverse,
+      sequence: exports2.sequence,
+      reduceWithIndex: _reduceWithIndex,
+      foldMapWithIndex: _foldMapWithIndex,
+      reduceRightWithIndex: _reduceRightWithIndex,
+      traverseWithIndex: _traverseWithIndex,
+      alt: _alt
+    };
+  })(NonEmptyArray.__exports);
+  return NonEmptyArray.__exports;
+}
+exports.__require = requireNonEmptyArray;
+//# sourceMappingURL=NonEmptyArray.cjs.map