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

@@ -0,0 +1,807 @@
+import { commonjsGlobal } from "../../../_virtual/_commonjsHelpers.js";
+import { __exports as ReadonlyNonEmptyArray } from "../../../_virtual/ReadonlyNonEmptyArray.js";
+import { __require as requireApply } from "./Apply.js";
+import { __require as requireChain } from "./Chain.js";
+import { __require as requireEq } from "./Eq.js";
+import { __require as require_function } from "./function.js";
+import { __require as requireFunctor } from "./Functor.js";
+import { __require as requireInternal } from "./internal.js";
+import { __require as requireOrd } from "./Ord.js";
+import { __require as requireSemigroup } from "./Semigroup.js";
+var hasRequiredReadonlyNonEmptyArray;
+function requireReadonlyNonEmptyArray() {
+  if (hasRequiredReadonlyNonEmptyArray)
+    return ReadonlyNonEmptyArray;
+  hasRequiredReadonlyNonEmptyArray = 1;
+  (function(exports) {
+    var __createBinding = commonjsGlobal && 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 = commonjsGlobal && commonjsGlobal.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = commonjsGlobal && 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 = commonjsGlobal && 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(exports, "__esModule", { value: true });
+    exports.reduceRight = exports.foldMap = exports.reduce = exports.mapWithIndex = exports.map = exports.flatten = exports.duplicate = exports.extend = exports.flatMap = exports.ap = exports.alt = exports.altW = exports.of = exports.chunksOf = exports.splitAt = exports.chop = exports.chainWithIndex = exports.intersperse = exports.prependAll = exports.unzip = exports.zip = exports.zipWith = exports.modifyAt = exports.updateAt = exports.sort = exports.groupBy = exports.group = exports.reverse = exports.concat = exports.concatW = exports.fromArray = exports.unappend = exports.unprepend = exports.range = exports.replicate = exports.makeBy = exports.fromReadonlyArray = exports.rotate = exports.union = exports.sortBy = exports.uniq = exports.unsafeUpdateAt = exports.unsafeInsertAt = exports.append = exports.appendW = exports.prepend = exports.prependW = exports.isOutOfBound = exports.isNonEmpty = exports.empty = void 0;
+    exports.groupSort = exports.chain = exports.intercalate = exports.updateLast = exports.modifyLast = exports.updateHead = exports.modifyHead = exports.matchRight = exports.matchLeft = exports.concatAll = exports.max = exports.min = exports.init = exports.last = exports.tail = exports.head = exports.apS = exports.bind = exports.let = exports.bindTo = exports.Do = exports.Comonad = exports.Alt = exports.TraversableWithIndex = exports.Traversable = exports.FoldableWithIndex = exports.Foldable = exports.Monad = exports.chainFirst = exports.Chain = exports.Applicative = exports.apSecond = exports.apFirst = exports.Apply = exports.FunctorWithIndex = exports.Pointed = exports.flap = exports.Functor = exports.getUnionSemigroup = exports.getEq = exports.getSemigroup = exports.getShow = exports.URI = exports.extract = exports.traverseWithIndex = exports.sequence = exports.traverse = exports.reduceRightWithIndex = exports.foldMapWithIndex = exports.reduceWithIndex = void 0;
+    exports.readonlyNonEmptyArray = exports.fold = exports.prependToAll = exports.insertAt = exports.snoc = exports.cons = exports.unsnoc = exports.uncons = exports.filterWithIndex = exports.filter = void 0;
+    var Apply_1 = requireApply();
+    var Chain_1 = requireChain();
+    var Eq_1 = requireEq();
+    var function_1 = require_function();
+    var Functor_1 = requireFunctor();
+    var _ = __importStar(requireInternal());
+    var Ord_1 = requireOrd();
+    var Se = __importStar(requireSemigroup());
+    exports.empty = _.emptyReadonlyArray;
+    exports.isNonEmpty = _.isNonEmpty;
+    var isOutOfBound = function(i, as) {
+      return i < 0 || i >= as.length;
+    };
+    exports.isOutOfBound = isOutOfBound;
+    var prependW = function(head) {
+      return function(tail) {
+        return __spreadArray([head], tail, true);
+      };
+    };
+    exports.prependW = prependW;
+    exports.prepend = exports.prependW;
+    var appendW = function(end) {
+      return function(init2) {
+        return __spreadArray(__spreadArray([], init2, true), [end], false);
+      };
+    };
+    exports.appendW = appendW;
+    exports.append = exports.appendW;
+    var unsafeInsertAt = function(i, a, as) {
+      if ((0, exports.isNonEmpty)(as)) {
+        var xs = _.fromReadonlyNonEmptyArray(as);
+        xs.splice(i, 0, a);
+        return xs;
+      }
+      return [a];
+    };
+    exports.unsafeInsertAt = unsafeInsertAt;
+    var unsafeUpdateAt = function(i, a, as) {
+      if (as[i] === a) {
+        return as;
+      } else {
+        var xs = _.fromReadonlyNonEmptyArray(as);
+        xs[i] = a;
+        return xs;
+      }
+    };
+    exports.unsafeUpdateAt = unsafeUpdateAt;
+    var uniq = function(E) {
+      return function(as) {
+        if (as.length === 1) {
+          return as;
+        }
+        var out = [(0, exports.head)(as)];
+        var rest = (0, exports.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;
+      };
+    };
+    exports.uniq = uniq;
+    var sortBy = function(ords) {
+      if ((0, exports.isNonEmpty)(ords)) {
+        var M = (0, Ord_1.getMonoid)();
+        return (0, exports.sort)(ords.reduce(M.concat, M.empty));
+      }
+      return function_1.identity;
+    };
+    exports.sortBy = sortBy;
+    var union = function(E) {
+      var uniqE = (0, exports.uniq)(E);
+      return function(second) {
+        return function(first) {
+          return uniqE((0, function_1.pipe)(first, concat(second)));
+        };
+      };
+    };
+    exports.union = union;
+    var rotate = function(n) {
+      return function(as) {
+        var len = as.length;
+        var m = Math.round(n) % len;
+        if ((0, exports.isOutOfBound)(Math.abs(m), as) || m === 0) {
+          return as;
+        }
+        if (m < 0) {
+          var _a = (0, exports.splitAt)(-m)(as), f = _a[0], s = _a[1];
+          return (0, function_1.pipe)(s, concat(f));
+        } else {
+          return (0, exports.rotate)(m - len)(as);
+        }
+      };
+    };
+    exports.rotate = rotate;
+    var fromReadonlyArray = function(as) {
+      return (0, exports.isNonEmpty)(as) ? _.some(as) : _.none;
+    };
+    exports.fromReadonlyArray = fromReadonlyArray;
+    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;
+      };
+    };
+    exports.makeBy = makeBy;
+    var replicate = function(a) {
+      return (0, exports.makeBy)(function() {
+        return a;
+      });
+    };
+    exports.replicate = replicate;
+    var range = function(start, end) {
+      return start <= end ? (0, exports.makeBy)(function(i) {
+        return start + i;
+      })(end - start + 1) : [start];
+    };
+    exports.range = range;
+    var unprepend = function(as) {
+      return [(0, exports.head)(as), (0, exports.tail)(as)];
+    };
+    exports.unprepend = unprepend;
+    var unappend = function(as) {
+      return [(0, exports.init)(as), (0, exports.last)(as)];
+    };
+    exports.unappend = unappend;
+    var fromArray = function(as) {
+      return (0, exports.fromReadonlyArray)(as.slice());
+    };
+    exports.fromArray = fromArray;
+    function concatW(second) {
+      return function(first) {
+        return first.concat(second);
+      };
+    }
+    exports.concatW = concatW;
+    function concat(x, y) {
+      return y ? x.concat(y) : function(y2) {
+        return y2.concat(x);
+      };
+    }
+    exports.concat = concat;
+    var reverse = function(as) {
+      return as.length === 1 ? as : __spreadArray([(0, exports.last)(as)], as.slice(0, -1).reverse(), true);
+    };
+    exports.reverse = reverse;
+    function group(E) {
+      return function(as) {
+        var len = as.length;
+        if (len === 0) {
+          return exports.empty;
+        }
+        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;
+      };
+    }
+    exports.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;
+      };
+    };
+    exports.groupBy = groupBy;
+    var sort = function(O) {
+      return function(as) {
+        return as.length === 1 ? as : as.slice().sort(O.compare);
+      };
+    };
+    exports.sort = sort;
+    var updateAt = function(i, a) {
+      return (0, exports.modifyAt)(i, function() {
+        return a;
+      });
+    };
+    exports.updateAt = updateAt;
+    var modifyAt = function(i, f) {
+      return function(as) {
+        return (0, exports.isOutOfBound)(i, as) ? _.none : _.some((0, exports.unsafeUpdateAt)(i, f(as[i]), as));
+      };
+    };
+    exports.modifyAt = modifyAt;
+    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;
+    };
+    exports.zipWith = zipWith;
+    function zip(as, bs) {
+      if (bs === void 0) {
+        return function(bs2) {
+          return zip(bs2, as);
+        };
+      }
+      return (0, exports.zipWith)(as, bs, function(a, b) {
+        return [a, b];
+      });
+    }
+    exports.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];
+    };
+    exports.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;
+      };
+    };
+    exports.prependAll = prependAll;
+    var intersperse = function(middle) {
+      return function(as) {
+        var rest = (0, exports.tail)(as);
+        return (0, exports.isNonEmpty)(rest) ? (0, function_1.pipe)(rest, (0, exports.prependAll)(middle), (0, exports.prepend)((0, exports.head)(as))) : as;
+      };
+    };
+    exports.intersperse = intersperse;
+    var chainWithIndex = function(f) {
+      return function(as) {
+        var out = _.fromReadonlyNonEmptyArray(f(0, (0, exports.head)(as)));
+        for (var i = 1; i < as.length; i++) {
+          out.push.apply(out, f(i, as[i]));
+        }
+        return out;
+      };
+    };
+    exports.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, exports.isNonEmpty)(next)) {
+          var _b = f(next), b_1 = _b[0], rest_2 = _b[1];
+          out.push(b_1);
+          next = rest_2;
+        }
+        return out;
+      };
+    };
+    exports.chop = chop;
+    var splitAt = function(n) {
+      return function(as) {
+        var m = Math.max(1, n);
+        return m >= as.length ? [as, exports.empty] : [(0, function_1.pipe)(as.slice(1, m), (0, exports.prepend)((0, exports.head)(as))), as.slice(m)];
+      };
+    };
+    exports.splitAt = splitAt;
+    var chunksOf = function(n) {
+      return (0, exports.chop)((0, exports.splitAt)(n));
+    };
+    exports.chunksOf = chunksOf;
+    var _map = function(fa, f) {
+      return (0, function_1.pipe)(fa, (0, exports.map)(f));
+    };
+    var _mapWithIndex = function(fa, f) {
+      return (0, function_1.pipe)(fa, (0, exports.mapWithIndex)(f));
+    };
+    var _ap = function(fab, fa) {
+      return (0, function_1.pipe)(fab, (0, exports.ap)(fa));
+    };
+    var _extend = function(wa, f) {
+      return (0, function_1.pipe)(wa, (0, exports.extend)(f));
+    };
+    var _reduce = function(fa, b, f) {
+      return (0, function_1.pipe)(fa, (0, exports.reduce)(b, f));
+    };
+    var _foldMap = function(M) {
+      var foldMapM = (0, exports.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, exports.reduceRight)(b, f));
+    };
+    var _traverse = function(F) {
+      var traverseF = (0, exports.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, exports.alt)(that));
+    };
+    var _reduceWithIndex = function(fa, b, f) {
+      return (0, function_1.pipe)(fa, (0, exports.reduceWithIndex)(b, f));
+    };
+    var _foldMapWithIndex = function(M) {
+      var foldMapWithIndexM = (0, exports.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, exports.reduceRightWithIndex)(b, f));
+    };
+    var _traverseWithIndex = function(F) {
+      var traverseWithIndexF = (0, exports.traverseWithIndex)(F);
+      return function(ta, f) {
+        return (0, function_1.pipe)(ta, traverseWithIndexF(f));
+      };
+    };
+    exports.of = _.singleton;
+    var altW = function(that) {
+      return function(as) {
+        return (0, function_1.pipe)(as, concatW(that()));
+      };
+    };
+    exports.altW = altW;
+    exports.alt = exports.altW;
+    var ap = function(as) {
+      return (0, exports.flatMap)(function(f) {
+        return (0, function_1.pipe)(as, (0, exports.map)(f));
+      });
+    };
+    exports.ap = ap;
+    exports.flatMap = (0, function_1.dual)(2, function(ma, f) {
+      return (0, function_1.pipe)(ma, (0, exports.chainWithIndex)(function(i, a) {
+        return f(a, i);
+      }));
+    });
+    var extend = function(f) {
+      return function(as) {
+        var next = (0, exports.tail)(as);
+        var out = [f(as)];
+        while ((0, exports.isNonEmpty)(next)) {
+          out.push(f(next));
+          next = (0, exports.tail)(next);
+        }
+        return out;
+      };
+    };
+    exports.extend = extend;
+    exports.duplicate = /* @__PURE__ */ (0, exports.extend)(function_1.identity);
+    exports.flatten = /* @__PURE__ */ (0, exports.flatMap)(function_1.identity);
+    var map = function(f) {
+      return (0, exports.mapWithIndex)(function(_2, a) {
+        return f(a);
+      });
+    };
+    exports.map = map;
+    var mapWithIndex = function(f) {
+      return function(as) {
+        var out = [f(0, (0, exports.head)(as))];
+        for (var i = 1; i < as.length; i++) {
+          out.push(f(i, as[i]));
+        }
+        return out;
+      };
+    };
+    exports.mapWithIndex = mapWithIndex;
+    var reduce = function(b, f) {
+      return (0, exports.reduceWithIndex)(b, function(_2, b2, a) {
+        return f(b2, a);
+      });
+    };
+    exports.reduce = reduce;
+    var foldMap = function(S) {
+      return function(f) {
+        return function(as) {
+          return as.slice(1).reduce(function(s, a) {
+            return S.concat(s, f(a));
+          }, f(as[0]));
+        };
+      };
+    };
+    exports.foldMap = foldMap;
+    var reduceRight = function(b, f) {
+      return (0, exports.reduceRightWithIndex)(b, function(_2, b2, a) {
+        return f(b2, a);
+      });
+    };
+    exports.reduceRight = reduceRight;
+    var reduceWithIndex = function(b, f) {
+      return function(as) {
+        return as.reduce(function(b2, a, i) {
+          return f(i, b2, a);
+        }, b);
+      };
+    };
+    exports.reduceWithIndex = reduceWithIndex;
+    var foldMapWithIndex = function(S) {
+      return function(f) {
+        return function(as) {
+          return as.slice(1).reduce(function(s, a, i) {
+            return S.concat(s, f(i + 1, a));
+          }, f(0, as[0]));
+        };
+      };
+    };
+    exports.foldMapWithIndex = foldMapWithIndex;
+    var reduceRightWithIndex = function(b, f) {
+      return function(as) {
+        return as.reduceRight(function(b2, a, i) {
+          return f(i, a, b2);
+        }, b);
+      };
+    };
+    exports.reduceRightWithIndex = reduceRightWithIndex;
+    var traverse = function(F) {
+      var traverseWithIndexF = (0, exports.traverseWithIndex)(F);
+      return function(f) {
+        return traverseWithIndexF(function(_2, a) {
+          return f(a);
+        });
+      };
+    };
+    exports.traverse = traverse;
+    var sequence = function(F) {
+      return (0, exports.traverseWithIndex)(F)(function_1.SK);
+    };
+    exports.sequence = sequence;
+    var traverseWithIndex = function(F) {
+      return function(f) {
+        return function(as) {
+          var out = F.map(f(0, (0, exports.head)(as)), exports.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, exports.append)(b));
+              };
+            }), f(i, as[i]));
+          }
+          return out;
+        };
+      };
+    };
+    exports.traverseWithIndex = traverseWithIndex;
+    exports.extract = _.head;
+    exports.URI = "ReadonlyNonEmptyArray";
+    var getShow = function(S) {
+      return {
+        show: function(as) {
+          return "[".concat(as.map(S.show).join(", "), "]");
+        }
+      };
+    };
+    exports.getShow = getShow;
+    var getSemigroup = function() {
+      return {
+        concat
+      };
+    };
+    exports.getSemigroup = getSemigroup;
+    var getEq = function(E) {
+      return (0, Eq_1.fromEquals)(function(xs, ys) {
+        return xs.length === ys.length && xs.every(function(x, i) {
+          return E.equals(x, ys[i]);
+        });
+      });
+    };
+    exports.getEq = getEq;
+    var getUnionSemigroup = function(E) {
+      var unionE = (0, exports.union)(E);
+      return {
+        concat: function(first, second) {
+          return unionE(second)(first);
+        }
+      };
+    };
+    exports.getUnionSemigroup = getUnionSemigroup;
+    exports.Functor = {
+      URI: exports.URI,
+      map: _map
+    };
+    exports.flap = (0, Functor_1.flap)(exports.Functor);
+    exports.Pointed = {
+      URI: exports.URI,
+      of: exports.of
+    };
+    exports.FunctorWithIndex = {
+      URI: exports.URI,
+      map: _map,
+      mapWithIndex: _mapWithIndex
+    };
+    exports.Apply = {
+      URI: exports.URI,
+      map: _map,
+      ap: _ap
+    };
+    exports.apFirst = (0, Apply_1.apFirst)(exports.Apply);
+    exports.apSecond = (0, Apply_1.apSecond)(exports.Apply);
+    exports.Applicative = {
+      URI: exports.URI,
+      map: _map,
+      ap: _ap,
+      of: exports.of
+    };
+    exports.Chain = {
+      URI: exports.URI,
+      map: _map,
+      ap: _ap,
+      chain: exports.flatMap
+    };
+    exports.chainFirst = (0, Chain_1.chainFirst)(exports.Chain);
+    exports.Monad = {
+      URI: exports.URI,
+      map: _map,
+      ap: _ap,
+      of: exports.of,
+      chain: exports.flatMap
+    };
+    exports.Foldable = {
+      URI: exports.URI,
+      reduce: _reduce,
+      foldMap: _foldMap,
+      reduceRight: _reduceRight
+    };
+    exports.FoldableWithIndex = {
+      URI: exports.URI,
+      reduce: _reduce,
+      foldMap: _foldMap,
+      reduceRight: _reduceRight,
+      reduceWithIndex: _reduceWithIndex,
+      foldMapWithIndex: _foldMapWithIndex,
+      reduceRightWithIndex: _reduceRightWithIndex
+    };
+    exports.Traversable = {
+      URI: exports.URI,
+      map: _map,
+      reduce: _reduce,
+      foldMap: _foldMap,
+      reduceRight: _reduceRight,
+      traverse: _traverse,
+      sequence: exports.sequence
+    };
+    exports.TraversableWithIndex = {
+      URI: exports.URI,
+      map: _map,
+      mapWithIndex: _mapWithIndex,
+      reduce: _reduce,
+      foldMap: _foldMap,
+      reduceRight: _reduceRight,
+      traverse: _traverse,
+      sequence: exports.sequence,
+      reduceWithIndex: _reduceWithIndex,
+      foldMapWithIndex: _foldMapWithIndex,
+      reduceRightWithIndex: _reduceRightWithIndex,
+      traverseWithIndex: _traverseWithIndex
+    };
+    exports.Alt = {
+      URI: exports.URI,
+      map: _map,
+      alt: _alt
+    };
+    exports.Comonad = {
+      URI: exports.URI,
+      map: _map,
+      extend: _extend,
+      extract: exports.extract
+    };
+    exports.Do = (0, exports.of)(_.emptyRecord);
+    exports.bindTo = (0, Functor_1.bindTo)(exports.Functor);
+    var let_ = /* @__PURE__ */ (0, Functor_1.let)(exports.Functor);
+    exports.let = let_;
+    exports.bind = (0, Chain_1.bind)(exports.Chain);
+    exports.apS = (0, Apply_1.apS)(exports.Apply);
+    exports.head = exports.extract;
+    exports.tail = _.tail;
+    var last = function(as) {
+      return as[as.length - 1];
+    };
+    exports.last = last;
+    var init = function(as) {
+      return as.slice(0, -1);
+    };
+    exports.init = init;
+    var min = function(O) {
+      var S = Se.min(O);
+      return function(as) {
+        return as.reduce(S.concat);
+      };
+    };
+    exports.min = min;
+    var max = function(O) {
+      var S = Se.max(O);
+      return function(as) {
+        return as.reduce(S.concat);
+      };
+    };
+    exports.max = max;
+    var concatAll = function(S) {
+      return function(as) {
+        return as.reduce(S.concat);
+      };
+    };
+    exports.concatAll = concatAll;
+    var matchLeft = function(f) {
+      return function(as) {
+        return f((0, exports.head)(as), (0, exports.tail)(as));
+      };
+    };
+    exports.matchLeft = matchLeft;
+    var matchRight = function(f) {
+      return function(as) {
+        return f((0, exports.init)(as), (0, exports.last)(as));
+      };
+    };
+    exports.matchRight = matchRight;
+    var modifyHead = function(f) {
+      return function(as) {
+        return __spreadArray([f((0, exports.head)(as))], (0, exports.tail)(as), true);
+      };
+    };
+    exports.modifyHead = modifyHead;
+    var updateHead = function(a) {
+      return (0, exports.modifyHead)(function() {
+        return a;
+      });
+    };
+    exports.updateHead = updateHead;
+    var modifyLast = function(f) {
+      return function(as) {
+        return (0, function_1.pipe)((0, exports.init)(as), (0, exports.append)(f((0, exports.last)(as))));
+      };
+    };
+    exports.modifyLast = modifyLast;
+    var updateLast = function(a) {
+      return (0, exports.modifyLast)(function() {
+        return a;
+      });
+    };
+    exports.updateLast = updateLast;
+    var intercalate = function(S) {
+      var concatAllS = (0, exports.concatAll)(S);
+      return function(middle) {
+        return (0, function_1.flow)((0, exports.intersperse)(middle), concatAllS);
+      };
+    };
+    exports.intercalate = intercalate;
+    exports.chain = exports.flatMap;
+    function groupSort(O) {
+      var sortO = (0, exports.sort)(O);
+      var groupO = group(O);
+      return function(as) {
+        return (0, exports.isNonEmpty)(as) ? groupO(sortO(as)) : exports.empty;
+      };
+    }
+    exports.groupSort = groupSort;
+    function filter(predicate) {
+      return (0, exports.filterWithIndex)(function(_2, a) {
+        return predicate(a);
+      });
+    }
+    exports.filter = filter;
+    var filterWithIndex = function(predicate) {
+      return function(as) {
+        return (0, exports.fromReadonlyArray)(as.filter(function(a, i) {
+          return predicate(i, a);
+        }));
+      };
+    };
+    exports.filterWithIndex = filterWithIndex;
+    exports.uncons = exports.unprepend;
+    exports.unsnoc = exports.unappend;
+    function cons(head, tail) {
+      return tail === void 0 ? (0, exports.prepend)(head) : (0, function_1.pipe)(tail, (0, exports.prepend)(head));
+    }
+    exports.cons = cons;
+    var snoc = function(init2, end) {
+      return (0, function_1.pipe)(init2, concat([end]));
+    };
+    exports.snoc = snoc;
+    var insertAt = function(i, a) {
+      return function(as) {
+        return i < 0 || i > as.length ? _.none : _.some((0, exports.unsafeInsertAt)(i, a, as));
+      };
+    };
+    exports.insertAt = insertAt;
+    exports.prependToAll = exports.prependAll;
+    exports.fold = exports.concatAll;
+    exports.readonlyNonEmptyArray = {
+      URI: exports.URI,
+      of: exports.of,
+      map: _map,
+      mapWithIndex: _mapWithIndex,
+      ap: _ap,
+      chain: exports.flatMap,
+      extend: _extend,
+      extract: exports.extract,
+      reduce: _reduce,
+      foldMap: _foldMap,
+      reduceRight: _reduceRight,
+      traverse: _traverse,
+      sequence: exports.sequence,
+      reduceWithIndex: _reduceWithIndex,
+      foldMapWithIndex: _foldMapWithIndex,
+      reduceRightWithIndex: _reduceRightWithIndex,
+      traverseWithIndex: _traverseWithIndex,
+      alt: _alt
+    };
+  })(ReadonlyNonEmptyArray);
+  return ReadonlyNonEmptyArray;
+}
+export {
+  requireReadonlyNonEmptyArray as __require
+};
+//# sourceMappingURL=ReadonlyNonEmptyArray.js.map