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

package/dist/_node_modules/fp-ts/lib/ReadonlyArray.js

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