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

@@ -0,0 +1,1300 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const _commonjsHelpers = require("../../../_virtual/_commonjsHelpers.cjs");
+const ReadonlyArray = require("../../../_virtual/ReadonlyArray.cjs");
+const Apply = require("./Apply.cjs");
+const Chain = require("./Chain.cjs");
+const Eq = require("./Eq.cjs");
+const FromEither = require("./FromEither.cjs");
+const _function = require("./function.cjs");
+const Functor = 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 = require("./Witherable.cjs");
+const Zero = require("./Zero.cjs");
+var hasRequiredReadonlyArray;
+function requireReadonlyArray() {
+  if (hasRequiredReadonlyArray)
+    return ReadonlyArray.__exports;
+  hasRequiredReadonlyArray = 1;
+  (function(exports2) {
+    var __createBinding = _commonjsHelpers.commonjsGlobal && _commonjsHelpers.commonjsGlobal.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = _commonjsHelpers.commonjsGlobal && _commonjsHelpers.commonjsGlobal.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = _commonjsHelpers.commonjsGlobal && _commonjsHelpers.commonjsGlobal.__importStar || function(mod) {
+      if (mod && mod.__esModule)
+        return mod;
+      var result = {};
+      if (mod != null) {
+        for (var k in mod)
+          if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
+            __createBinding(result, mod, k);
+      }
+      __setModuleDefault(result, mod);
+      return result;
+    };
+    var __spreadArray = _commonjsHelpers.commonjsGlobal && _commonjsHelpers.commonjsGlobal.__spreadArray || function(to, from, pack) {
+      if (pack || arguments.length === 2)
+        for (var i = 0, l = from.length, ar; i < l; i++) {
+          if (ar || !(i in from)) {
+            if (!ar)
+              ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+          }
+        }
+      return to.concat(ar || Array.prototype.slice.call(from));
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.sort = exports2.lefts = exports2.rights = exports2.reverse = exports2.modifyAt = exports2.deleteAt = exports2.updateAt = exports2.insertAt = exports2.findLastIndex = exports2.findLastMap = exports2.findLast = exports2.findFirstMap = exports2.findFirst = exports2.findIndex = exports2.dropLeftWhile = exports2.dropRight = exports2.dropLeft = exports2.spanLeft = exports2.takeLeftWhile = exports2.takeRight = exports2.takeLeft = exports2.init = exports2.tail = exports2.last = exports2.head = exports2.lookup = exports2.isOutOfBound = exports2.size = exports2.scanRight = exports2.scanLeft = exports2.chainWithIndex = exports2.foldRight = exports2.matchRight = exports2.matchRightW = exports2.foldLeft = exports2.matchLeft = exports2.matchLeftW = exports2.match = exports2.matchW = exports2.fromEither = exports2.fromOption = exports2.fromPredicate = exports2.replicate = exports2.makeBy = exports2.appendW = exports2.append = exports2.prependW = exports2.prepend = exports2.isNonEmpty = exports2.isEmpty = void 0;
+    exports2.sequence = exports2.traverse = exports2.reduceRightWithIndex = exports2.reduceRight = exports2.reduceWithIndex = exports2.foldMap = exports2.reduce = exports2.foldMapWithIndex = exports2.duplicate = exports2.extend = exports2.filterWithIndex = exports2.partitionMapWithIndex = exports2.partitionMap = exports2.partitionWithIndex = exports2.partition = exports2.compact = exports2.filterMap = exports2.filterMapWithIndex = exports2.filter = exports2.separate = exports2.mapWithIndex = exports2.map = exports2.flatten = exports2.flatMap = exports2.ap = exports2.alt = exports2.altW = exports2.zero = exports2.of = exports2._chainRecBreadthFirst = exports2._chainRecDepthFirst = exports2.difference = exports2.intersection = exports2.union = exports2.concat = exports2.concatW = exports2.comprehension = exports2.fromOptionK = exports2.chunksOf = exports2.splitAt = exports2.chop = exports2.sortBy = exports2.uniq = exports2.elem = exports2.rotate = exports2.intersperse = exports2.prependAll = exports2.unzip = exports2.zip = exports2.zipWith = void 0;
+    exports2.toArray = exports2.unsafeDeleteAt = exports2.unsafeUpdateAt = exports2.unsafeInsertAt = exports2.fromEitherK = exports2.FromEither = exports2.filterE = exports2.Witherable = exports2.ChainRecBreadthFirst = exports2.chainRecBreadthFirst = exports2.ChainRecDepthFirst = exports2.chainRecDepthFirst = exports2.TraversableWithIndex = exports2.Traversable = exports2.FoldableWithIndex = exports2.Foldable = exports2.FilterableWithIndex = exports2.Filterable = exports2.Compactable = exports2.Extend = exports2.Alternative = exports2.guard = exports2.Zero = exports2.Alt = exports2.Unfoldable = exports2.chainFirst = exports2.Monad = exports2.Chain = exports2.Applicative = exports2.apSecond = exports2.apFirst = exports2.Apply = exports2.FunctorWithIndex = exports2.Pointed = exports2.flap = exports2.Functor = exports2.getDifferenceMagma = exports2.getIntersectionSemigroup = exports2.getUnionMonoid = exports2.getUnionSemigroup = exports2.getOrd = exports2.getEq = exports2.getMonoid = exports2.getSemigroup = exports2.getShow = exports2.URI = exports2.unfold = exports2.wilt = exports2.wither = exports2.traverseWithIndex = void 0;
+    exports2.readonlyArray = exports2.prependToAll = exports2.snoc = exports2.cons = exports2.range = exports2.chain = exports2.apS = exports2.bind = exports2.let = exports2.bindTo = exports2.Do = exports2.intercalate = exports2.exists = exports2.some = exports2.every = exports2.empty = exports2.fromArray = void 0;
+    var Apply_1 = Apply.__require();
+    var Chain_1 = Chain.__require();
+    var Eq_1 = Eq.__require();
+    var FromEither_1 = FromEither.__require();
+    var function_1 = _function.__require();
+    var Functor_1 = Functor.__require();
+    var _ = __importStar(internal.__require());
+    var N = __importStar(number.__require());
+    var Ord_1 = Ord.__require();
+    var RNEA = __importStar(ReadonlyNonEmptyArray.__require());
+    var Separated_1 = Separated.__require();
+    var Witherable_1 = Witherable.__require();
+    var Zero_1 = Zero.__require();
+    var isEmpty = function(as) {
+      return as.length === 0;
+    };
+    exports2.isEmpty = isEmpty;
+    exports2.isNonEmpty = RNEA.isNonEmpty;
+    exports2.prepend = RNEA.prepend;
+    exports2.prependW = RNEA.prependW;
+    exports2.append = RNEA.append;
+    exports2.appendW = RNEA.appendW;
+    var makeBy = function(n, f) {
+      return n <= 0 ? exports2.empty : RNEA.makeBy(f)(n);
+    };
+    exports2.makeBy = makeBy;
+    var replicate = function(n, a) {
+      return (0, exports2.makeBy)(n, function() {
+        return a;
+      });
+    };
+    exports2.replicate = replicate;
+    function fromPredicate(predicate) {
+      return function(a) {
+        return predicate(a) ? [a] : exports2.empty;
+      };
+    }
+    exports2.fromPredicate = fromPredicate;
+    var fromOption = function(ma) {
+      return _.isNone(ma) ? exports2.empty : [ma.value];
+    };
+    exports2.fromOption = fromOption;
+    var fromEither = function(e) {
+      return _.isLeft(e) ? exports2.empty : [e.right];
+    };
+    exports2.fromEither = fromEither;
+    var matchW = function(onEmpty, onNonEmpty) {
+      return function(as) {
+        return (0, exports2.isNonEmpty)(as) ? onNonEmpty(as) : onEmpty();
+      };
+    };
+    exports2.matchW = matchW;
+    exports2.match = exports2.matchW;
+    var matchLeftW = function(onEmpty, onNonEmpty) {
+      return function(as) {
+        return (0, exports2.isNonEmpty)(as) ? onNonEmpty(RNEA.head(as), RNEA.tail(as)) : onEmpty();
+      };
+    };
+    exports2.matchLeftW = matchLeftW;
+    exports2.matchLeft = exports2.matchLeftW;
+    exports2.foldLeft = exports2.matchLeft;
+    var matchRightW = function(onEmpty, onNonEmpty) {
+      return function(as) {
+        return (0, exports2.isNonEmpty)(as) ? onNonEmpty(RNEA.init(as), RNEA.last(as)) : onEmpty();
+      };
+    };
+    exports2.matchRightW = matchRightW;
+    exports2.matchRight = exports2.matchRightW;
+    exports2.foldRight = exports2.matchRight;
+    var chainWithIndex = function(f) {
+      return function(as) {
+        if ((0, exports2.isEmpty)(as)) {
+          return exports2.empty;
+        }
+        var out = [];
+        for (var i = 0; i < as.length; i++) {
+          out.push.apply(out, f(i, as[i]));
+        }
+        return out;
+      };
+    };
+    exports2.chainWithIndex = chainWithIndex;
+    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;
+      };
+    };
+    exports2.scanLeft = scanLeft;
+    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;
+      };
+    };
+    exports2.scanRight = scanRight;
+    var size = function(as) {
+      return as.length;
+    };
+    exports2.size = size;
+    exports2.isOutOfBound = RNEA.isOutOfBound;
+    function lookup(i, as) {
+      return as === void 0 ? function(as2) {
+        return lookup(i, as2);
+      } : (0, exports2.isOutOfBound)(i, as) ? _.none : _.some(as[i]);
+    }
+    exports2.lookup = lookup;
+    var head = function(as) {
+      return (0, exports2.isNonEmpty)(as) ? _.some(RNEA.head(as)) : _.none;
+    };
+    exports2.head = head;
+    var last = function(as) {
+      return (0, exports2.isNonEmpty)(as) ? _.some(RNEA.last(as)) : _.none;
+    };
+    exports2.last = last;
+    var tail = function(as) {
+      return (0, exports2.isNonEmpty)(as) ? _.some(RNEA.tail(as)) : _.none;
+    };
+    exports2.tail = tail;
+    var init = function(as) {
+      return (0, exports2.isNonEmpty)(as) ? _.some(RNEA.init(as)) : _.none;
+    };
+    exports2.init = init;
+    var takeLeft = function(n) {
+      return function(as) {
+        return (0, exports2.isOutOfBound)(n, as) ? as : n === 0 ? exports2.empty : as.slice(0, n);
+      };
+    };
+    exports2.takeLeft = takeLeft;
+    var takeRight = function(n) {
+      return function(as) {
+        return (0, exports2.isOutOfBound)(n, as) ? as : n === 0 ? exports2.empty : as.slice(-n);
+      };
+    };
+    exports2.takeRight = takeRight;
+    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 ? exports2.empty : out;
+      };
+    }
+    exports2.takeLeftWhile = takeLeftWhile;
+    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 = (0, exports2.splitAt)(spanLeftIndex(as, predicate))(as), init2 = _a[0], rest = _a[1];
+        return { init: init2, rest };
+      };
+    }
+    exports2.spanLeft = spanLeft;
+    var dropLeft = function(n) {
+      return function(as) {
+        return n <= 0 || (0, exports2.isEmpty)(as) ? as : n >= as.length ? exports2.empty : as.slice(n, as.length);
+      };
+    };
+    exports2.dropLeft = dropLeft;
+    var dropRight = function(n) {
+      return function(as) {
+        return n <= 0 || (0, exports2.isEmpty)(as) ? as : n >= as.length ? exports2.empty : as.slice(0, as.length - n);
+      };
+    };
+    exports2.dropRight = dropRight;
+    function dropLeftWhile(predicate) {
+      return function(as) {
+        var i = spanLeftIndex(as, predicate);
+        return i === 0 ? as : i === as.length ? exports2.empty : as.slice(i);
+      };
+    }
+    exports2.dropLeftWhile = dropLeftWhile;
+    var findIndex = function(predicate) {
+      return function(as) {
+        for (var i = 0; i < as.length; i++) {
+          if (predicate(as[i])) {
+            return _.some(i);
+          }
+        }
+        return _.none;
+      };
+    };
+    exports2.findIndex = findIndex;
+    function findFirst(predicate) {
+      return function(as) {
+        for (var i = 0; i < as.length; i++) {
+          if (predicate(as[i])) {
+            return _.some(as[i]);
+          }
+        }
+        return _.none;
+      };
+    }
+    exports2.findFirst = findFirst;
+    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;
+      };
+    };
+    exports2.findFirstMap = findFirstMap;
+    function findLast(predicate) {
+      return function(as) {
+        for (var i = as.length - 1; i >= 0; i--) {
+          if (predicate(as[i])) {
+            return _.some(as[i]);
+          }
+        }
+        return _.none;
+      };
+    }
+    exports2.findLast = findLast;
+    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;
+      };
+    };
+    exports2.findLastMap = findLastMap;
+    var findLastIndex = function(predicate) {
+      return function(as) {
+        for (var i = as.length - 1; i >= 0; i--) {
+          if (predicate(as[i])) {
+            return _.some(i);
+          }
+        }
+        return _.none;
+      };
+    };
+    exports2.findLastIndex = findLastIndex;
+    var insertAt = function(i, a) {
+      return function(as) {
+        return i < 0 || i > as.length ? _.none : _.some(RNEA.unsafeInsertAt(i, a, as));
+      };
+    };
+    exports2.insertAt = insertAt;
+    var updateAt = function(i, a) {
+      return (0, exports2.modifyAt)(i, function() {
+        return a;
+      });
+    };
+    exports2.updateAt = updateAt;
+    var deleteAt = function(i) {
+      return function(as) {
+        return (0, exports2.isOutOfBound)(i, as) ? _.none : _.some((0, exports2.unsafeDeleteAt)(i, as));
+      };
+    };
+    exports2.deleteAt = deleteAt;
+    var modifyAt = function(i, f) {
+      return function(as) {
+        return (0, exports2.isOutOfBound)(i, as) ? _.none : _.some((0, exports2.unsafeUpdateAt)(i, f(as[i]), as));
+      };
+    };
+    exports2.modifyAt = modifyAt;
+    var reverse = function(as) {
+      return as.length <= 1 ? as : as.slice().reverse();
+    };
+    exports2.reverse = 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;
+    };
+    exports2.rights = rights;
+    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;
+    };
+    exports2.lefts = lefts;
+    var sort = function(O) {
+      return function(as) {
+        return as.length <= 1 ? as : as.slice().sort(O.compare);
+      };
+    };
+    exports2.sort = sort;
+    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;
+    };
+    exports2.zipWith = zipWith;
+    function zip(as, bs) {
+      if (bs === void 0) {
+        return function(bs2) {
+          return zip(bs2, as);
+        };
+      }
+      return (0, exports2.zipWith)(as, bs, function(a, b) {
+        return [a, b];
+      });
+    }
+    exports2.zip = zip;
+    var unzip = function(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];
+    };
+    exports2.unzip = unzip;
+    var prependAll = function(middle) {
+      var f = RNEA.prependAll(middle);
+      return function(as) {
+        return (0, exports2.isNonEmpty)(as) ? f(as) : as;
+      };
+    };
+    exports2.prependAll = prependAll;
+    var intersperse = function(middle) {
+      var f = RNEA.intersperse(middle);
+      return function(as) {
+        return (0, exports2.isNonEmpty)(as) ? f(as) : as;
+      };
+    };
+    exports2.intersperse = intersperse;
+    var rotate = function(n) {
+      var f = RNEA.rotate(n);
+      return function(as) {
+        return (0, exports2.isNonEmpty)(as) ? f(as) : as;
+      };
+    };
+    exports2.rotate = rotate;
+    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;
+      };
+    }
+    exports2.elem = elem;
+    var uniq = function(E) {
+      var f = RNEA.uniq(E);
+      return function(as) {
+        return (0, exports2.isNonEmpty)(as) ? f(as) : as;
+      };
+    };
+    exports2.uniq = uniq;
+    var sortBy = function(ords) {
+      var f = RNEA.sortBy(ords);
+      return function(as) {
+        return (0, exports2.isNonEmpty)(as) ? f(as) : as;
+      };
+    };
+    exports2.sortBy = sortBy;
+    var chop = function(f) {
+      var g = RNEA.chop(f);
+      return function(as) {
+        return (0, exports2.isNonEmpty)(as) ? g(as) : exports2.empty;
+      };
+    };
+    exports2.chop = chop;
+    var splitAt = function(n) {
+      return function(as) {
+        return n >= 1 && (0, exports2.isNonEmpty)(as) ? RNEA.splitAt(n)(as) : (0, exports2.isEmpty)(as) ? [as, exports2.empty] : [exports2.empty, as];
+      };
+    };
+    exports2.splitAt = splitAt;
+    var chunksOf = function(n) {
+      var f = RNEA.chunksOf(n);
+      return function(as) {
+        return (0, exports2.isNonEmpty)(as) ? f(as) : exports2.empty;
+      };
+    };
+    exports2.chunksOf = chunksOf;
+    var fromOptionK = function(f) {
+      return function() {
+        var a = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          a[_i] = arguments[_i];
+        }
+        return (0, exports2.fromOption)(f.apply(void 0, a));
+      };
+    };
+    exports2.fromOptionK = fromOptionK;
+    function comprehension(input, f, g) {
+      if (g === void 0) {
+        g = function() {
+          return true;
+        };
+      }
+      var go = function(scope, input2) {
+        return (0, exports2.isNonEmpty)(input2) ? (0, exports2.flatMap)(RNEA.head(input2), function(a) {
+          return go((0, function_1.pipe)(scope, (0, exports2.append)(a)), RNEA.tail(input2));
+        }) : g.apply(void 0, scope) ? [f.apply(void 0, scope)] : exports2.empty;
+      };
+      return go(exports2.empty, input);
+    }
+    exports2.comprehension = comprehension;
+    var concatW = function(second) {
+      return function(first) {
+        return (0, exports2.isEmpty)(first) ? second : (0, exports2.isEmpty)(second) ? first : first.concat(second);
+      };
+    };
+    exports2.concatW = concatW;
+    exports2.concat = exports2.concatW;
+    function union(E) {
+      var unionE = RNEA.union(E);
+      return function(first, second) {
+        if (second === void 0) {
+          var unionE_1 = union(E);
+          return function(second2) {
+            return unionE_1(second2, first);
+          };
+        }
+        return (0, exports2.isNonEmpty)(first) && (0, exports2.isNonEmpty)(second) ? unionE(second)(first) : (0, exports2.isNonEmpty)(first) ? first : second;
+      };
+    }
+    exports2.union = union;
+    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);
+        });
+      };
+    }
+    exports2.intersection = intersection;
+    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);
+        });
+      };
+    }
+    exports2.difference = difference;
+    var _map = function(fa, f) {
+      return (0, function_1.pipe)(fa, (0, exports2.map)(f));
+    };
+    var _mapWithIndex = function(fa, f) {
+      return (0, function_1.pipe)(fa, (0, exports2.mapWithIndex)(f));
+    };
+    var _ap = function(fab, fa) {
+      return (0, function_1.pipe)(fab, (0, exports2.ap)(fa));
+    };
+    var _filter = function(fa, predicate) {
+      return (0, function_1.pipe)(fa, (0, exports2.filter)(predicate));
+    };
+    var _filterMap = function(fa, f) {
+      return (0, function_1.pipe)(fa, (0, exports2.filterMap)(f));
+    };
+    var _partition = function(fa, predicate) {
+      return (0, function_1.pipe)(fa, (0, exports2.partition)(predicate));
+    };
+    var _partitionMap = function(fa, f) {
+      return (0, function_1.pipe)(fa, (0, exports2.partitionMap)(f));
+    };
+    var _partitionWithIndex = function(fa, predicateWithIndex) {
+      return (0, function_1.pipe)(fa, (0, exports2.partitionWithIndex)(predicateWithIndex));
+    };
+    var _partitionMapWithIndex = function(fa, f) {
+      return (0, function_1.pipe)(fa, (0, exports2.partitionMapWithIndex)(f));
+    };
+    var _alt = function(fa, that) {
+      return (0, function_1.pipe)(fa, (0, exports2.alt)(that));
+    };
+    var _reduce = function(fa, b, f) {
+      return (0, function_1.pipe)(fa, (0, exports2.reduce)(b, f));
+    };
+    var _foldMap = function(M) {
+      var foldMapM = (0, exports2.foldMap)(M);
+      return function(fa, f) {
+        return (0, function_1.pipe)(fa, foldMapM(f));
+      };
+    };
+    var _reduceRight = function(fa, b, f) {
+      return (0, function_1.pipe)(fa, (0, exports2.reduceRight)(b, f));
+    };
+    var _reduceWithIndex = function(fa, b, f) {
+      return (0, function_1.pipe)(fa, (0, exports2.reduceWithIndex)(b, f));
+    };
+    var _foldMapWithIndex = function(M) {
+      var foldMapWithIndexM = (0, exports2.foldMapWithIndex)(M);
+      return function(fa, f) {
+        return (0, function_1.pipe)(fa, foldMapWithIndexM(f));
+      };
+    };
+    var _reduceRightWithIndex = function(fa, b, f) {
+      return (0, function_1.pipe)(fa, (0, exports2.reduceRightWithIndex)(b, f));
+    };
+    var _filterMapWithIndex = function(fa, f) {
+      return (0, function_1.pipe)(fa, (0, exports2.filterMapWithIndex)(f));
+    };
+    var _filterWithIndex = function(fa, predicateWithIndex) {
+      return (0, function_1.pipe)(fa, (0, exports2.filterWithIndex)(predicateWithIndex));
+    };
+    var _extend = function(fa, f) {
+      return (0, function_1.pipe)(fa, (0, exports2.extend)(f));
+    };
+    var _traverse = function(F) {
+      var traverseF = (0, exports2.traverse)(F);
+      return function(ta, f) {
+        return (0, function_1.pipe)(ta, traverseF(f));
+      };
+    };
+    var _traverseWithIndex = function(F) {
+      var traverseWithIndexF = (0, exports2.traverseWithIndex)(F);
+      return function(ta, f) {
+        return (0, function_1.pipe)(ta, traverseWithIndexF(f));
+      };
+    };
+    var _chainRecDepthFirst = function(a, f) {
+      return (0, function_1.pipe)(a, (0, exports2.chainRecDepthFirst)(f));
+    };
+    exports2._chainRecDepthFirst = _chainRecDepthFirst;
+    var _chainRecBreadthFirst = function(a, f) {
+      return (0, function_1.pipe)(a, (0, exports2.chainRecBreadthFirst)(f));
+    };
+    exports2._chainRecBreadthFirst = _chainRecBreadthFirst;
+    exports2.of = RNEA.of;
+    var zero = function() {
+      return exports2.empty;
+    };
+    exports2.zero = zero;
+    var altW = function(that) {
+      return function(fa) {
+        return fa.concat(that());
+      };
+    };
+    exports2.altW = altW;
+    exports2.alt = exports2.altW;
+    var ap = function(fa) {
+      return (0, exports2.flatMap)(function(f) {
+        return (0, function_1.pipe)(fa, (0, exports2.map)(f));
+      });
+    };
+    exports2.ap = ap;
+    exports2.flatMap = (0, function_1.dual)(2, function(ma, f) {
+      return (0, function_1.pipe)(ma, (0, exports2.chainWithIndex)(function(i, a) {
+        return f(a, i);
+      }));
+    });
+    exports2.flatten = (0, exports2.flatMap)(function_1.identity);
+    var map = function(f) {
+      return function(fa) {
+        return fa.map(function(a) {
+          return f(a);
+        });
+      };
+    };
+    exports2.map = map;
+    var mapWithIndex = function(f) {
+      return function(fa) {
+        return fa.map(function(a, i) {
+          return f(i, a);
+        });
+      };
+    };
+    exports2.mapWithIndex = mapWithIndex;
+    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 (0, Separated_1.separated)(left, right);
+    };
+    exports2.separate = separate;
+    var filter = function(predicate) {
+      return function(as) {
+        return as.filter(predicate);
+      };
+    };
+    exports2.filter = filter;
+    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;
+      };
+    };
+    exports2.filterMapWithIndex = filterMapWithIndex;
+    var filterMap = function(f) {
+      return (0, exports2.filterMapWithIndex)(function(_2, a) {
+        return f(a);
+      });
+    };
+    exports2.filterMap = filterMap;
+    exports2.compact = (0, exports2.filterMap)(function_1.identity);
+    var partition = function(predicate) {
+      return (0, exports2.partitionWithIndex)(function(_2, a) {
+        return predicate(a);
+      });
+    };
+    exports2.partition = partition;
+    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 (0, Separated_1.separated)(left, right);
+      };
+    };
+    exports2.partitionWithIndex = partitionWithIndex;
+    var partitionMap = function(f) {
+      return (0, exports2.partitionMapWithIndex)(function(_2, a) {
+        return f(a);
+      });
+    };
+    exports2.partitionMap = partitionMap;
+    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 (0, Separated_1.separated)(left, right);
+      };
+    };
+    exports2.partitionMapWithIndex = partitionMapWithIndex;
+    var filterWithIndex = function(predicateWithIndex) {
+      return function(as) {
+        return as.filter(function(a, i) {
+          return predicateWithIndex(i, a);
+        });
+      };
+    };
+    exports2.filterWithIndex = filterWithIndex;
+    var extend = function(f) {
+      return function(wa) {
+        return wa.map(function(_2, i) {
+          return f(wa.slice(i));
+        });
+      };
+    };
+    exports2.extend = extend;
+    exports2.duplicate = (0, exports2.extend)(function_1.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);
+        };
+      };
+    };
+    exports2.foldMapWithIndex = foldMapWithIndex;
+    var reduce = function(b, f) {
+      return (0, exports2.reduceWithIndex)(b, function(_2, b2, a) {
+        return f(b2, a);
+      });
+    };
+    exports2.reduce = reduce;
+    var foldMap = function(M) {
+      var foldMapWithIndexM = (0, exports2.foldMapWithIndex)(M);
+      return function(f) {
+        return foldMapWithIndexM(function(_2, a) {
+          return f(a);
+        });
+      };
+    };
+    exports2.foldMap = foldMap;
+    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;
+      };
+    };
+    exports2.reduceWithIndex = reduceWithIndex;
+    var reduceRight = function(b, f) {
+      return (0, exports2.reduceRightWithIndex)(b, function(_2, a, b2) {
+        return f(a, b2);
+      });
+    };
+    exports2.reduceRight = reduceRight;
+    var reduceRightWithIndex = function(b, f) {
+      return function(fa) {
+        return fa.reduceRight(function(b2, a, i) {
+          return f(i, a, b2);
+        }, b);
+      };
+    };
+    exports2.reduceRightWithIndex = reduceRightWithIndex;
+    var traverse = function(F) {
+      var traverseWithIndexF = (0, exports2.traverseWithIndex)(F);
+      return function(f) {
+        return traverseWithIndexF(function(_2, a) {
+          return f(a);
+        });
+      };
+    };
+    exports2.traverse = traverse;
+    var sequence = function(F) {
+      return function(ta) {
+        return _reduce(ta, F.of((0, exports2.zero)()), function(fas, fa) {
+          return F.ap(F.map(fas, function(as) {
+            return function(a) {
+              return (0, function_1.pipe)(as, (0, exports2.append)(a));
+            };
+          }), fa);
+        });
+      };
+    };
+    exports2.sequence = sequence;
+    var traverseWithIndex = function(F) {
+      return function(f) {
+        return (0, exports2.reduceWithIndex)(F.of((0, exports2.zero)()), function(i, fbs, a) {
+          return F.ap(F.map(fbs, function(bs) {
+            return function(b) {
+              return (0, function_1.pipe)(bs, (0, exports2.append)(b));
+            };
+          }), f(i, a));
+        });
+      };
+    };
+    exports2.traverseWithIndex = traverseWithIndex;
+    var wither = function(F) {
+      var _witherF = _wither(F);
+      return function(f) {
+        return function(fa) {
+          return _witherF(fa, f);
+        };
+      };
+    };
+    exports2.wither = wither;
+    var wilt = function(F) {
+      var _wiltF = _wilt(F);
+      return function(f) {
+        return function(fa) {
+          return _wiltF(fa, f);
+        };
+      };
+    };
+    exports2.wilt = wilt;
+    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;
+    };
+    exports2.unfold = unfold;
+    exports2.URI = "ReadonlyArray";
+    var getShow = function(S) {
+      return {
+        show: function(as) {
+          return "[".concat(as.map(S.show).join(", "), "]");
+        }
+      };
+    };
+    exports2.getShow = getShow;
+    var getSemigroup = function() {
+      return {
+        concat: function(first, second) {
+          return (0, exports2.isEmpty)(first) ? second : (0, exports2.isEmpty)(second) ? first : first.concat(second);
+        }
+      };
+    };
+    exports2.getSemigroup = getSemigroup;
+    var getMonoid = function() {
+      return {
+        concat: (0, exports2.getSemigroup)().concat,
+        empty: exports2.empty
+      };
+    };
+    exports2.getMonoid = getMonoid;
+    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]);
+        });
+      });
+    };
+    exports2.getEq = getEq;
+    var getOrd = function(O) {
+      return (0, Ord_1.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 N.Ord.compare(aLen, bLen);
+      });
+    };
+    exports2.getOrd = getOrd;
+    var getUnionSemigroup = function(E) {
+      var unionE = union(E);
+      return {
+        concat: function(first, second) {
+          return unionE(second)(first);
+        }
+      };
+    };
+    exports2.getUnionSemigroup = getUnionSemigroup;
+    var getUnionMonoid = function(E) {
+      return {
+        concat: (0, exports2.getUnionSemigroup)(E).concat,
+        empty: exports2.empty
+      };
+    };
+    exports2.getUnionMonoid = getUnionMonoid;
+    var getIntersectionSemigroup = function(E) {
+      var intersectionE = intersection(E);
+      return {
+        concat: function(first, second) {
+          return intersectionE(second)(first);
+        }
+      };
+    };
+    exports2.getIntersectionSemigroup = getIntersectionSemigroup;
+    var getDifferenceMagma = function(E) {
+      var differenceE = difference(E);
+      return {
+        concat: function(first, second) {
+          return differenceE(second)(first);
+        }
+      };
+    };
+    exports2.getDifferenceMagma = getDifferenceMagma;
+    exports2.Functor = {
+      URI: exports2.URI,
+      map: _map
+    };
+    exports2.flap = (0, Functor_1.flap)(exports2.Functor);
+    exports2.Pointed = {
+      URI: exports2.URI,
+      of: exports2.of
+    };
+    exports2.FunctorWithIndex = {
+      URI: exports2.URI,
+      map: _map,
+      mapWithIndex: _mapWithIndex
+    };
+    exports2.Apply = {
+      URI: exports2.URI,
+      map: _map,
+      ap: _ap
+    };
+    exports2.apFirst = (0, Apply_1.apFirst)(exports2.Apply);
+    exports2.apSecond = (0, Apply_1.apSecond)(exports2.Apply);
+    exports2.Applicative = {
+      URI: exports2.URI,
+      map: _map,
+      ap: _ap,
+      of: exports2.of
+    };
+    exports2.Chain = {
+      URI: exports2.URI,
+      map: _map,
+      ap: _ap,
+      chain: exports2.flatMap
+    };
+    exports2.Monad = {
+      URI: exports2.URI,
+      map: _map,
+      ap: _ap,
+      of: exports2.of,
+      chain: exports2.flatMap
+    };
+    exports2.chainFirst = /* @__PURE__ */ (0, Chain_1.chainFirst)(exports2.Chain);
+    exports2.Unfoldable = {
+      URI: exports2.URI,
+      unfold: exports2.unfold
+    };
+    exports2.Alt = {
+      URI: exports2.URI,
+      map: _map,
+      alt: _alt
+    };
+    exports2.Zero = {
+      URI: exports2.URI,
+      zero: exports2.zero
+    };
+    exports2.guard = (0, Zero_1.guard)(exports2.Zero, exports2.Pointed);
+    exports2.Alternative = {
+      URI: exports2.URI,
+      map: _map,
+      ap: _ap,
+      of: exports2.of,
+      alt: _alt,
+      zero: exports2.zero
+    };
+    exports2.Extend = {
+      URI: exports2.URI,
+      map: _map,
+      extend: _extend
+    };
+    exports2.Compactable = {
+      URI: exports2.URI,
+      compact: exports2.compact,
+      separate: exports2.separate
+    };
+    exports2.Filterable = {
+      URI: exports2.URI,
+      map: _map,
+      compact: exports2.compact,
+      separate: exports2.separate,
+      filter: _filter,
+      filterMap: _filterMap,
+      partition: _partition,
+      partitionMap: _partitionMap
+    };
+    exports2.FilterableWithIndex = {
+      URI: exports2.URI,
+      map: _map,
+      mapWithIndex: _mapWithIndex,
+      compact: exports2.compact,
+      separate: exports2.separate,
+      filter: _filter,
+      filterMap: _filterMap,
+      partition: _partition,
+      partitionMap: _partitionMap,
+      partitionMapWithIndex: _partitionMapWithIndex,
+      partitionWithIndex: _partitionWithIndex,
+      filterMapWithIndex: _filterMapWithIndex,
+      filterWithIndex: _filterWithIndex
+    };
+    exports2.Foldable = {
+      URI: exports2.URI,
+      reduce: _reduce,
+      foldMap: _foldMap,
+      reduceRight: _reduceRight
+    };
+    exports2.FoldableWithIndex = {
+      URI: exports2.URI,
+      reduce: _reduce,
+      foldMap: _foldMap,
+      reduceRight: _reduceRight,
+      reduceWithIndex: _reduceWithIndex,
+      foldMapWithIndex: _foldMapWithIndex,
+      reduceRightWithIndex: _reduceRightWithIndex
+    };
+    exports2.Traversable = {
+      URI: exports2.URI,
+      map: _map,
+      reduce: _reduce,
+      foldMap: _foldMap,
+      reduceRight: _reduceRight,
+      traverse: _traverse,
+      sequence: exports2.sequence
+    };
+    exports2.TraversableWithIndex = {
+      URI: exports2.URI,
+      map: _map,
+      mapWithIndex: _mapWithIndex,
+      reduce: _reduce,
+      foldMap: _foldMap,
+      reduceRight: _reduceRight,
+      reduceWithIndex: _reduceWithIndex,
+      foldMapWithIndex: _foldMapWithIndex,
+      reduceRightWithIndex: _reduceRightWithIndex,
+      traverse: _traverse,
+      sequence: exports2.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;
+      };
+    };
+    exports2.chainRecDepthFirst = chainRecDepthFirst;
+    exports2.ChainRecDepthFirst = {
+      URI: exports2.URI,
+      map: _map,
+      ap: _ap,
+      chain: exports2.flatMap,
+      chainRec: exports2._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;
+      };
+    };
+    exports2.chainRecBreadthFirst = chainRecBreadthFirst;
+    exports2.ChainRecBreadthFirst = {
+      URI: exports2.URI,
+      map: _map,
+      ap: _ap,
+      chain: exports2.flatMap,
+      chainRec: exports2._chainRecBreadthFirst
+    };
+    var _wither = /* @__PURE__ */ (0, Witherable_1.witherDefault)(exports2.Traversable, exports2.Compactable);
+    var _wilt = /* @__PURE__ */ (0, Witherable_1.wiltDefault)(exports2.Traversable, exports2.Compactable);
+    exports2.Witherable = {
+      URI: exports2.URI,
+      map: _map,
+      compact: exports2.compact,
+      separate: exports2.separate,
+      filter: _filter,
+      filterMap: _filterMap,
+      partition: _partition,
+      partitionMap: _partitionMap,
+      reduce: _reduce,
+      foldMap: _foldMap,
+      reduceRight: _reduceRight,
+      traverse: _traverse,
+      sequence: exports2.sequence,
+      wither: _wither,
+      wilt: _wilt
+    };
+    exports2.filterE = (0, Witherable_1.filterE)(exports2.Witherable);
+    exports2.FromEither = {
+      URI: exports2.URI,
+      fromEither: exports2.fromEither
+    };
+    exports2.fromEitherK = (0, FromEither_1.fromEitherK)(exports2.FromEither);
+    exports2.unsafeInsertAt = RNEA.unsafeInsertAt;
+    var unsafeUpdateAt = function(i, a, as) {
+      return (0, exports2.isNonEmpty)(as) ? RNEA.unsafeUpdateAt(i, a, as) : as;
+    };
+    exports2.unsafeUpdateAt = unsafeUpdateAt;
+    var unsafeDeleteAt = function(i, as) {
+      var xs = as.slice();
+      xs.splice(i, 1);
+      return xs;
+    };
+    exports2.unsafeDeleteAt = unsafeDeleteAt;
+    var toArray = function(as) {
+      return as.slice();
+    };
+    exports2.toArray = toArray;
+    var fromArray = function(as) {
+      return (0, exports2.isEmpty)(as) ? exports2.empty : as.slice();
+    };
+    exports2.fromArray = fromArray;
+    exports2.empty = RNEA.empty;
+    function every(predicate) {
+      return function(as) {
+        return as.every(predicate);
+      };
+    }
+    exports2.every = every;
+    var some = function(predicate) {
+      return function(as) {
+        return as.some(predicate);
+      };
+    };
+    exports2.some = some;
+    exports2.exists = exports2.some;
+    var intercalate = function(M) {
+      var intercalateM = RNEA.intercalate(M);
+      return function(middle) {
+        return (0, exports2.match)(function() {
+          return M.empty;
+        }, intercalateM(middle));
+      };
+    };
+    exports2.intercalate = intercalate;
+    exports2.Do = (0, exports2.of)(_.emptyRecord);
+    exports2.bindTo = (0, Functor_1.bindTo)(exports2.Functor);
+    var let_ = /* @__PURE__ */ (0, Functor_1.let)(exports2.Functor);
+    exports2.let = let_;
+    exports2.bind = (0, Chain_1.bind)(exports2.Chain);
+    exports2.apS = (0, Apply_1.apS)(exports2.Apply);
+    exports2.chain = exports2.flatMap;
+    exports2.range = RNEA.range;
+    exports2.cons = RNEA.cons;
+    exports2.snoc = RNEA.snoc;
+    exports2.prependToAll = exports2.prependAll;
+    exports2.readonlyArray = {
+      URI: exports2.URI,
+      compact: exports2.compact,
+      separate: exports2.separate,
+      map: _map,
+      ap: _ap,
+      of: exports2.of,
+      chain: exports2.flatMap,
+      filter: _filter,
+      filterMap: _filterMap,
+      partition: _partition,
+      partitionMap: _partitionMap,
+      mapWithIndex: _mapWithIndex,
+      partitionMapWithIndex: _partitionMapWithIndex,
+      partitionWithIndex: _partitionWithIndex,
+      filterMapWithIndex: _filterMapWithIndex,
+      filterWithIndex: _filterWithIndex,
+      alt: _alt,
+      zero: exports2.zero,
+      unfold: exports2.unfold,
+      reduce: _reduce,
+      foldMap: _foldMap,
+      reduceRight: _reduceRight,
+      traverse: _traverse,
+      sequence: exports2.sequence,
+      reduceWithIndex: _reduceWithIndex,
+      foldMapWithIndex: _foldMapWithIndex,
+      reduceRightWithIndex: _reduceRightWithIndex,
+      traverseWithIndex: _traverseWithIndex,
+      extend: _extend,
+      wither: _wither,
+      wilt: _wilt
+    };
+  })(ReadonlyArray.__exports);
+  return ReadonlyArray.__exports;
+}
+exports.__require = requireReadonlyArray;
+//# sourceMappingURL=ReadonlyArray.cjs.map