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

@@ -0,0 +1,1300 @@
+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 { fromEquals } from "./Eq.js";
+import { fromEitherK as fromEitherK$1 } from "./FromEither.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 { isNone, isLeft, none, some as some$1, isSome, emptyRecord } from "./internal.js";
+import { Ord } from "./number.js";
+import { fromCompare } from "./Ord.js";
+import { isNonEmpty as isNonEmpty$1, prepend as prepend$1, prependW as prependW$1, append as append$1, appendW as appendW$1, makeBy as makeBy$1, head as head$1, tail as tail$1, init as init$1, last as last$1, isOutOfBound as isOutOfBound$1, unsafeInsertAt as unsafeInsertAt$1, sortBy as sortBy$1, splitAt as splitAt$1, chunksOf as chunksOf$1, of as of$1, unsafeUpdateAt as unsafeUpdateAt$1, empty as empty$1, range as range$1, cons as cons$1, snoc as snoc$1, prependAll as prependAll$1, intersperse as intersperse$1, rotate as rotate$1, uniq as uniq$1, chop as chop$1, union as union$1, intercalate as intercalate$1 } from "./ReadonlyNonEmptyArray.js";
+import { separated } from "./Separated.js";
+import { witherDefault, wiltDefault, filterE as filterE$1 } from "./Witherable.js";
+import { guard as guard$1 } from "./Zero.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 isEmpty = function(as) {
+  return as.length === 0;
+};
+var isNonEmpty = isNonEmpty$1;
+var prepend = prepend$1;
+var prependW = prependW$1;
+var append = append$1;
+var appendW = appendW$1;
+var makeBy = function(n, f) {
+  return n <= 0 ? empty : makeBy$1(f)(n);
+};
+var replicate = function(n, a) {
+  return makeBy(n, function() {
+    return a;
+  });
+};
+function fromPredicate(predicate) {
+  return function(a) {
+    return predicate(a) ? [a] : empty;
+  };
+}
+var fromOption = function(ma) {
+  return isNone(ma) ? empty : [ma.value];
+};
+var fromEither = function(e) {
+  return isLeft(e) ? empty : [e.right];
+};
+var matchW = function(onEmpty, onNonEmpty) {
+  return function(as) {
+    return isNonEmpty(as) ? onNonEmpty(as) : onEmpty();
+  };
+};
+var match = matchW;
+var matchLeftW = function(onEmpty, onNonEmpty) {
+  return function(as) {
+    return isNonEmpty(as) ? onNonEmpty(head$1(as), tail$1(as)) : onEmpty();
+  };
+};
+var matchLeft = matchLeftW;
+var foldLeft = matchLeft;
+var matchRightW = function(onEmpty, onNonEmpty) {
+  return function(as) {
+    return isNonEmpty(as) ? onNonEmpty(init$1(as), last$1(as)) : onEmpty();
+  };
+};
+var matchRight = matchRightW;
+var foldRight = matchRight;
+var chainWithIndex = function(f) {
+  return function(as) {
+    if (isEmpty(as)) {
+      return empty;
+    }
+    var out = [];
+    for (var i = 0; i < as.length; i++) {
+      out.push.apply(out, f(i, as[i]));
+    }
+    return out;
+  };
+};
+var scanLeft = function(b, f) {
+  return function(as) {
+    var len = as.length;
+    var out = new Array(len + 1);
+    out[0] = b;
+    for (var i = 0; i < len; i++) {
+      out[i + 1] = f(out[i], as[i]);
+    }
+    return out;
+  };
+};
+var scanRight = function(b, f) {
+  return function(as) {
+    var len = as.length;
+    var out = new Array(len + 1);
+    out[len] = b;
+    for (var i = len - 1; i >= 0; i--) {
+      out[i] = f(as[i], out[i + 1]);
+    }
+    return out;
+  };
+};
+var size = function(as) {
+  return as.length;
+};
+var isOutOfBound = isOutOfBound$1;
+function lookup(i, as) {
+  return as === void 0 ? function(as2) {
+    return lookup(i, as2);
+  } : isOutOfBound(i, as) ? none : some$1(as[i]);
+}
+var head = function(as) {
+  return isNonEmpty(as) ? some$1(head$1(as)) : none;
+};
+var last = function(as) {
+  return isNonEmpty(as) ? some$1(last$1(as)) : none;
+};
+var tail = function(as) {
+  return isNonEmpty(as) ? some$1(tail$1(as)) : none;
+};
+var init = function(as) {
+  return isNonEmpty(as) ? some$1(init$1(as)) : none;
+};
+var takeLeft = function(n) {
+  return function(as) {
+    return isOutOfBound(n, as) ? as : n === 0 ? empty : as.slice(0, n);
+  };
+};
+var takeRight = function(n) {
+  return function(as) {
+    return isOutOfBound(n, as) ? as : n === 0 ? empty : as.slice(-n);
+  };
+};
+function takeLeftWhile(predicate) {
+  return function(as) {
+    var out = [];
+    for (var _i = 0, as_1 = as; _i < as_1.length; _i++) {
+      var a = as_1[_i];
+      if (!predicate(a)) {
+        break;
+      }
+      out.push(a);
+    }
+    var len = out.length;
+    return len === as.length ? as : len === 0 ? empty : out;
+  };
+}
+var spanLeftIndex = function(as, predicate) {
+  var l = as.length;
+  var i = 0;
+  for (; i < l; i++) {
+    if (!predicate(as[i])) {
+      break;
+    }
+  }
+  return i;
+};
+function spanLeft(predicate) {
+  return function(as) {
+    var _a = splitAt(spanLeftIndex(as, predicate))(as), init2 = _a[0], rest = _a[1];
+    return { init: init2, rest };
+  };
+}
+var dropLeft = function(n) {
+  return function(as) {
+    return n <= 0 || isEmpty(as) ? as : n >= as.length ? empty : as.slice(n, as.length);
+  };
+};
+var dropRight = function(n) {
+  return function(as) {
+    return n <= 0 || isEmpty(as) ? as : n >= as.length ? empty : as.slice(0, as.length - n);
+  };
+};
+function dropLeftWhile(predicate) {
+  return function(as) {
+    var i = spanLeftIndex(as, predicate);
+    return i === 0 ? as : i === as.length ? empty : as.slice(i);
+  };
+}
+var findIndex = function(predicate) {
+  return function(as) {
+    for (var i = 0; i < as.length; i++) {
+      if (predicate(as[i])) {
+        return some$1(i);
+      }
+    }
+    return none;
+  };
+};
+function findFirst(predicate) {
+  return function(as) {
+    for (var i = 0; i < as.length; i++) {
+      if (predicate(as[i])) {
+        return some$1(as[i]);
+      }
+    }
+    return none;
+  };
+}
+var findFirstMap = function(f) {
+  return function(as) {
+    for (var i = 0; i < as.length; i++) {
+      var out = f(as[i]);
+      if (isSome(out)) {
+        return out;
+      }
+    }
+    return none;
+  };
+};
+function findLast(predicate) {
+  return function(as) {
+    for (var i = as.length - 1; i >= 0; i--) {
+      if (predicate(as[i])) {
+        return some$1(as[i]);
+      }
+    }
+    return none;
+  };
+}
+var findLastMap = function(f) {
+  return function(as) {
+    for (var i = as.length - 1; i >= 0; i--) {
+      var out = f(as[i]);
+      if (isSome(out)) {
+        return out;
+      }
+    }
+    return none;
+  };
+};
+var findLastIndex = function(predicate) {
+  return function(as) {
+    for (var i = as.length - 1; i >= 0; i--) {
+      if (predicate(as[i])) {
+        return some$1(i);
+      }
+    }
+    return none;
+  };
+};
+var insertAt = function(i, a) {
+  return function(as) {
+    return i < 0 || i > as.length ? none : some$1(unsafeInsertAt$1(i, a, as));
+  };
+};
+var updateAt = function(i, a) {
+  return modifyAt(i, function() {
+    return a;
+  });
+};
+var deleteAt = function(i) {
+  return function(as) {
+    return isOutOfBound(i, as) ? none : some$1(unsafeDeleteAt(i, as));
+  };
+};
+var modifyAt = function(i, f) {
+  return function(as) {
+    return isOutOfBound(i, as) ? none : some$1(unsafeUpdateAt(i, f(as[i]), as));
+  };
+};
+var reverse = function(as) {
+  return as.length <= 1 ? as : as.slice().reverse();
+};
+var rights = function(as) {
+  var r = [];
+  for (var i = 0; i < as.length; i++) {
+    var a = as[i];
+    if (a._tag === "Right") {
+      r.push(a.right);
+    }
+  }
+  return r;
+};
+var lefts = function(as) {
+  var r = [];
+  for (var i = 0; i < as.length; i++) {
+    var a = as[i];
+    if (a._tag === "Left") {
+      r.push(a.left);
+    }
+  }
+  return r;
+};
+var sort = function(O) {
+  return function(as) {
+    return as.length <= 1 ? as : as.slice().sort(O.compare);
+  };
+};
+var zipWith = function(fa, fb, f) {
+  var fc = [];
+  var len = Math.min(fa.length, fb.length);
+  for (var i = 0; i < len; i++) {
+    fc[i] = f(fa[i], fb[i]);
+  }
+  return fc;
+};
+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(as) {
+  var fa = [];
+  var fb = [];
+  for (var i = 0; i < as.length; i++) {
+    fa[i] = as[i][0];
+    fb[i] = as[i][1];
+  }
+  return [fa, fb];
+};
+var prependAll = function(middle) {
+  var f = prependAll$1(middle);
+  return function(as) {
+    return isNonEmpty(as) ? f(as) : as;
+  };
+};
+var intersperse = function(middle) {
+  var f = intersperse$1(middle);
+  return function(as) {
+    return isNonEmpty(as) ? f(as) : as;
+  };
+};
+var rotate = function(n) {
+  var f = rotate$1(n);
+  return function(as) {
+    return isNonEmpty(as) ? f(as) : as;
+  };
+};
+function elem(E) {
+  return function(a, as) {
+    if (as === void 0) {
+      var elemE_1 = elem(E);
+      return function(as2) {
+        return elemE_1(a, as2);
+      };
+    }
+    var predicate = function(element) {
+      return E.equals(element, a);
+    };
+    var i = 0;
+    for (; i < as.length; i++) {
+      if (predicate(as[i])) {
+        return true;
+      }
+    }
+    return false;
+  };
+}
+var uniq = function(E) {
+  var f = uniq$1(E);
+  return function(as) {
+    return isNonEmpty(as) ? f(as) : as;
+  };
+};
+var sortBy = function(ords) {
+  var f = sortBy$1(ords);
+  return function(as) {
+    return isNonEmpty(as) ? f(as) : as;
+  };
+};
+var chop = function(f) {
+  var g = chop$1(f);
+  return function(as) {
+    return isNonEmpty(as) ? g(as) : empty;
+  };
+};
+var splitAt = function(n) {
+  return function(as) {
+    return n >= 1 && isNonEmpty(as) ? splitAt$1(n)(as) : isEmpty(as) ? [as, empty] : [empty, as];
+  };
+};
+var chunksOf = function(n) {
+  var f = chunksOf$1(n);
+  return function(as) {
+    return isNonEmpty(as) ? f(as) : empty;
+  };
+};
+var fromOptionK = function(f) {
+  return function() {
+    var a = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+      a[_i] = arguments[_i];
+    }
+    return fromOption(f.apply(void 0, a));
+  };
+};
+function comprehension(input, f, g) {
+  if (g === void 0) {
+    g = function() {
+      return true;
+    };
+  }
+  var go = function(scope, input2) {
+    return isNonEmpty(input2) ? flatMap(head$1(input2), function(a) {
+      return go(pipe(scope, append(a)), tail$1(input2));
+    }) : g.apply(void 0, scope) ? [f.apply(void 0, scope)] : empty;
+  };
+  return go(empty, input);
+}
+var concatW = function(second) {
+  return function(first) {
+    return isEmpty(first) ? second : isEmpty(second) ? first : first.concat(second);
+  };
+};
+var concat = concatW;
+function union(E) {
+  var unionE = union$1(E);
+  return function(first, second) {
+    if (second === void 0) {
+      var unionE_1 = union(E);
+      return function(second2) {
+        return unionE_1(second2, first);
+      };
+    }
+    return isNonEmpty(first) && isNonEmpty(second) ? unionE(second)(first) : isNonEmpty(first) ? first : second;
+  };
+}
+function intersection(E) {
+  var elemE = elem(E);
+  return function(xs, ys) {
+    if (ys === void 0) {
+      var intersectionE_1 = intersection(E);
+      return function(ys2) {
+        return intersectionE_1(ys2, xs);
+      };
+    }
+    return xs.filter(function(a) {
+      return elemE(a, ys);
+    });
+  };
+}
+function difference(E) {
+  var elemE = elem(E);
+  return function(xs, ys) {
+    if (ys === void 0) {
+      var differenceE_1 = difference(E);
+      return function(ys2) {
+        return differenceE_1(ys2, xs);
+      };
+    }
+    return xs.filter(function(a) {
+      return !elemE(a, ys);
+    });
+  };
+}
+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 _filter = function(fa, predicate) {
+  return pipe(fa, filter(predicate));
+};
+var _filterMap = function(fa, f) {
+  return pipe(fa, filterMap(f));
+};
+var _partition = function(fa, predicate) {
+  return pipe(fa, partition(predicate));
+};
+var _partitionMap = function(fa, f) {
+  return pipe(fa, partitionMap(f));
+};
+var _partitionWithIndex = function(fa, predicateWithIndex) {
+  return pipe(fa, partitionWithIndex(predicateWithIndex));
+};
+var _partitionMapWithIndex = function(fa, f) {
+  return pipe(fa, partitionMapWithIndex(f));
+};
+var _alt = function(fa, that) {
+  return pipe(fa, alt(that));
+};
+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 _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 _filterMapWithIndex = function(fa, f) {
+  return pipe(fa, filterMapWithIndex(f));
+};
+var _filterWithIndex = function(fa, predicateWithIndex) {
+  return pipe(fa, filterWithIndex(predicateWithIndex));
+};
+var _extend = function(fa, f) {
+  return pipe(fa, extend(f));
+};
+var _traverse = function(F) {
+  var traverseF = traverse(F);
+  return function(ta, f) {
+    return pipe(ta, traverseF(f));
+  };
+};
+var _traverseWithIndex = function(F) {
+  var traverseWithIndexF = traverseWithIndex(F);
+  return function(ta, f) {
+    return pipe(ta, traverseWithIndexF(f));
+  };
+};
+var _chainRecDepthFirst = function(a, f) {
+  return pipe(a, chainRecDepthFirst(f));
+};
+var _chainRecBreadthFirst = function(a, f) {
+  return pipe(a, chainRecBreadthFirst(f));
+};
+var of = of$1;
+var zero = function() {
+  return empty;
+};
+var altW = function(that) {
+  return function(fa) {
+    return fa.concat(that());
+  };
+};
+var alt = altW;
+var ap = function(fa) {
+  return flatMap(function(f) {
+    return pipe(fa, map(f));
+  });
+};
+var flatMap = /* @__PURE__ */ dual(2, function(ma, f) {
+  return pipe(ma, chainWithIndex(function(i, a) {
+    return f(a, i);
+  }));
+});
+var flatten = /* @__PURE__ */ flatMap(identity);
+var map = function(f) {
+  return function(fa) {
+    return fa.map(function(a) {
+      return f(a);
+    });
+  };
+};
+var mapWithIndex = function(f) {
+  return function(fa) {
+    return fa.map(function(a, i) {
+      return f(i, a);
+    });
+  };
+};
+var separate = function(fa) {
+  var left = [];
+  var right = [];
+  for (var _i = 0, fa_1 = fa; _i < fa_1.length; _i++) {
+    var e = fa_1[_i];
+    if (e._tag === "Left") {
+      left.push(e.left);
+    } else {
+      right.push(e.right);
+    }
+  }
+  return separated(left, right);
+};
+var filter = function(predicate) {
+  return function(as) {
+    return as.filter(predicate);
+  };
+};
+var filterMapWithIndex = function(f) {
+  return function(fa) {
+    var out = [];
+    for (var i = 0; i < fa.length; i++) {
+      var optionB = f(i, fa[i]);
+      if (isSome(optionB)) {
+        out.push(optionB.value);
+      }
+    }
+    return out;
+  };
+};
+var filterMap = function(f) {
+  return filterMapWithIndex(function(_, a) {
+    return f(a);
+  });
+};
+var compact = /* @__PURE__ */ filterMap(identity);
+var partition = function(predicate) {
+  return partitionWithIndex(function(_, a) {
+    return predicate(a);
+  });
+};
+var partitionWithIndex = function(predicateWithIndex) {
+  return function(as) {
+    var left = [];
+    var right = [];
+    for (var i = 0; i < as.length; i++) {
+      var a = as[i];
+      if (predicateWithIndex(i, a)) {
+        right.push(a);
+      } else {
+        left.push(a);
+      }
+    }
+    return separated(left, right);
+  };
+};
+var partitionMap = function(f) {
+  return partitionMapWithIndex(function(_, a) {
+    return f(a);
+  });
+};
+var partitionMapWithIndex = function(f) {
+  return function(fa) {
+    var left = [];
+    var right = [];
+    for (var i = 0; i < fa.length; i++) {
+      var e = f(i, fa[i]);
+      if (e._tag === "Left") {
+        left.push(e.left);
+      } else {
+        right.push(e.right);
+      }
+    }
+    return separated(left, right);
+  };
+};
+var filterWithIndex = function(predicateWithIndex) {
+  return function(as) {
+    return as.filter(function(a, i) {
+      return predicateWithIndex(i, a);
+    });
+  };
+};
+var extend = function(f) {
+  return function(wa) {
+    return wa.map(function(_, i) {
+      return f(wa.slice(i));
+    });
+  };
+};
+var duplicate = /* @__PURE__ */ extend(identity);
+var foldMapWithIndex = function(M) {
+  return function(f) {
+    return function(fa) {
+      return fa.reduce(function(b, a, i) {
+        return M.concat(b, f(i, a));
+      }, M.empty);
+    };
+  };
+};
+var reduce = function(b, f) {
+  return reduceWithIndex(b, function(_, b2, a) {
+    return f(b2, a);
+  });
+};
+var foldMap = function(M) {
+  var foldMapWithIndexM = foldMapWithIndex(M);
+  return function(f) {
+    return foldMapWithIndexM(function(_, a) {
+      return f(a);
+    });
+  };
+};
+var reduceWithIndex = function(b, f) {
+  return function(fa) {
+    var len = fa.length;
+    var out = b;
+    for (var i = 0; i < len; i++) {
+      out = f(i, out, fa[i]);
+    }
+    return out;
+  };
+};
+var reduceRight = function(b, f) {
+  return reduceRightWithIndex(b, function(_, a, b2) {
+    return f(a, b2);
+  });
+};
+var reduceRightWithIndex = function(b, f) {
+  return function(fa) {
+    return fa.reduceRight(function(b2, a, i) {
+      return f(i, a, b2);
+    }, b);
+  };
+};
+var traverse = function(F) {
+  var traverseWithIndexF = traverseWithIndex(F);
+  return function(f) {
+    return traverseWithIndexF(function(_, a) {
+      return f(a);
+    });
+  };
+};
+var sequence = function(F) {
+  return function(ta) {
+    return _reduce(ta, F.of(zero()), function(fas, fa) {
+      return F.ap(F.map(fas, function(as) {
+        return function(a) {
+          return pipe(as, append(a));
+        };
+      }), fa);
+    });
+  };
+};
+var traverseWithIndex = function(F) {
+  return function(f) {
+    return reduceWithIndex(F.of(zero()), function(i, fbs, a) {
+      return F.ap(F.map(fbs, function(bs) {
+        return function(b) {
+          return pipe(bs, append(b));
+        };
+      }), f(i, a));
+    });
+  };
+};
+var wither = function(F) {
+  var _witherF = _wither(F);
+  return function(f) {
+    return function(fa) {
+      return _witherF(fa, f);
+    };
+  };
+};
+var wilt = function(F) {
+  var _wiltF = _wilt(F);
+  return function(f) {
+    return function(fa) {
+      return _wiltF(fa, f);
+    };
+  };
+};
+var unfold = function(b, f) {
+  var out = [];
+  var bb = b;
+  while (true) {
+    var mt = f(bb);
+    if (isSome(mt)) {
+      var _a = mt.value, a = _a[0], b_1 = _a[1];
+      out.push(a);
+      bb = b_1;
+    } else {
+      break;
+    }
+  }
+  return out;
+};
+var URI = "ReadonlyArray";
+var getShow = function(S) {
+  return {
+    show: function(as) {
+      return "[".concat(as.map(S.show).join(", "), "]");
+    }
+  };
+};
+var getSemigroup = function() {
+  return {
+    concat: function(first, second) {
+      return isEmpty(first) ? second : isEmpty(second) ? first : first.concat(second);
+    }
+  };
+};
+var getMonoid = function() {
+  return {
+    concat: getSemigroup().concat,
+    empty
+  };
+};
+var getEq = function(E) {
+  return fromEquals(function(xs, ys) {
+    return xs.length === ys.length && xs.every(function(x, i) {
+      return E.equals(x, ys[i]);
+    });
+  });
+};
+var getOrd = function(O) {
+  return fromCompare(function(a, b) {
+    var aLen = a.length;
+    var bLen = b.length;
+    var len = Math.min(aLen, bLen);
+    for (var i = 0; i < len; i++) {
+      var ordering = O.compare(a[i], b[i]);
+      if (ordering !== 0) {
+        return ordering;
+      }
+    }
+    return Ord.compare(aLen, bLen);
+  });
+};
+var getUnionSemigroup = function(E) {
+  var unionE = union(E);
+  return {
+    concat: function(first, second) {
+      return unionE(second)(first);
+    }
+  };
+};
+var getUnionMonoid = function(E) {
+  return {
+    concat: getUnionSemigroup(E).concat,
+    empty
+  };
+};
+var getIntersectionSemigroup = function(E) {
+  var intersectionE = intersection(E);
+  return {
+    concat: function(first, second) {
+      return intersectionE(second)(first);
+    }
+  };
+};
+var getDifferenceMagma = function(E) {
+  var differenceE = difference(E);
+  return {
+    concat: function(first, second) {
+      return differenceE(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 Monad = {
+  URI,
+  map: _map,
+  ap: _ap,
+  of,
+  chain: flatMap
+};
+var chainFirst = /* @__PURE__ */ chainFirst$1(Chain);
+var Unfoldable = {
+  URI,
+  unfold
+};
+var Alt = {
+  URI,
+  map: _map,
+  alt: _alt
+};
+var Zero = {
+  URI,
+  zero
+};
+var guard = /* @__PURE__ */ guard$1(Zero, Pointed);
+var Alternative = {
+  URI,
+  map: _map,
+  ap: _ap,
+  of,
+  alt: _alt,
+  zero
+};
+var Extend = {
+  URI,
+  map: _map,
+  extend: _extend
+};
+var Compactable = {
+  URI,
+  compact,
+  separate
+};
+var Filterable = {
+  URI,
+  map: _map,
+  compact,
+  separate,
+  filter: _filter,
+  filterMap: _filterMap,
+  partition: _partition,
+  partitionMap: _partitionMap
+};
+var FilterableWithIndex = {
+  URI,
+  map: _map,
+  mapWithIndex: _mapWithIndex,
+  compact,
+  separate,
+  filter: _filter,
+  filterMap: _filterMap,
+  partition: _partition,
+  partitionMap: _partitionMap,
+  partitionMapWithIndex: _partitionMapWithIndex,
+  partitionWithIndex: _partitionWithIndex,
+  filterMapWithIndex: _filterMapWithIndex,
+  filterWithIndex: _filterWithIndex
+};
+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,
+  reduceWithIndex: _reduceWithIndex,
+  foldMapWithIndex: _foldMapWithIndex,
+  reduceRightWithIndex: _reduceRightWithIndex,
+  traverse: _traverse,
+  sequence,
+  traverseWithIndex: _traverseWithIndex
+};
+var chainRecDepthFirst = function(f) {
+  return function(a) {
+    var todo = __spreadArray([], f(a), true);
+    var out = [];
+    while (todo.length > 0) {
+      var e = todo.shift();
+      if (isLeft(e)) {
+        todo.unshift.apply(todo, f(e.left));
+      } else {
+        out.push(e.right);
+      }
+    }
+    return out;
+  };
+};
+var ChainRecDepthFirst = {
+  URI,
+  map: _map,
+  ap: _ap,
+  chain: flatMap,
+  chainRec: _chainRecDepthFirst
+};
+var chainRecBreadthFirst = function(f) {
+  return function(a) {
+    var initial = f(a);
+    var todo = [];
+    var out = [];
+    function go(e2) {
+      if (isLeft(e2)) {
+        f(e2.left).forEach(function(v) {
+          return todo.push(v);
+        });
+      } else {
+        out.push(e2.right);
+      }
+    }
+    for (var _i = 0, initial_1 = initial; _i < initial_1.length; _i++) {
+      var e = initial_1[_i];
+      go(e);
+    }
+    while (todo.length > 0) {
+      go(todo.shift());
+    }
+    return out;
+  };
+};
+var ChainRecBreadthFirst = {
+  URI,
+  map: _map,
+  ap: _ap,
+  chain: flatMap,
+  chainRec: _chainRecBreadthFirst
+};
+var _wither = /* @__PURE__ */ witherDefault(Traversable, Compactable);
+var _wilt = /* @__PURE__ */ wiltDefault(Traversable, Compactable);
+var Witherable = {
+  URI,
+  map: _map,
+  compact,
+  separate,
+  filter: _filter,
+  filterMap: _filterMap,
+  partition: _partition,
+  partitionMap: _partitionMap,
+  reduce: _reduce,
+  foldMap: _foldMap,
+  reduceRight: _reduceRight,
+  traverse: _traverse,
+  sequence,
+  wither: _wither,
+  wilt: _wilt
+};
+var filterE = /* @__PURE__ */ filterE$1(Witherable);
+var FromEither = {
+  URI,
+  fromEither
+};
+var fromEitherK = /* @__PURE__ */ fromEitherK$1(FromEither);
+var unsafeInsertAt = unsafeInsertAt$1;
+var unsafeUpdateAt = function(i, a, as) {
+  return isNonEmpty(as) ? unsafeUpdateAt$1(i, a, as) : as;
+};
+var unsafeDeleteAt = function(i, as) {
+  var xs = as.slice();
+  xs.splice(i, 1);
+  return xs;
+};
+var toArray = function(as) {
+  return as.slice();
+};
+var fromArray = function(as) {
+  return isEmpty(as) ? empty : as.slice();
+};
+var empty = empty$1;
+function every(predicate) {
+  return function(as) {
+    return as.every(predicate);
+  };
+}
+var some = function(predicate) {
+  return function(as) {
+    return as.some(predicate);
+  };
+};
+var exists = some;
+var intercalate = function(M) {
+  var intercalateM = intercalate$1(M);
+  return function(middle) {
+    return match(function() {
+      return M.empty;
+    }, intercalateM(middle));
+  };
+};
+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 chain = flatMap;
+var range = range$1;
+var cons = cons$1;
+var snoc = snoc$1;
+var prependToAll = prependAll;
+var readonlyArray = {
+  URI,
+  compact,
+  separate,
+  map: _map,
+  ap: _ap,
+  of,
+  chain: flatMap,
+  filter: _filter,
+  filterMap: _filterMap,
+  partition: _partition,
+  partitionMap: _partitionMap,
+  mapWithIndex: _mapWithIndex,
+  partitionMapWithIndex: _partitionMapWithIndex,
+  partitionWithIndex: _partitionWithIndex,
+  filterMapWithIndex: _filterMapWithIndex,
+  filterWithIndex: _filterWithIndex,
+  alt: _alt,
+  zero,
+  unfold,
+  reduce: _reduce,
+  foldMap: _foldMap,
+  reduceRight: _reduceRight,
+  traverse: _traverse,
+  sequence,
+  reduceWithIndex: _reduceWithIndex,
+  foldMapWithIndex: _foldMapWithIndex,
+  reduceRightWithIndex: _reduceRightWithIndex,
+  traverseWithIndex: _traverseWithIndex,
+  extend: _extend,
+  wither: _wither,
+  wilt: _wilt
+};
+export {
+  Alt,
+  Alternative,
+  Applicative,
+  Apply,
+  Chain,
+  ChainRecBreadthFirst,
+  ChainRecDepthFirst,
+  Compactable,
+  Do,
+  Extend,
+  Filterable,
+  FilterableWithIndex,
+  Foldable,
+  FoldableWithIndex,
+  FromEither,
+  Functor,
+  FunctorWithIndex,
+  Monad,
+  Pointed,
+  Traversable,
+  TraversableWithIndex,
+  URI,
+  Unfoldable,
+  Witherable,
+  Zero,
+  _chainRecBreadthFirst,
+  _chainRecDepthFirst,
+  alt,
+  altW,
+  ap,
+  apFirst,
+  apS,
+  apSecond,
+  append,
+  appendW,
+  bind,
+  bindTo,
+  chain,
+  chainFirst,
+  chainRecBreadthFirst,
+  chainRecDepthFirst,
+  chainWithIndex,
+  chop,
+  chunksOf,
+  compact,
+  comprehension,
+  concat,
+  concatW,
+  cons,
+  deleteAt,
+  difference,
+  dropLeft,
+  dropLeftWhile,
+  dropRight,
+  duplicate,
+  elem,
+  empty,
+  every,
+  exists,
+  extend,
+  filter,
+  filterE,
+  filterMap,
+  filterMapWithIndex,
+  filterWithIndex,
+  findFirst,
+  findFirstMap,
+  findIndex,
+  findLast,
+  findLastIndex,
+  findLastMap,
+  flap,
+  flatMap,
+  flatten,
+  foldLeft,
+  foldMap,
+  foldMapWithIndex,
+  foldRight,
+  fromArray,
+  fromEither,
+  fromEitherK,
+  fromOption,
+  fromOptionK,
+  fromPredicate,
+  getDifferenceMagma,
+  getEq,
+  getIntersectionSemigroup,
+  getMonoid,
+  getOrd,
+  getSemigroup,
+  getShow,
+  getUnionMonoid,
+  getUnionSemigroup,
+  guard,
+  head,
+  init,
+  insertAt,
+  intercalate,
+  intersection,
+  intersperse,
+  isEmpty,
+  isNonEmpty,
+  isOutOfBound,
+  last,
+  lefts,
+  let_ as let,
+  lookup,
+  makeBy,
+  map,
+  mapWithIndex,
+  match,
+  matchLeft,
+  matchLeftW,
+  matchRight,
+  matchRightW,
+  matchW,
+  modifyAt,
+  of,
+  partition,
+  partitionMap,
+  partitionMapWithIndex,
+  partitionWithIndex,
+  prepend,
+  prependAll,
+  prependToAll,
+  prependW,
+  range,
+  readonlyArray,
+  reduce,
+  reduceRight,
+  reduceRightWithIndex,
+  reduceWithIndex,
+  replicate,
+  reverse,
+  rights,
+  rotate,
+  scanLeft,
+  scanRight,
+  separate,
+  sequence,
+  size,
+  snoc,
+  some,
+  sort,
+  sortBy,
+  spanLeft,
+  splitAt,
+  tail,
+  takeLeft,
+  takeLeftWhile,
+  takeRight,
+  toArray,
+  traverse,
+  traverseWithIndex,
+  unfold,
+  union,
+  uniq,
+  unsafeDeleteAt,
+  unsafeInsertAt,
+  unsafeUpdateAt,
+  unzip,
+  updateAt,
+  wilt,
+  wither,
+  zero,
+  zip,
+  zipWith
+};
+//# sourceMappingURL=ReadonlyArray.js.map