@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.cjs

@@ -0,0 +1,1300 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Apply$1 = require("./Apply.cjs");
+const Chain$1 = require("./Chain.cjs");
+const Eq = require("./Eq.cjs");
+const FromEither$1 = require("./FromEither.cjs");
+const _function = require("./function.cjs");
+const Functor$1 = require("./Functor.cjs");
+const internal = require("./internal.cjs");
+const number = require("./number.cjs");
+const Ord = require("./Ord.cjs");
+const ReadonlyNonEmptyArray = require("./ReadonlyNonEmptyArray.cjs");
+const Separated = require("./Separated.cjs");
+const Witherable$1 = require("./Witherable.cjs");
+const Zero$1 = require("./Zero.cjs");
+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 = ReadonlyNonEmptyArray.isNonEmpty;
+var prepend = ReadonlyNonEmptyArray.prepend;
+var prependW = ReadonlyNonEmptyArray.prependW;
+var append = ReadonlyNonEmptyArray.append;
+var appendW = ReadonlyNonEmptyArray.appendW;
+var makeBy = function(n, f) {
+  return n <= 0 ? empty : ReadonlyNonEmptyArray.makeBy(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 internal.isNone(ma) ? empty : [ma.value];
+};
+var fromEither = function(e) {
+  return internal.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(ReadonlyNonEmptyArray.head(as), ReadonlyNonEmptyArray.tail(as)) : onEmpty();
+  };
+};
+var matchLeft = matchLeftW;
+var foldLeft = matchLeft;
+var matchRightW = function(onEmpty, onNonEmpty) {
+  return function(as) {
+    return isNonEmpty(as) ? onNonEmpty(ReadonlyNonEmptyArray.init(as), ReadonlyNonEmptyArray.last(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 = ReadonlyNonEmptyArray.isOutOfBound;
+function lookup(i, as) {
+  return as === void 0 ? function(as2) {
+    return lookup(i, as2);
+  } : isOutOfBound(i, as) ? internal.none : internal.some(as[i]);
+}
+var head = function(as) {
+  return isNonEmpty(as) ? internal.some(ReadonlyNonEmptyArray.head(as)) : internal.none;
+};
+var last = function(as) {
+  return isNonEmpty(as) ? internal.some(ReadonlyNonEmptyArray.last(as)) : internal.none;
+};
+var tail = function(as) {
+  return isNonEmpty(as) ? internal.some(ReadonlyNonEmptyArray.tail(as)) : internal.none;
+};
+var init = function(as) {
+  return isNonEmpty(as) ? internal.some(ReadonlyNonEmptyArray.init(as)) : internal.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 internal.some(i);
+      }
+    }
+    return internal.none;
+  };
+};
+function findFirst(predicate) {
+  return function(as) {
+    for (var i = 0; i < as.length; i++) {
+      if (predicate(as[i])) {
+        return internal.some(as[i]);
+      }
+    }
+    return internal.none;
+  };
+}
+var findFirstMap = function(f) {
+  return function(as) {
+    for (var i = 0; i < as.length; i++) {
+      var out = f(as[i]);
+      if (internal.isSome(out)) {
+        return out;
+      }
+    }
+    return internal.none;
+  };
+};
+function findLast(predicate) {
+  return function(as) {
+    for (var i = as.length - 1; i >= 0; i--) {
+      if (predicate(as[i])) {
+        return internal.some(as[i]);
+      }
+    }
+    return internal.none;
+  };
+}
+var findLastMap = function(f) {
+  return function(as) {
+    for (var i = as.length - 1; i >= 0; i--) {
+      var out = f(as[i]);
+      if (internal.isSome(out)) {
+        return out;
+      }
+    }
+    return internal.none;
+  };
+};
+var findLastIndex = function(predicate) {
+  return function(as) {
+    for (var i = as.length - 1; i >= 0; i--) {
+      if (predicate(as[i])) {
+        return internal.some(i);
+      }
+    }
+    return internal.none;
+  };
+};
+var insertAt = function(i, a) {
+  return function(as) {
+    return i < 0 || i > as.length ? internal.none : internal.some(ReadonlyNonEmptyArray.unsafeInsertAt(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) ? internal.none : internal.some(unsafeDeleteAt(i, as));
+  };
+};
+var modifyAt = function(i, f) {
+  return function(as) {
+    return isOutOfBound(i, as) ? internal.none : internal.some(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 = ReadonlyNonEmptyArray.prependAll(middle);
+  return function(as) {
+    return isNonEmpty(as) ? f(as) : as;
+  };
+};
+var intersperse = function(middle) {
+  var f = ReadonlyNonEmptyArray.intersperse(middle);
+  return function(as) {
+    return isNonEmpty(as) ? f(as) : as;
+  };
+};
+var rotate = function(n) {
+  var f = ReadonlyNonEmptyArray.rotate(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 = ReadonlyNonEmptyArray.uniq(E);
+  return function(as) {
+    return isNonEmpty(as) ? f(as) : as;
+  };
+};
+var sortBy = function(ords) {
+  var f = ReadonlyNonEmptyArray.sortBy(ords);
+  return function(as) {
+    return isNonEmpty(as) ? f(as) : as;
+  };
+};
+var chop = function(f) {
+  var g = ReadonlyNonEmptyArray.chop(f);
+  return function(as) {
+    return isNonEmpty(as) ? g(as) : empty;
+  };
+};
+var splitAt = function(n) {
+  return function(as) {
+    return n >= 1 && isNonEmpty(as) ? ReadonlyNonEmptyArray.splitAt(n)(as) : isEmpty(as) ? [as, empty] : [empty, as];
+  };
+};
+var chunksOf = function(n) {
+  var f = ReadonlyNonEmptyArray.chunksOf(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(ReadonlyNonEmptyArray.head(input2), function(a) {
+      return go(_function.pipe(scope, append(a)), ReadonlyNonEmptyArray.tail(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 = ReadonlyNonEmptyArray.union(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 _function.pipe(fa, map(f));
+};
+var _mapWithIndex = function(fa, f) {
+  return _function.pipe(fa, mapWithIndex(f));
+};
+var _ap = function(fab, fa) {
+  return _function.pipe(fab, ap(fa));
+};
+var _filter = function(fa, predicate) {
+  return _function.pipe(fa, filter(predicate));
+};
+var _filterMap = function(fa, f) {
+  return _function.pipe(fa, filterMap(f));
+};
+var _partition = function(fa, predicate) {
+  return _function.pipe(fa, partition(predicate));
+};
+var _partitionMap = function(fa, f) {
+  return _function.pipe(fa, partitionMap(f));
+};
+var _partitionWithIndex = function(fa, predicateWithIndex) {
+  return _function.pipe(fa, partitionWithIndex(predicateWithIndex));
+};
+var _partitionMapWithIndex = function(fa, f) {
+  return _function.pipe(fa, partitionMapWithIndex(f));
+};
+var _alt = function(fa, that) {
+  return _function.pipe(fa, alt(that));
+};
+var _reduce = function(fa, b, f) {
+  return _function.pipe(fa, reduce(b, f));
+};
+var _foldMap = function(M) {
+  var foldMapM = foldMap(M);
+  return function(fa, f) {
+    return _function.pipe(fa, foldMapM(f));
+  };
+};
+var _reduceRight = function(fa, b, f) {
+  return _function.pipe(fa, reduceRight(b, f));
+};
+var _reduceWithIndex = function(fa, b, f) {
+  return _function.pipe(fa, reduceWithIndex(b, f));
+};
+var _foldMapWithIndex = function(M) {
+  var foldMapWithIndexM = foldMapWithIndex(M);
+  return function(fa, f) {
+    return _function.pipe(fa, foldMapWithIndexM(f));
+  };
+};
+var _reduceRightWithIndex = function(fa, b, f) {
+  return _function.pipe(fa, reduceRightWithIndex(b, f));
+};
+var _filterMapWithIndex = function(fa, f) {
+  return _function.pipe(fa, filterMapWithIndex(f));
+};
+var _filterWithIndex = function(fa, predicateWithIndex) {
+  return _function.pipe(fa, filterWithIndex(predicateWithIndex));
+};
+var _extend = function(fa, f) {
+  return _function.pipe(fa, extend(f));
+};
+var _traverse = function(F) {
+  var traverseF = traverse(F);
+  return function(ta, f) {
+    return _function.pipe(ta, traverseF(f));
+  };
+};
+var _traverseWithIndex = function(F) {
+  var traverseWithIndexF = traverseWithIndex(F);
+  return function(ta, f) {
+    return _function.pipe(ta, traverseWithIndexF(f));
+  };
+};
+var _chainRecDepthFirst = function(a, f) {
+  return _function.pipe(a, chainRecDepthFirst(f));
+};
+var _chainRecBreadthFirst = function(a, f) {
+  return _function.pipe(a, chainRecBreadthFirst(f));
+};
+var of = ReadonlyNonEmptyArray.of;
+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 _function.pipe(fa, map(f));
+  });
+};
+var flatMap = /* @__PURE__ */ _function.dual(2, function(ma, f) {
+  return _function.pipe(ma, chainWithIndex(function(i, a) {
+    return f(a, i);
+  }));
+});
+var flatten = /* @__PURE__ */ flatMap(_function.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.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 (internal.isSome(optionB)) {
+        out.push(optionB.value);
+      }
+    }
+    return out;
+  };
+};
+var filterMap = function(f) {
+  return filterMapWithIndex(function(_, a) {
+    return f(a);
+  });
+};
+var compact = /* @__PURE__ */ filterMap(_function.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.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.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(_function.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 _function.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 _function.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 (internal.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 Eq.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 Ord.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 number.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__ */ Functor$1.flap(Functor);
+var Pointed = {
+  URI,
+  of
+};
+var FunctorWithIndex = {
+  URI,
+  map: _map,
+  mapWithIndex: _mapWithIndex
+};
+var Apply = {
+  URI,
+  map: _map,
+  ap: _ap
+};
+var apFirst = /* @__PURE__ */ Apply$1.apFirst(Apply);
+var apSecond = /* @__PURE__ */ Apply$1.apSecond(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__ */ Chain$1.chainFirst(Chain);
+var Unfoldable = {
+  URI,
+  unfold
+};
+var Alt = {
+  URI,
+  map: _map,
+  alt: _alt
+};
+var Zero = {
+  URI,
+  zero
+};
+var guard = /* @__PURE__ */ Zero$1.guard(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 (internal.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 (internal.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__ */ Witherable$1.witherDefault(Traversable, Compactable);
+var _wilt = /* @__PURE__ */ Witherable$1.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__ */ Witherable$1.filterE(Witherable);
+var FromEither = {
+  URI,
+  fromEither
+};
+var fromEitherK = /* @__PURE__ */ FromEither$1.fromEitherK(FromEither);
+var unsafeInsertAt = ReadonlyNonEmptyArray.unsafeInsertAt;
+var unsafeUpdateAt = function(i, a, as) {
+  return isNonEmpty(as) ? ReadonlyNonEmptyArray.unsafeUpdateAt(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 = ReadonlyNonEmptyArray.empty;
+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 = ReadonlyNonEmptyArray.intercalate(M);
+  return function(middle) {
+    return match(function() {
+      return M.empty;
+    }, intercalateM(middle));
+  };
+};
+var Do = /* @__PURE__ */ of(internal.emptyRecord);
+var bindTo = /* @__PURE__ */ Functor$1.bindTo(Functor);
+var let_ = /* @__PURE__ */ Functor$1.let(Functor);
+var bind = /* @__PURE__ */ Chain$1.bind(Chain);
+var apS = /* @__PURE__ */ Apply$1.apS(Apply);
+var chain = flatMap;
+var range = ReadonlyNonEmptyArray.range;
+var cons = ReadonlyNonEmptyArray.cons;
+var snoc = ReadonlyNonEmptyArray.snoc;
+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
+};
+exports.Alt = Alt;
+exports.Alternative = Alternative;
+exports.Applicative = Applicative;
+exports.Apply = Apply;
+exports.Chain = Chain;
+exports.ChainRecBreadthFirst = ChainRecBreadthFirst;
+exports.ChainRecDepthFirst = ChainRecDepthFirst;
+exports.Compactable = Compactable;
+exports.Do = Do;
+exports.Extend = Extend;
+exports.Filterable = Filterable;
+exports.FilterableWithIndex = FilterableWithIndex;
+exports.Foldable = Foldable;
+exports.FoldableWithIndex = FoldableWithIndex;
+exports.FromEither = FromEither;
+exports.Functor = Functor;
+exports.FunctorWithIndex = FunctorWithIndex;
+exports.Monad = Monad;
+exports.Pointed = Pointed;
+exports.Traversable = Traversable;
+exports.TraversableWithIndex = TraversableWithIndex;
+exports.URI = URI;
+exports.Unfoldable = Unfoldable;
+exports.Witherable = Witherable;
+exports.Zero = Zero;
+exports._chainRecBreadthFirst = _chainRecBreadthFirst;
+exports._chainRecDepthFirst = _chainRecDepthFirst;
+exports.alt = alt;
+exports.altW = altW;
+exports.ap = ap;
+exports.apFirst = apFirst;
+exports.apS = apS;
+exports.apSecond = apSecond;
+exports.append = append;
+exports.appendW = appendW;
+exports.bind = bind;
+exports.bindTo = bindTo;
+exports.chain = chain;
+exports.chainFirst = chainFirst;
+exports.chainRecBreadthFirst = chainRecBreadthFirst;
+exports.chainRecDepthFirst = chainRecDepthFirst;
+exports.chainWithIndex = chainWithIndex;
+exports.chop = chop;
+exports.chunksOf = chunksOf;
+exports.compact = compact;
+exports.comprehension = comprehension;
+exports.concat = concat;
+exports.concatW = concatW;
+exports.cons = cons;
+exports.deleteAt = deleteAt;
+exports.difference = difference;
+exports.dropLeft = dropLeft;
+exports.dropLeftWhile = dropLeftWhile;
+exports.dropRight = dropRight;
+exports.duplicate = duplicate;
+exports.elem = elem;
+exports.empty = empty;
+exports.every = every;
+exports.exists = exists;
+exports.extend = extend;
+exports.filter = filter;
+exports.filterE = filterE;
+exports.filterMap = filterMap;
+exports.filterMapWithIndex = filterMapWithIndex;
+exports.filterWithIndex = filterWithIndex;
+exports.findFirst = findFirst;
+exports.findFirstMap = findFirstMap;
+exports.findIndex = findIndex;
+exports.findLast = findLast;
+exports.findLastIndex = findLastIndex;
+exports.findLastMap = findLastMap;
+exports.flap = flap;
+exports.flatMap = flatMap;
+exports.flatten = flatten;
+exports.foldLeft = foldLeft;
+exports.foldMap = foldMap;
+exports.foldMapWithIndex = foldMapWithIndex;
+exports.foldRight = foldRight;
+exports.fromArray = fromArray;
+exports.fromEither = fromEither;
+exports.fromEitherK = fromEitherK;
+exports.fromOption = fromOption;
+exports.fromOptionK = fromOptionK;
+exports.fromPredicate = fromPredicate;
+exports.getDifferenceMagma = getDifferenceMagma;
+exports.getEq = getEq;
+exports.getIntersectionSemigroup = getIntersectionSemigroup;
+exports.getMonoid = getMonoid;
+exports.getOrd = getOrd;
+exports.getSemigroup = getSemigroup;
+exports.getShow = getShow;
+exports.getUnionMonoid = getUnionMonoid;
+exports.getUnionSemigroup = getUnionSemigroup;
+exports.guard = guard;
+exports.head = head;
+exports.init = init;
+exports.insertAt = insertAt;
+exports.intercalate = intercalate;
+exports.intersection = intersection;
+exports.intersperse = intersperse;
+exports.isEmpty = isEmpty;
+exports.isNonEmpty = isNonEmpty;
+exports.isOutOfBound = isOutOfBound;
+exports.last = last;
+exports.lefts = lefts;
+exports.let = let_;
+exports.lookup = lookup;
+exports.makeBy = makeBy;
+exports.map = map;
+exports.mapWithIndex = mapWithIndex;
+exports.match = match;
+exports.matchLeft = matchLeft;
+exports.matchLeftW = matchLeftW;
+exports.matchRight = matchRight;
+exports.matchRightW = matchRightW;
+exports.matchW = matchW;
+exports.modifyAt = modifyAt;
+exports.of = of;
+exports.partition = partition;
+exports.partitionMap = partitionMap;
+exports.partitionMapWithIndex = partitionMapWithIndex;
+exports.partitionWithIndex = partitionWithIndex;
+exports.prepend = prepend;
+exports.prependAll = prependAll;
+exports.prependToAll = prependToAll;
+exports.prependW = prependW;
+exports.range = range;
+exports.readonlyArray = readonlyArray;
+exports.reduce = reduce;
+exports.reduceRight = reduceRight;
+exports.reduceRightWithIndex = reduceRightWithIndex;
+exports.reduceWithIndex = reduceWithIndex;
+exports.replicate = replicate;
+exports.reverse = reverse;
+exports.rights = rights;
+exports.rotate = rotate;
+exports.scanLeft = scanLeft;
+exports.scanRight = scanRight;
+exports.separate = separate;
+exports.sequence = sequence;
+exports.size = size;
+exports.snoc = snoc;
+exports.some = some;
+exports.sort = sort;
+exports.sortBy = sortBy;
+exports.spanLeft = spanLeft;
+exports.splitAt = splitAt;
+exports.tail = tail;
+exports.takeLeft = takeLeft;
+exports.takeLeftWhile = takeLeftWhile;
+exports.takeRight = takeRight;
+exports.toArray = toArray;
+exports.traverse = traverse;
+exports.traverseWithIndex = traverseWithIndex;
+exports.unfold = unfold;
+exports.union = union;
+exports.uniq = uniq;
+exports.unsafeDeleteAt = unsafeDeleteAt;
+exports.unsafeInsertAt = unsafeInsertAt;
+exports.unsafeUpdateAt = unsafeUpdateAt;
+exports.unzip = unzip;
+exports.updateAt = updateAt;
+exports.wilt = wilt;
+exports.wither = wither;
+exports.zero = zero;
+exports.zip = zip;
+exports.zipWith = zipWith;
+//# sourceMappingURL=ReadonlyArray.cjs.map