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

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

@@ -0,0 +1,727 @@
+import { apFirst as apFirst$1, apSecond as apSecond$1, apS as apS$1 } from "./Apply.js";
+import { chainFirst as chainFirst$1, bind as bind$1 } from "./Chain.js";
+import { pipe, dual, identity } from "./function.js";
+import { flap as flap$1, bindTo as bindTo$1, let as let_$1 } from "./Functor.js";
+import { fromReadonlyNonEmptyArray as fromReadonlyNonEmptyArray$1, some, none, has, emptyRecord } from "./internal.js";
+import { getMonoid } from "./Ord.js";
+import { foldMapWithIndex as foldMapWithIndex$1, foldMap as foldMap$1, reduce as reduce$1, reduceWithIndex as reduceWithIndex$1, reduceRight as reduceRight$1, reduceRightWithIndex as reduceRightWithIndex$1, head as head$1, getShow as getShow$1, getEq as getEq$1, last as last$1, min as min$1, max as max$1, intercalate as intercalate$1, concatAll as concatAll$1 } from "./ReadonlyNonEmptyArray.js";
+var __spreadArray = globalThis && globalThis.__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));
+};
+var isNonEmpty = function(as) {
+  return as.length > 0;
+};
+var isOutOfBound = function(i, as) {
+  return i < 0 || i >= as.length;
+};
+var prependW = function(head2) {
+  return function(tail2) {
+    return __spreadArray([head2], tail2, true);
+  };
+};
+var prepend = prependW;
+var appendW = function(end) {
+  return function(init2) {
+    return __spreadArray(__spreadArray([], init2, true), [end], false);
+  };
+};
+var append = appendW;
+var unsafeInsertAt = function(i, a, as) {
+  if (isNonEmpty(as)) {
+    var xs = fromReadonlyNonEmptyArray(as);
+    xs.splice(i, 0, a);
+    return xs;
+  }
+  return [a];
+};
+var unsafeUpdateAt = function(i, a, as) {
+  var xs = fromReadonlyNonEmptyArray(as);
+  xs[i] = a;
+  return xs;
+};
+var uniq = function(E) {
+  return function(as) {
+    if (as.length === 1) {
+      return copy(as);
+    }
+    var out = [head(as)];
+    var rest = 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;
+  };
+};
+var sortBy = function(ords) {
+  if (isNonEmpty(ords)) {
+    var M = getMonoid();
+    return sort(ords.reduce(M.concat, M.empty));
+  }
+  return copy;
+};
+var union = function(E) {
+  var uniqE = uniq(E);
+  return function(second) {
+    return function(first) {
+      return uniqE(pipe(first, concat(second)));
+    };
+  };
+};
+var rotate = function(n) {
+  return function(as) {
+    var len = as.length;
+    var m = Math.round(n) % len;
+    if (isOutOfBound(Math.abs(m), as) || m === 0) {
+      return copy(as);
+    }
+    if (m < 0) {
+      var _a = splitAt(-m)(as), f = _a[0], s = _a[1];
+      return pipe(s, concat(f));
+    } else {
+      return rotate(m - len)(as);
+    }
+  };
+};
+var fromReadonlyNonEmptyArray = fromReadonlyNonEmptyArray$1;
+var fromArray = function(as) {
+  return isNonEmpty(as) ? some(as) : none;
+};
+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;
+  };
+};
+var replicate = function(a) {
+  return makeBy(function() {
+    return a;
+  });
+};
+var range = function(start, end) {
+  return start <= end ? makeBy(function(i) {
+    return start + i;
+  })(end - start + 1) : [start];
+};
+var unprepend = function(as) {
+  return [head(as), tail(as)];
+};
+var unappend = function(as) {
+  return [init(as), last(as)];
+};
+function concatW(second) {
+  return function(first) {
+    return first.concat(second);
+  };
+}
+function concat(x, y) {
+  return y ? x.concat(y) : function(y2) {
+    return y2.concat(x);
+  };
+}
+var reverse = function(as) {
+  return __spreadArray([last(as)], as.slice(0, -1).reverse(), true);
+};
+function group(E) {
+  return function(as) {
+    var len = as.length;
+    if (len === 0) {
+      return [];
+    }
+    var out = [];
+    var head2 = as[0];
+    var nea = [head2];
+    for (var i = 1; i < len; i++) {
+      var a = as[i];
+      if (E.equals(a, head2)) {
+        nea.push(a);
+      } else {
+        out.push(nea);
+        head2 = a;
+        nea = [head2];
+      }
+    }
+    out.push(nea);
+    return out;
+  };
+}
+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;
+  };
+};
+var sort = function(O) {
+  return function(as) {
+    return as.slice().sort(O.compare);
+  };
+};
+var insertAt = function(i, a) {
+  return function(as) {
+    return i < 0 || i > as.length ? none : some(unsafeInsertAt(i, a, as));
+  };
+};
+var updateAt = function(i, a) {
+  return modifyAt(i, function() {
+    return a;
+  });
+};
+var modifyAt = function(i, f) {
+  return function(as) {
+    return isOutOfBound(i, as) ? none : some(unsafeUpdateAt(i, f(as[i]), as));
+  };
+};
+var copy = fromReadonlyNonEmptyArray;
+var of = function(a) {
+  return [a];
+};
+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;
+};
+function zip(as, bs) {
+  if (bs === void 0) {
+    return function(bs2) {
+      return zip(bs2, as);
+    };
+  }
+  return zipWith(as, bs, function(a, b) {
+    return [a, b];
+  });
+}
+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];
+};
+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;
+  };
+};
+var intersperse = function(middle) {
+  return function(as) {
+    var rest = tail(as);
+    return isNonEmpty(rest) ? pipe(rest, prependAll(middle), prepend(head(as))) : copy(as);
+  };
+};
+var foldMapWithIndex = foldMapWithIndex$1;
+var foldMap = foldMap$1;
+var chainWithIndex = function(f) {
+  return function(as) {
+    var out = fromReadonlyNonEmptyArray(f(0, head(as)));
+    for (var i = 1; i < as.length; i++) {
+      out.push.apply(out, f(i, as[i]));
+    }
+    return out;
+  };
+};
+var chop = function(f) {
+  return function(as) {
+    var _a = f(as), b = _a[0], rest = _a[1];
+    var out = [b];
+    var next = rest;
+    while (isNonEmpty(next)) {
+      var _b = f(next), b_1 = _b[0], rest_2 = _b[1];
+      out.push(b_1);
+      next = rest_2;
+    }
+    return out;
+  };
+};
+var splitAt = function(n) {
+  return function(as) {
+    var m = Math.max(1, n);
+    return m >= as.length ? [copy(as), []] : [pipe(as.slice(1, m), prepend(head(as))), as.slice(m)];
+  };
+};
+var chunksOf = function(n) {
+  return chop(splitAt(n));
+};
+var _map = function(fa, f) {
+  return pipe(fa, map(f));
+};
+var _mapWithIndex = function(fa, f) {
+  return pipe(fa, mapWithIndex(f));
+};
+var _ap = function(fab, fa) {
+  return pipe(fab, ap(fa));
+};
+var _extend = function(wa, f) {
+  return pipe(wa, extend(f));
+};
+var _reduce = function(fa, b, f) {
+  return pipe(fa, reduce(b, f));
+};
+var _foldMap = function(M) {
+  var foldMapM = foldMap(M);
+  return function(fa, f) {
+    return pipe(fa, foldMapM(f));
+  };
+};
+var _reduceRight = function(fa, b, f) {
+  return pipe(fa, reduceRight(b, f));
+};
+var _traverse = function(F) {
+  var traverseF = traverse(F);
+  return function(ta, f) {
+    return pipe(ta, traverseF(f));
+  };
+};
+var _alt = function(fa, that) {
+  return pipe(fa, alt(that));
+};
+var _reduceWithIndex = function(fa, b, f) {
+  return pipe(fa, reduceWithIndex(b, f));
+};
+var _foldMapWithIndex = function(M) {
+  var foldMapWithIndexM = foldMapWithIndex(M);
+  return function(fa, f) {
+    return pipe(fa, foldMapWithIndexM(f));
+  };
+};
+var _reduceRightWithIndex = function(fa, b, f) {
+  return pipe(fa, reduceRightWithIndex(b, f));
+};
+var _traverseWithIndex = function(F) {
+  var traverseWithIndexF = traverseWithIndex(F);
+  return function(ta, f) {
+    return pipe(ta, traverseWithIndexF(f));
+  };
+};
+var altW = function(that) {
+  return function(as) {
+    return pipe(as, concatW(that()));
+  };
+};
+var alt = altW;
+var ap = function(as) {
+  return flatMap(function(f) {
+    return pipe(as, map(f));
+  });
+};
+var flatMap = /* @__PURE__ */ dual(2, function(ma, f) {
+  return pipe(ma, chainWithIndex(function(i, a) {
+    return f(a, i);
+  }));
+});
+var extend = function(f) {
+  return function(as) {
+    var next = tail(as);
+    var out = [f(as)];
+    while (isNonEmpty(next)) {
+      out.push(f(next));
+      next = tail(next);
+    }
+    return out;
+  };
+};
+var duplicate = /* @__PURE__ */ extend(identity);
+var flatten = /* @__PURE__ */ flatMap(identity);
+var map = function(f) {
+  return mapWithIndex(function(_, a) {
+    return f(a);
+  });
+};
+var mapWithIndex = function(f) {
+  return function(as) {
+    var out = [f(0, head(as))];
+    for (var i = 1; i < as.length; i++) {
+      out.push(f(i, as[i]));
+    }
+    return out;
+  };
+};
+var reduce = reduce$1;
+var reduceWithIndex = reduceWithIndex$1;
+var reduceRight = reduceRight$1;
+var reduceRightWithIndex = reduceRightWithIndex$1;
+var traverse = function(F) {
+  var traverseWithIndexF = traverseWithIndex(F);
+  return function(f) {
+    return traverseWithIndexF(function(_, a) {
+      return f(a);
+    });
+  };
+};
+var sequence = function(F) {
+  return traverseWithIndex(F)(function(_, a) {
+    return a;
+  });
+};
+var traverseWithIndex = function(F) {
+  return function(f) {
+    return function(as) {
+      var out = F.map(f(0, head(as)), of);
+      for (var i = 1; i < as.length; i++) {
+        out = F.ap(F.map(out, function(bs) {
+          return function(b) {
+            return pipe(bs, append(b));
+          };
+        }), f(i, as[i]));
+      }
+      return out;
+    };
+  };
+};
+var extract = head$1;
+var URI = "NonEmptyArray";
+var getShow = getShow$1;
+var getSemigroup = function() {
+  return {
+    concat
+  };
+};
+var getEq = getEq$1;
+var getUnionSemigroup = function(E) {
+  var unionE = union(E);
+  return {
+    concat: function(first, second) {
+      return unionE(second)(first);
+    }
+  };
+};
+var Functor = {
+  URI,
+  map: _map
+};
+var flap = /* @__PURE__ */ flap$1(Functor);
+var Pointed = {
+  URI,
+  of
+};
+var FunctorWithIndex = {
+  URI,
+  map: _map,
+  mapWithIndex: _mapWithIndex
+};
+var Apply = {
+  URI,
+  map: _map,
+  ap: _ap
+};
+var apFirst = /* @__PURE__ */ apFirst$1(Apply);
+var apSecond = /* @__PURE__ */ apSecond$1(Apply);
+var Applicative = {
+  URI,
+  map: _map,
+  ap: _ap,
+  of
+};
+var Chain = {
+  URI,
+  map: _map,
+  ap: _ap,
+  chain: flatMap
+};
+var chainFirst = /* @__PURE__ */ chainFirst$1(Chain);
+var Monad = {
+  URI,
+  map: _map,
+  ap: _ap,
+  of,
+  chain: flatMap
+};
+var Foldable = {
+  URI,
+  reduce: _reduce,
+  foldMap: _foldMap,
+  reduceRight: _reduceRight
+};
+var FoldableWithIndex = {
+  URI,
+  reduce: _reduce,
+  foldMap: _foldMap,
+  reduceRight: _reduceRight,
+  reduceWithIndex: _reduceWithIndex,
+  foldMapWithIndex: _foldMapWithIndex,
+  reduceRightWithIndex: _reduceRightWithIndex
+};
+var Traversable = {
+  URI,
+  map: _map,
+  reduce: _reduce,
+  foldMap: _foldMap,
+  reduceRight: _reduceRight,
+  traverse: _traverse,
+  sequence
+};
+var TraversableWithIndex = {
+  URI,
+  map: _map,
+  mapWithIndex: _mapWithIndex,
+  reduce: _reduce,
+  foldMap: _foldMap,
+  reduceRight: _reduceRight,
+  traverse: _traverse,
+  sequence,
+  reduceWithIndex: _reduceWithIndex,
+  foldMapWithIndex: _foldMapWithIndex,
+  reduceRightWithIndex: _reduceRightWithIndex,
+  traverseWithIndex: _traverseWithIndex
+};
+var Alt = {
+  URI,
+  map: _map,
+  alt: _alt
+};
+var Comonad = {
+  URI,
+  map: _map,
+  extend: _extend,
+  extract
+};
+var Do = /* @__PURE__ */ of(emptyRecord);
+var bindTo = /* @__PURE__ */ bindTo$1(Functor);
+var let_ = /* @__PURE__ */ let_$1(Functor);
+var bind = /* @__PURE__ */ bind$1(Chain);
+var apS = /* @__PURE__ */ apS$1(Apply);
+var head = head$1;
+var tail = function(as) {
+  return as.slice(1);
+};
+var last = last$1;
+var init = function(as) {
+  return as.slice(0, -1);
+};
+var min = min$1;
+var max = max$1;
+var concatAll = function(S) {
+  return function(as) {
+    return as.reduce(S.concat);
+  };
+};
+var matchLeft = function(f) {
+  return function(as) {
+    return f(head(as), tail(as));
+  };
+};
+var matchRight = function(f) {
+  return function(as) {
+    return f(init(as), last(as));
+  };
+};
+var modifyHead = function(f) {
+  return function(as) {
+    return __spreadArray([f(head(as))], tail(as), true);
+  };
+};
+var updateHead = function(a) {
+  return modifyHead(function() {
+    return a;
+  });
+};
+var modifyLast = function(f) {
+  return function(as) {
+    return pipe(init(as), append(f(last(as))));
+  };
+};
+var updateLast = function(a) {
+  return modifyLast(function() {
+    return a;
+  });
+};
+var intercalate = intercalate$1;
+var chain = flatMap;
+function groupSort(O) {
+  var sortO = sort(O);
+  var groupO = group(O);
+  return function(as) {
+    return isNonEmpty(as) ? groupO(sortO(as)) : [];
+  };
+}
+function filter(predicate) {
+  return filterWithIndex(function(_, a) {
+    return predicate(a);
+  });
+}
+var filterWithIndex = function(predicate) {
+  return function(as) {
+    return fromArray(as.filter(function(a, i) {
+      return predicate(i, a);
+    }));
+  };
+};
+var uncons = unprepend;
+var unsnoc = unappend;
+function cons(head2, tail2) {
+  return tail2 === void 0 ? prepend(head2) : pipe(tail2, prepend(head2));
+}
+var snoc = function(init2, end) {
+  return pipe(init2, append(end));
+};
+var prependToAll = prependAll;
+var fold = concatAll$1;
+var nonEmptyArray = {
+  URI,
+  of,
+  map: _map,
+  mapWithIndex: _mapWithIndex,
+  ap: _ap,
+  chain: flatMap,
+  extend: _extend,
+  extract,
+  reduce: _reduce,
+  foldMap: _foldMap,
+  reduceRight: _reduceRight,
+  traverse: _traverse,
+  sequence,
+  reduceWithIndex: _reduceWithIndex,
+  foldMapWithIndex: _foldMapWithIndex,
+  reduceRightWithIndex: _reduceRightWithIndex,
+  traverseWithIndex: _traverseWithIndex,
+  alt: _alt
+};
+export {
+  Alt,
+  Applicative,
+  Apply,
+  Chain,
+  Comonad,
+  Do,
+  Foldable,
+  FoldableWithIndex,
+  Functor,
+  FunctorWithIndex,
+  Monad,
+  Pointed,
+  Traversable,
+  TraversableWithIndex,
+  URI,
+  alt,
+  altW,
+  ap,
+  apFirst,
+  apS,
+  apSecond,
+  append,
+  appendW,
+  bind,
+  bindTo,
+  chain,
+  chainFirst,
+  chainWithIndex,
+  chop,
+  chunksOf,
+  concat,
+  concatAll,
+  concatW,
+  cons,
+  copy,
+  duplicate,
+  extend,
+  extract,
+  filter,
+  filterWithIndex,
+  flap,
+  flatMap,
+  flatten,
+  fold,
+  foldMap,
+  foldMapWithIndex,
+  fromArray,
+  fromReadonlyNonEmptyArray,
+  getEq,
+  getSemigroup,
+  getShow,
+  getUnionSemigroup,
+  group,
+  groupBy,
+  groupSort,
+  head,
+  init,
+  insertAt,
+  intercalate,
+  intersperse,
+  isNonEmpty,
+  isOutOfBound,
+  last,
+  let_ as let,
+  makeBy,
+  map,
+  mapWithIndex,
+  matchLeft,
+  matchRight,
+  max,
+  min,
+  modifyAt,
+  modifyHead,
+  modifyLast,
+  nonEmptyArray,
+  of,
+  prepend,
+  prependAll,
+  prependToAll,
+  prependW,
+  range,
+  reduce,
+  reduceRight,
+  reduceRightWithIndex,
+  reduceWithIndex,
+  replicate,
+  reverse,
+  rotate,
+  sequence,
+  snoc,
+  sort,
+  sortBy,
+  splitAt,
+  tail,
+  traverse,
+  traverseWithIndex,
+  unappend,
+  uncons,
+  union,
+  uniq,
+  unprepend,
+  unsafeInsertAt,
+  unsafeUpdateAt,
+  unsnoc,
+  unzip,
+  updateAt,
+  updateHead,
+  updateLast,
+  zip,
+  zipWith
+};
+//# sourceMappingURL=NonEmptyArray.js.map