@fncts/base 0.0.1

package/_cjs/collection/immutable/ImmutableArray/api.cjs

@@ -0,0 +1,1807 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.alignWith_ = void 0;
+exports.align_ = align_;
+exports.alt_ = alt_;
+exports.ap_ = ap_;
+exports.append_ = void 0;
+exports.chainRecBreadthFirst = chainRecBreadthFirst;
+exports.chainRecDepthFirst = chainRecDepthFirst;
+exports.chop = void 0;
+exports.chopSelf = chopSelf;
+exports.chop_ = void 0;
+exports.chunksOf_ = chunksOf_;
+exports.collectWhile_ = collectWhile_;
+exports.comprehension = comprehension;
+exports.concat_ = void 0;
+exports.crossWith_ = crossWith_;
+exports.deleteAt_ = deleteAt_;
+exports.differenceSelf = differenceSelf;
+exports.difference_ = difference_;
+exports.dropLastWhile_ = dropLastWhile_;
+exports.dropLast_ = dropLast_;
+exports.dropWhile_ = dropWhile_;
+exports.drop_ = drop_;
+exports.elemSelf = elemSelf;
+exports.elem_ = elem_;
+exports.everyWithIndex_ = void 0;
+exports.every_ = every_;
+exports.exists_ = exists_;
+exports.filterMapWithIndex_ = void 0;
+exports.filterMap_ = filterMap_;
+exports.filter_ = exports.filterWithIndex_ = void 0;
+exports.findIndex_ = findIndex_;
+exports.findLastIndex_ = findLastIndex_;
+exports.findLastMapWithIndex_ = void 0;
+exports.findLastMap_ = findLastMap_;
+exports.findLast_ = findLast_;
+exports.findMapWithIndex_ = void 0;
+exports.findMap_ = findMap_;
+exports.findWithIndex_ = void 0;
+exports.find_ = find_;
+exports.flatten = exports.flatMap_ = exports.flatMapWithIndex_ = void 0;
+exports.fold = fold;
+exports.foldLeftWhile_ = foldLeftWhile_;
+exports.foldLeft_ = exports.foldLeftWithIndex_ = exports.foldLeftWithIndexWhile_ = void 0;
+exports.foldMapSelf = foldMapSelf;
+exports.foldMapWithIndexSelf = void 0;
+exports.foldMapWithIndex_ = foldMapWithIndex_;
+exports.foldMap_ = foldMap_;
+exports.foldRightWhile_ = foldRightWhile_;
+exports.foldRightWithIndex_ = exports.foldRightWithIndexWhile_ = void 0;
+exports.foldRight_ = foldRight_;
+exports.get_ = exports.forEach_ = exports.foldSelf = void 0;
+exports.group = group;
+exports.groupBy_ = groupBy_;
+exports.head = head;
+exports.init = init;
+exports.insertAt_ = insertAt_;
+exports.intersectionSelf = intersectionSelf;
+exports.intersection_ = intersection_;
+exports.intersperse_ = intersperse_;
+exports.isOutOfBound_ = exports.isNonEmpty = exports.isEmpty = void 0;
+exports.join = join;
+exports.last = last;
+exports.lefts = lefts;
+exports.length = void 0;
+exports.mapAccum_ = mapAccum_;
+exports.map_ = exports.mapWithIndex_ = void 0;
+exports.modifyAt_ = modifyAt_;
+exports.partitionMapWithIndex_ = exports.mutate_ = exports.mutableClone = void 0;
+exports.partitionMap_ = partitionMap_;
+exports.partitionWithIndex_ = void 0;
+exports.partition_ = partition_;
+exports.prepend_ = exports.prependAll_ = void 0;
+exports.reverse = reverse;
+exports.rights = rights;
+exports.rotate_ = void 0;
+exports.scanLeft_ = scanLeft_;
+exports.scanRight_ = scanRight_;
+exports.sort = exports.slice_ = exports.sequenceSelf = exports.sequence = void 0;
+exports.sortBy = sortBy;
+exports.spanIndexRight_ = exports.spanIndexLeft_ = void 0;
+exports.spanLeft_ = spanLeft_;
+exports.spanRight_ = spanRight_;
+exports.splitAt_ = void 0;
+exports.splitWhere_ = splitWhere_;
+exports.tail = tail;
+exports.takeLast_ = takeLast_;
+exports.takeWhile_ = takeWhile_;
+exports.take_ = take_;
+exports.traverse_ = exports.traverseWithIndex_ = exports.traverseWithIndexSelf = exports.traverseWithIndex = exports.traverseSelf = exports.traverse = void 0;
+exports.union_ = union_;
+exports.uniq = uniq;
+exports.uniqSelf = uniqSelf;
+exports.unprepend = unprepend;
+exports.unsafeUpdateAt_ = exports.unsafeModifyAt_ = exports.unsafeInsertAt_ = exports.unsafeGet = exports.unsafeDeleteAt_ = exports.unsafeAsMutable = void 0;
+exports.unzip = unzip;
+exports.updateAt_ = updateAt_;
+exports.zipWith_ = exports.wither_ = exports.witherWithIndex_ = exports.witherWithIndexSelf = exports.witherWithIndex = exports.witherSelf = exports.wither = exports.wilt_ = exports.wiltWithIndex_ = exports.wiltWithIndexSelf = exports.wiltWithIndex = exports.wiltSelf = exports.wilt = void 0;
+exports.zip_ = zip_;
+
+var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/These/constructors"));
+
+var tsplus_module_2 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/ImmutableArray/constructors"));
+
+var tsplus_module_3 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"));
+
+var tsplus_module_4 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/definition"));
+
+var tsplus_module_5 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/control/Eval/constructors"));
+
+var tsplus_module_6 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/control/Eval/instance"));
+
+var tsplus_module_7 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/control/Eval/api"));
+
+var tsplus_module_8 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/control/Eval/run"));
+
+var tsplus_module_9 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/constructors"));
+
+var tsplus_module_10 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/ImmutableNonEmptyArray/constructors"));
+
+var tsplus_module_11 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/Dictionary/api"));
+
+var tsplus_module_12 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/Dictionary/definition"));
+
+var tsplus_module_13 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/typeclass/Ord/instances"));
+
+var tsplus_module_14 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/function/api"));
+
+var tsplus_module_15 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Either/destructors"));
+
+var _function = /*#__PURE__*/require("@fncts/base/data/function");
+
+var P = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/typeclass"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const alignWith_ = alignWith_1;
+exports.alignWith_ = alignWith_;
+const append_ = append_1;
+exports.append_ = append_;
+const flatMapWithIndex_ = flatMapWithIndex_1;
+exports.flatMapWithIndex_ = flatMapWithIndex_;
+const flatMap_ = flatMap_1;
+exports.flatMap_ = flatMap_;
+const flatten = flatten_1;
+exports.flatten = flatten;
+const chop_ = chop_1;
+exports.chop_ = chop_;
+const concat_ = concat_1;
+exports.concat_ = concat_;
+const everyWithIndex_ = everyWithIndex_1;
+exports.everyWithIndex_ = everyWithIndex_;
+const filter_ = filter_1;
+exports.filter_ = filter_;
+const filterWithIndex_ = filterWithIndex_1;
+exports.filterWithIndex_ = filterWithIndex_;
+const filterMapWithIndex_ = filterMapWithIndex_1;
+exports.filterMapWithIndex_ = filterMapWithIndex_;
+const findWithIndex_ = findWithIndex_1;
+exports.findWithIndex_ = findWithIndex_;
+const findMapWithIndex_ = findMapWithIndex_1;
+exports.findMapWithIndex_ = findMapWithIndex_;
+const findLastMapWithIndex_ = findLastMapWithIndex_1;
+exports.findLastMapWithIndex_ = findLastMapWithIndex_;
+const foldLeftWithIndex_ = foldLeftWithIndex_1;
+exports.foldLeftWithIndex_ = foldLeftWithIndex_;
+const foldLeft_ = foldLeft_1;
+exports.foldLeft_ = foldLeft_;
+const foldLeftWithIndexWhile_ = foldLeftWithIndexWhile_1;
+exports.foldLeftWithIndexWhile_ = foldLeftWithIndexWhile_;
+const foldSelf = foldSelf_1;
+exports.foldSelf = foldSelf;
+const foldMapWithIndexSelf = foldMapWithIndexSelf_1;
+exports.foldMapWithIndexSelf = foldMapWithIndexSelf;
+const foldRightWithIndex_ = foldRightWithIndex_1;
+exports.foldRightWithIndex_ = foldRightWithIndex_;
+const foldRightWithIndexWhile_ = foldRightWithIndexWhile_1;
+exports.foldRightWithIndexWhile_ = foldRightWithIndexWhile_;
+const forEach_ = forEach_1;
+exports.forEach_ = forEach_;
+const get_ = get_1;
+exports.get_ = get_;
+const isEmpty = isEmpty_1;
+exports.isEmpty = isEmpty;
+const isNonEmpty = isNonEmpty_1;
+exports.isNonEmpty = isNonEmpty;
+const isOutOfBound_ = isOutOfBound_1;
+exports.isOutOfBound_ = isOutOfBound_;
+const length = length_1;
+exports.length = length;
+const map_ = map_1;
+exports.map_ = map_;
+const mapWithIndex_ = mapWithIndex_1;
+exports.mapWithIndex_ = mapWithIndex_;
+const mutate_ = mutate_1;
+exports.mutate_ = mutate_;
+const mutableClone = mutableClone_1;
+exports.mutableClone = mutableClone;
+const partitionWithIndex_ = partitionWithIndex_1;
+exports.partitionWithIndex_ = partitionWithIndex_;
+const partitionMapWithIndex_ = partitionMapWithIndex_1;
+exports.partitionMapWithIndex_ = partitionMapWithIndex_;
+const prepend_ = prepend_1;
+exports.prepend_ = prepend_;
+const prependAll_ = prependAll_1;
+exports.prependAll_ = prependAll_;
+const rotate_ = rotate_1;
+exports.rotate_ = rotate_;
+const sort = sort_1;
+exports.sort = sort;
+const spanIndexLeft_ = spanIndexLeft_1;
+exports.spanIndexLeft_ = spanIndexLeft_;
+const spanIndexRight_ = spanIndexRight_1;
+exports.spanIndexRight_ = spanIndexRight_;
+const slice_ = slice_1;
+exports.slice_ = slice_;
+const splitAt_ = splitAt_1;
+exports.splitAt_ = splitAt_;
+const unsafeGet = unsafeGet_1;
+exports.unsafeGet = unsafeGet;
+const unsafeAsMutable = unsafeAsMutable_1;
+exports.unsafeAsMutable = unsafeAsMutable;
+const unsafeDeleteAt_ = unsafeDeleteAt_1;
+exports.unsafeDeleteAt_ = unsafeDeleteAt_;
+const unsafeInsertAt_ = unsafeInsertAt_1;
+exports.unsafeInsertAt_ = unsafeInsertAt_;
+const unsafeModifyAt_ = unsafeModifyAt_1;
+exports.unsafeModifyAt_ = unsafeModifyAt_;
+const unsafeUpdateAt_ = unsafeUpdateAt_1;
+exports.unsafeUpdateAt_ = unsafeUpdateAt_;
+const zipWith_ = zipWith_1;
+exports.zipWith_ = zipWith_;
+
+/**
+ * @tsplus fluent fncts.ImmutableArray alignWith
+ */
+function alignWith_1(self, fb, f) {
+  const selfArray = self._array;
+  const thatArray = fb._array;
+  const minlen = Math.min(selfArray.length, thatArray.length);
+  const maxlen = Math.max(selfArray.length, thatArray.length);
+  const ret = Array(maxlen);
+
+  for (let i = 0; i < minlen; i++) {
+    ret[i] = f(tsplus_module_1.both(selfArray[i], thatArray[i]));
+  }
+
+  if (minlen === maxlen) {
+    return tsplus_module_2.asImmutableArray(ret);
+  } else if (selfArray.length > thatArray.length) {
+    for (let i = minlen; i < maxlen; i++) {
+      ret[i] = f(tsplus_module_1.left(selfArray[i]));
+    }
+  } else {
+    for (let i = minlen; i < maxlen; i++) {
+      ret[i] = f(tsplus_module_1.right(thatArray[i]));
+    }
+  }
+
+  return tsplus_module_2.asImmutableArray(ret);
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray align
+ */
+
+
+function align_(self, fb) {
+  return alignWith_1(self, fb, _function.identity);
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray alt
+ */
+
+
+function alt_(self, that) {
+  return concat_1(self, that());
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray ap
+ */
+
+
+function ap_(self, fa) {
+  return flatMap_1(self, f => map_1(fa, f));
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray append
+ */
+
+
+function append_1(self, last) {
+  const selfArray = self._array;
+  const len = selfArray.length;
+  const r = Array(len + 1);
+  r[len] = last;
+
+  for (let i = 0; i < len; i++) {
+    r[i] = selfArray[i];
+  }
+
+  return tsplus_module_2.asImmutableArray(r);
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray crossWith
+ */
+
+
+function crossWith_(self, fb, f) {
+  return flatMap_1(self, a => map_1(fb, b => f(a, b)));
+}
+/**
+ * @tsplus static fncts.ImmutableArrayOps chainRecDepthFirst
+ */
+
+
+function chainRecDepthFirst(a, f) {
+  const buffer = unsafeAsMutable_1(slice_1(f(a)));
+  const out = [];
+
+  while (buffer.length > 0) {
+    const e = buffer.shift();
+
+    if (e._tag === "Left"
+    /* EitherTag.Left */
+    ) {
+      buffer.unshift(...f(e.left));
+    } else {
+      out.push(e.right);
+    }
+  }
+
+  return tsplus_module_2.asImmutableArray(out);
+}
+/**
+ * @tsplus static fncts.ImmutableArrayOps chainRecBreadthFirst
+ */
+
+
+function chainRecBreadthFirst(a, f) {
+  const initial = f(a);
+  const buffer = [];
+  const out = [];
+
+  function go(e) {
+    if (e._tag === "Left") {
+      forEach_1(f(e.left), v => buffer.push(v));
+    } else {
+      out.push(e.right);
+    }
+  }
+
+  for (const e of initial) {
+    go(e);
+  }
+
+  while (buffer.length > 0) {
+    go(buffer.shift());
+  }
+
+  return tsplus_module_2.asImmutableArray(out);
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray flatMapWithIndex
+ */
+
+
+function flatMapWithIndex_1(self, f) {
+  let outLen = 0;
+  const selfArray = self._array;
+  const len = selfArray.length;
+  const temp = Array(len);
+
+  for (let i = 0; i < len; i++) {
+    const e = selfArray[i];
+
+    const arr = f(i, e)._array;
+
+    outLen += arr.length;
+    temp[i] = arr;
+  }
+
+  const out = Array(outLen);
+  let start = 0;
+
+  for (let i = 0; i < len; i++) {
+    const arr = temp[i];
+    const l = arr.length;
+
+    for (let j = 0; j < l; j++) {
+      out[j + start] = arr[j];
+    }
+
+    start += l;
+  }
+
+  return tsplus_module_2.asImmutableArray(out);
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray flatMap
+ */
+
+
+function flatMap_1(self, f) {
+  return flatMapWithIndex_1(self, (_, a) => f(a));
+}
+/**
+ * @tsplus getter fncts.ImmutableArray flatten
+ */
+
+
+function flatten_1(self) {
+  return flatMap_1(self, _function.identity);
+}
+/**
+ * A useful recursion pattern for processing a `Array` to produce a new `Array`,
+ * often used for "chopping" up the input `Array`. Typically chop is called with some function
+ * that will consume an initial prefix of the `Array` and produce a value and the rest of the `Array`.
+ *
+ * @tsplus fluent fncts.ImmutableArray chop
+ */
+
+
+function chop_1(as, f) {
+  const result = [];
+  let cs = as;
+
+  while (isNonEmpty_1(cs)) {
+    const [b, c] = f(cs);
+    result.push(b);
+    cs = c;
+  }
+
+  return tsplus_module_2.asImmutableArray(result);
+}
+
+const chop = f => as => chop_(as, f);
+/**
+ * @tsplus fluent fncts.ImmutableArray chunksOf
+ */
+
+
+exports.chop = chop;
+
+function chunksOf_(self, n) {
+  return chop_1(self, as => tsplus_module_3.splitAt_(as, n));
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray collectWhile
+ */
+
+
+function collectWhile_(as, f) {
+  const result = [];
+
+  for (let i = 0; i < length_1(as); i++) {
+    const o = f(as._array[i]);
+
+    if (tsplus_module_4.isJust(o)) {
+      result.push(o.value);
+    } else {
+      break;
+    }
+  }
+
+  return tsplus_module_2.asImmutableArray(result);
+}
+
+function comprehensionLoop(scope, input, f, g) {
+  if (input.length === 0) {
+    return g(...scope) ? tsplus_module_5.now(tsplus_module_2.make(f(...scope))) : tsplus_module_5.now(tsplus_module_2.empty());
+  } else {
+    return tsplus_module_7.map_(traverseSelf_1(input[0])(tsplus_module_6.Applicative)(a => comprehensionLoop(append_1(scope, a), input.slice(1), f, g)), rs => flatten_1(rs));
+  }
+}
+
+function comprehension(input, f, g = () => true) {
+  return tsplus_module_8.run(comprehensionLoop(tsplus_module_2.empty(), input, f, g));
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray concat
+ * @tsplus operator fncts.ImmutableArray +
+ * @tsplus operator fncts.base.MutableArray +
+ */
+
+
+function concat_1(self, that) {
+  const lenx = self._array.length;
+
+  if (lenx === 0) {
+    return that;
+  }
+
+  const leny = that._array.length;
+
+  if (leny === 0) {
+    return self;
+  }
+
+  const r = Array(lenx + leny);
+
+  for (let i = 0; i < lenx; i++) {
+    r[i] = self._array[i];
+  }
+
+  for (let i = 0; i < leny; i++) {
+    r[i + lenx] = that._array[i];
+  }
+
+  return tsplus_module_2.asImmutableArray(r);
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray deleteAt
+ */
+
+
+function deleteAt_(as, i) {
+  return isOutOfBound_1(as, i) ? tsplus_module_9.nothing() : tsplus_module_9.just(unsafeDeleteAt_1(as, i));
+}
+/**
+ * @constrained
+ */
+
+
+function difference_(E) {
+  const elemE_ = elem_(E);
+  return (self, ys) => filter_1(self, a => !elemE_(ys, a));
+}
+/**
+ * @tsplus getter fncts.ImmutableArray difference
+ */
+
+
+function differenceSelf(self) {
+  return E => that => difference_(E)(self, that);
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray drop
+ */
+
+
+function drop_(self, n) {
+  return slice_1(self, n);
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray dropLast
+ */
+
+
+function dropLast_(self, n) {
+  return slice_1(self, 0, length_1(self) - n);
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray dropWhile
+ */
+
+
+function dropWhile_(self, p) {
+  return slice_1(self, spanIndexLeft_1(self, p));
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray dropLastWhile
+ */
+
+
+function dropLastWhile_(as, p) {
+  return slice_1(as, 0, spanIndexRight_1(as, p) + 1);
+}
+/**
+ * Test if a value is a member of an array. Takes an `Eq<A>` as a single
+ * argument which returns the function to use to search for a value of type `A` in
+ * an array of type `ImmutableArray<A>`.
+ *
+ * @constrained
+ */
+
+
+function elem_(E) {
+  return (as, a) => {
+    const predicate = element => E.equals_(element, a);
+
+    const len = length_1(as);
+
+    for (let i = 0; i < len; i++) {
+      if (predicate(as._array[i])) {
+        return true;
+      }
+    }
+
+    return false;
+  };
+}
+/**
+ * Test if a value is a member of an array. Takes an `Eq<A>` as a single
+ * argument which returns the function to use to search for a value of type `A` in
+ * an array of type `ImmutableArray<A>`.
+ *
+ * @tsplus getter fncts.ImmutableArray elem
+ */
+
+
+function elemSelf(self) {
+  return E => a => elem_(E)(self, a);
+}
+
+function every_(self, p) {
+  return everyWithIndex_1(self, (_, a) => p(a));
+}
+
+function everyWithIndex_1(self, p) {
+  let result = true;
+  let i = 0;
+
+  while (result && i < length_1(self)) {
+    result = p(i, self._array[i]);
+    i++;
+  }
+
+  return result;
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray exists
+ */
+
+
+function exists_(self, p) {
+  let result = false;
+  let i = 0;
+
+  while (!result && i < length_1(self)) {
+    result = p(self._array[i]);
+    i++;
+  }
+
+  return result;
+}
+
+function filter_1(self, p) {
+  return filterWithIndex_1(self, (_, a) => p(a));
+}
+
+function filterWithIndex_1(self, p) {
+  const result = [];
+
+  for (let i = 0; i < length_1(self); i++) {
+    const a = self._array[i];
+
+    if (p(i, a)) {
+      result.push(a);
+    }
+  }
+
+  return tsplus_module_2.asImmutableArray(result);
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray filterMapWithIndex
+ */
+
+
+function filterMapWithIndex_1(fa, f) {
+  const result = [];
+
+  for (let i = 0; i < length_1(fa); i++) {
+    const maybeB = f(i, unsafeGet_1(fa, i));
+
+    if (tsplus_module_4.isJust(maybeB)) {
+      result.push(maybeB.value);
+    }
+  }
+
+  return tsplus_module_2.asImmutableArray(result);
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray filterMap
+ */
+
+
+function filterMap_(self, f) {
+  return filterMapWithIndex_1(self, (_, a) => f(a));
+}
+
+function find_(self, p) {
+  return findWithIndex_1(self, (_, a) => p(a));
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray findIndex
+ */
+
+
+function findIndex_(as, predicate) {
+  return findMapWithIndex_1(as, (i, a) => predicate(a) ? tsplus_module_9.just(i) : tsplus_module_9.nothing());
+}
+
+function findWithIndex_1(as, p) {
+  const len = length_1(as);
+
+  for (let i = 0; i < len; i++) {
+    if (p(i, as._array[i])) {
+      return tsplus_module_9.just(as._array[i]);
+    }
+  }
+
+  return tsplus_module_9.nothing();
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray findMap
+ */
+
+
+function findMap_(as, f) {
+  return findMapWithIndex_1(as, (_, a) => f(a));
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray findMapWithIndex
+ */
+
+
+function findMapWithIndex_1(as, f) {
+  const len = length_1(as);
+
+  for (let i = 0; i < len; i++) {
+    const v = f(i, as._array[i]);
+
+    if (tsplus_module_4.isJust(v)) {
+      return v;
+    }
+  }
+
+  return tsplus_module_9.nothing();
+}
+
+function findLast_(as, p) {
+  const len = length_1(as);
+
+  for (let i = len - 1; i >= 0; i--) {
+    if (p(as._array[i])) {
+      return tsplus_module_9.just(as._array[i]);
+    }
+  }
+
+  return tsplus_module_9.nothing();
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray findLastIndex
+ */
+
+
+function findLastIndex_(self, p) {
+  return findLastMapWithIndex_1(self, (i, a) => p(a) ? tsplus_module_9.just(i) : tsplus_module_9.nothing());
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray findLastMap
+ */
+
+
+function findLastMap_(as, f) {
+  return findLastMapWithIndex_1(as, (_, a) => f(a));
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray findLastMapWithIndex
+ */
+
+
+function findLastMapWithIndex_1(as, f) {
+  const len = length_1(as);
+
+  for (let i = len - 1; i >= 0; i--) {
+    const v = f(i, as._array[i]);
+
+    if (tsplus_module_4.isJust(v)) {
+      return v;
+    }
+  }
+
+  return tsplus_module_9.nothing();
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray foldLeftWithIndex
+ * @tsplus fluent fncts.base.MutableArray foldLeftWithIndex
+ */
+
+
+function foldLeftWithIndex_1(self, b, f) {
+  const len = length_1(self);
+  let r = b;
+
+  for (let i = 0; i < len; i++) {
+    r = f(i, r, self._array[i]);
+  }
+
+  return r;
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray foldLeft
+ * @tsplus fluent fncts.base.MutableArray foldLeft
+ */
+
+
+function foldLeft_1(self, b, f) {
+  return foldLeftWithIndex_1(self, b, (_, b, a) => f(b, a));
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray foldLeftWhile
+ * @tsplus fluent fncts.base.MutableArray foldLeftWhile
+ */
+
+
+function foldLeftWhile_(self, b, p, f) {
+  return foldLeftWithIndexWhile_1(self, b, p, (_, b, a) => f(b, a));
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray foldLeftWithIndexWhile
+ * @tsplus fluent fncts.base.MutableArray foldLeftWithIndexWhile
+ */
+
+
+function foldLeftWithIndexWhile_1(self, b, p, f) {
+  let out = b;
+  let cont = p(out);
+
+  for (let i = 0; cont && i < length_1(self); i++) {
+    out = f(i, out, self._array[i]);
+    cont = p(out);
+  }
+
+  return out;
+}
+
+function fold(M) {
+  return self => foldLeft_1(self, M.nat, M.combine_);
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray fold
+ * @tsplus fluent fncts.base.MutableArray fold
+ */
+
+
+function foldSelf_1(self, M) {
+  return foldLeft_1(self, M.nat, M.combine_);
+}
+/**
+ * @constrained
+ */
+
+
+function foldMapWithIndex_(M) {
+  return (self, f) => {
+    return foldLeftWithIndex_1(self, M.nat, (i, b, a) => M.combine_(b, f(i, a)));
+  };
+}
+/**
+ * @tsplus getter fncts.ImmutableArray foldMapWithIndex
+ * @tsplus getter fncts.base.MutableArray foldMapWithIndex
+ */
+
+
+function foldMapWithIndexSelf_1(self) {
+  return M => f => foldMapWithIndex_(M)(self, f);
+}
+/**
+ * @constrained
+ */
+
+
+function foldMap_(M) {
+  return (self, f) => {
+    return foldMapWithIndexSelf_1(self)(M)((_, a) => f(a));
+  };
+}
+/**
+ * @tsplus getter fncts.ImmutableArray foldMap
+ * @tsplus getter fncts.base.MutableArray foldMap
+ */
+
+
+function foldMapSelf(self) {
+  return M => f => foldMapWithIndexSelf_1(self)(M)((_, a) => f(a));
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray foldRightWithIndex
+ * @tsplus fluent fncts.base.MutableArray foldRightWithIndex
+ */
+
+
+function foldRightWithIndex_1(self, b, f) {
+  let r = b;
+
+  for (let i = length_1(self) - 1; i >= 0; i--) {
+    r = f(i, self._array[i], r);
+  }
+
+  return r;
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray foldRight
+ * @tsplus fluent fncts.base.MutableArray foldRight
+ */
+
+
+function foldRight_(self, b, f) {
+  return foldRightWithIndex_1(self, b, (_, a, b) => f(a, b));
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray foldRighWhile
+ * @tsplus fluent fncts.base.MutableArray foldRightWhile
+ */
+
+
+function foldRightWhile_(self, b, p, f) {
+  return foldRightWithIndexWhile_1(self, b, p, (_, a, b) => f(a, b));
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray foldRightWithIndexWhile
+ * @tsplus fluent fncts.base.MutableArray foldRightWithIndexWhile
+ */
+
+
+function foldRightWithIndexWhile_1(self, b, predicate, f) {
+  let out = b;
+  let cont = predicate(out);
+
+  for (let i = length_1(self) - 1; cont && i >= 0; i--) {
+    out = f(i, self._array[i], out);
+    cont = predicate(out);
+  }
+
+  return out;
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray forEach
+ */
+
+
+function forEach_1(self, f) {
+  return forEach_1(self, f);
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray get
+ * @tsplus fluent fncts.base.MutableArray get
+ */
+
+
+function get_1(self, i) {
+  return isOutOfBound_1(self, i) ? tsplus_module_9.nothing() : tsplus_module_9.just(self._array[i]);
+}
+
+function group(E) {
+  return chop(self => {
+    const h = self._array[0];
+    const out = [h];
+    let i = 1;
+
+    for (; i < length_1(self); i++) {
+      const a = self._array[i];
+
+      if (E.equals_(a, h)) {
+        out.push(a);
+      } else {
+        break;
+      }
+    }
+
+    return [tsplus_module_10.unsafeAsNonEmptyArray(out), slice_1(self, i)];
+  });
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray group
+ */
+
+
+function chopSelf(self, E) {
+  return group(E)(self);
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray groupBy
+ */
+
+
+function groupBy_(self, f) {
+  const out = {};
+
+  for (let i = 0; i < length_1(self); i++) {
+    const a = self._array[i];
+    const k = f(a);
+
+    if (Object.prototype.hasOwnProperty.call(out, k)) {
+      out[k].push(a);
+    } else {
+      out[k] = [a];
+    }
+  }
+
+  return tsplus_module_11.toRecord(tsplus_module_11.map_(tsplus_module_12.Dictionary.get(out), tsplus_module_10.from));
+}
+/**
+ * @tsplus getter fncts.ImmutableArray head
+ */
+
+
+function head(self) {
+  return isNonEmpty_1(self) ? tsplus_module_9.just(self._array[0]) : tsplus_module_9.nothing();
+}
+/**
+ * @tsplus getter fncts.ImmutableArray init
+ */
+
+
+function init(self) {
+  const len = length_1(self);
+  return len === 0 ? tsplus_module_9.nothing() : tsplus_module_9.just(slice_1(self, 0, len - 1));
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray insertAt
+ */
+
+
+function insertAt_(self, i, a) {
+  return isOutOfBound_1(self, i) ? tsplus_module_9.nothing() : tsplus_module_9.just(unsafeInsertAt_1(self, i, a));
+}
+
+function intersection_(E) {
+  const elemE = elem_(E);
+  return (self, that) => filter_1(self, a => elemE(that, a));
+}
+/**
+ * @tsplus getter fncts.ImmutableArray intersection
+ */
+
+
+function intersectionSelf(self) {
+  return E => that => intersection_(E)(self, that);
+}
+
+function intersperse_(self, a) {
+  const len = length_1(self);
+  return len === 0 ? self : prepend_1(prependAll_1(slice_1(self, 1, len), a), unsafeGet_1(self, 0));
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray isEmpty
+ */
+
+
+function isEmpty_1(self) {
+  return length_1(self) === 0;
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray isNonEmpty
+ */
+
+
+function isNonEmpty_1(self) {
+  return length_1(self) > 0;
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray isOutOfBound
+ */
+
+
+function isOutOfBound_1(self, i) {
+  return i < 0 || i >= length_1(self);
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray join
+ */
+
+
+function join(self, separator) {
+  return self._array.join(separator);
+}
+/**
+ * @tsplus getter fncts.ImmutableArray last
+ */
+
+
+function last(self) {
+  return get_1(self, length_1(self) - 1);
+}
+/**
+ * @tsplus getter fncts.ImmutableArray length
+ */
+
+
+function length_1(self) {
+  return self._array.length;
+}
+/**
+ * @tsplus getter fncts.ImmutableArray lefts
+ */
+
+
+function lefts(self) {
+  const ls = [];
+
+  for (let i = 0; i < length_1(self); i++) {
+    const a = self._array[i];
+
+    if (a._tag === "Left"
+    /* EitherTag.Left */
+    ) {
+      ls.push(a.left);
+    }
+  }
+
+  return tsplus_module_2.asImmutableArray(ls);
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray map
+ */
+
+
+function map_1(self, f) {
+  return mapWithIndex_1(self, (_, a) => f(a));
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray mapAccum
+ */
+
+
+function mapAccum_(self, s, f) {
+  const bs = Array(length_1(self));
+  let state = s;
+
+  for (let i = 0; i < length_1(self); i++) {
+    const result = f(state, self._array[i]);
+    bs[i] = result[0];
+    state = result[1];
+  }
+
+  return [tsplus_module_2.asImmutableArray(bs), state];
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray mapWithIndex
+ */
+
+
+function mapWithIndex_1(self, f) {
+  const len = self._array.length;
+  const bs = Array(len);
+
+  for (let i = 0; i < len; i++) {
+    bs[i] = f(i, self._array[i]);
+  }
+
+  return tsplus_module_2.asImmutableArray(bs);
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray modifyAt
+ */
+
+
+function modifyAt_(self, i, f) {
+  return isOutOfBound_1(self, i) ? tsplus_module_9.nothing() : tsplus_module_9.just(unsafeModifyAt_1(self, i, f));
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray mutate
+ */
+
+
+function mutate_1(self, f) {
+  const mut = mutableClone_1(self);
+  f(mut);
+  return tsplus_module_2.asImmutableArray(mut);
+}
+/**
+ * @tsplus getter fncts.ImmutableArray mutableClone
+ */
+
+
+function mutableClone_1(self) {
+  return slice_1(self, 0)._array;
+}
+
+function partitionWithIndex_1(self, p) {
+  const left = [];
+  const right = [];
+
+  for (let i = 0; i < length_1(self); i++) {
+    const a = self._array[i];
+
+    if (p(i, a)) {
+      right.push(a);
+    } else {
+      left.push(a);
+    }
+  }
+
+  return [tsplus_module_2.asImmutableArray(left), tsplus_module_2.asImmutableArray(right)];
+}
+
+function partition_(self, p) {
+  return partitionWithIndex_1(self, (_, a) => p(a));
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray partitionMapWithIndex
+ */
+
+
+function partitionMapWithIndex_1(self, f) {
+  const left = [];
+  const right = [];
+
+  for (let i = 0; i < length_1(self); i++) {
+    const ea = f(i, self._array[i]);
+
+    switch (ea._tag) {
+      case "Left"
+      /* EitherTag.Left */
+      :
+        left.push(ea.left);
+        break;
+
+      case "Right"
+      /* EitherTag.Right */
+      :
+        right.push(ea.right);
+        break;
+    }
+  }
+
+  return [tsplus_module_2.asImmutableArray(left), tsplus_module_2.asImmutableArray(right)];
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray partitionMap
+ */
+
+
+function partitionMap_(self, f) {
+  return partitionMapWithIndex_1(self, (_, a) => f(a));
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray prepend
+ */
+
+
+function prepend_1(self, head) {
+  const len = length_1(self);
+  const out = Array(len + 1);
+  out[0] = head;
+
+  for (let i = 0; i < len; i++) {
+    out[i + 1] = self._array[i];
+  }
+
+  return tsplus_module_2.asImmutableArray(out);
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray prependAll
+ * @tsplus fluent fncts.base.MutableArray prependAll
+ */
+
+
+function prependAll_1(self, a) {
+  const out = [];
+
+  for (let i = 0; i < length_1(self); i++) {
+    out.push(a, self._array[i]);
+  }
+
+  return tsplus_module_2.asImmutableArray(out);
+}
+/**
+ * @tsplus getter fncts.ImmutableArray reverse
+ */
+
+
+function reverse(self) {
+  if (isEmpty_1(self)) {
+    return self;
+  } else if (length_1(self) === 1) {
+    return tsplus_module_2.make(self._array[0]);
+  } else {
+    const out = Array(length_1(self));
+
+    for (let j = 0, i = length_1(self) - 1; i >= 0; i--, j++) {
+      out[j] = self._array[i];
+    }
+
+    return tsplus_module_2.asImmutableArray(out);
+  }
+}
+/**
+ * @tsplus getter fncts.ImmutableArray rights
+ */
+
+
+function rights(self) {
+  const rs = [];
+
+  for (let i = 0; i < length_1(self); i++) {
+    const a = self._array[i];
+
+    if (a._tag === "Right"
+    /* EitherTag.Right */
+    ) {
+      rs.push(a.right);
+    }
+  }
+
+  return tsplus_module_2.asImmutableArray(rs);
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray rotate
+ */
+
+
+function rotate_1(self, n) {
+  const len = length_1(self);
+
+  if (n === 0 || len <= 1 || len === Math.abs(n)) {
+    return self;
+  } else if (n < 0) {
+    return rotate_1(self, len + n);
+  } else {
+    return concat_1(slice_1(self, -n), slice_1(self, 0, len - n));
+  }
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray scanLeft
+ */
+
+
+function scanLeft_(self, b, f) {
+  const l = length_1(self);
+  const r = Array(l + 1);
+  r[0] = b;
+
+  for (let i = 0; i < l; i++) {
+    r[i + 1] = f(r[i], self._array[i]);
+  }
+
+  return tsplus_module_2.asImmutableArray(r);
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray scanRight
+ */
+
+
+function scanRight_(self, b, f) {
+  const l = length_1(self);
+  const r = Array(l + 1);
+  r[l] = b;
+
+  for (let i = l - 1; i >= 0; i--) {
+    r[i] = f(self._array[i], r[i + 1]);
+  }
+
+  return tsplus_module_2.asImmutableArray(r);
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray sort
+ */
+
+
+function sort_1(self, O) {
+  return isEmpty_1(self) || length_1(self) === 1 ? self : tsplus_module_2.asImmutableArray(self._array.slice().sort(O.compare_));
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray sortBy
+ */
+
+
+function sortBy(self, Os) {
+  return sort_1(self, foldSelf_1(Os, tsplus_module_13.getMonoid()));
+}
+
+function spanLeft_(self, p) {
+  const i = spanIndexLeft_1(self, p);
+  const init = Array(i);
+
+  for (let j = 0; j < i; j++) {
+    init[j] = self._array[j];
+  }
+
+  const l = length_1(self);
+  const rest = Array(l - i);
+
+  for (let j = i; j < l; j++) {
+    rest[j - i] = self._array[j];
+  }
+
+  return [tsplus_module_2.asImmutableArray(init), tsplus_module_2.asImmutableArray(rest)];
+}
+
+function spanRight_(self, p) {
+  const i = spanIndexRight_1(self, p);
+  const l = length_1(self);
+  const tail = Array(l - i - 1);
+
+  for (let j = l - 1; j > i; j--) {
+    tail[j - i - 1] = self._array[j];
+  }
+
+  const rest = Array(i);
+
+  for (let j = i; j >= 0; j--) {
+    rest[j] = self._array[j];
+  }
+
+  return [tsplus_module_2.asImmutableArray(rest), tsplus_module_2.asImmutableArray(tail)];
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray spanIndexLeft
+ */
+
+
+function spanIndexLeft_1(self, p) {
+  const l = length_1(self);
+  let i = 0;
+
+  for (; i < l; i++) {
+    if (!p(self._array[i])) {
+      break;
+    }
+  }
+
+  return i;
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray spanIndexRight
+ */
+
+
+function spanIndexRight_1(as, predicate) {
+  let i = length_1(as) - 1;
+
+  for (; i >= 0; i--) {
+    if (!predicate(as._array[i])) {
+      break;
+    }
+  }
+
+  return i;
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray slice
+ */
+
+
+function slice_1(self, start, end) {
+  return tsplus_module_2.asImmutableArray(self._array.slice(start, end));
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray splitAt
+ */
+
+
+function splitAt_1(as, n) {
+  return [slice_1(as, 0, n), slice_1(as, n)];
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray splitWhere
+ */
+
+
+function splitWhere_(self, p) {
+  let cont = true;
+  let i = 0;
+
+  while (cont && i < length_1(self)) {
+    if (p(self._array[i])) {
+      cont = false;
+    } else {
+      i++;
+    }
+  }
+
+  return splitAt_1(self, i);
+}
+
+const sequence = A => self => traverseSelf_1(self)(A)(_function.identity);
+/**
+ * @tsplus getter fncts.ImmutableArray sequence
+ */
+
+
+exports.sequence = sequence;
+
+const sequenceSelf = self => A => traverseSelf_1(self)(A)(_function.identity);
+/**
+ * @tsplus getter fncts.ImmutableArray tail
+ */
+
+
+exports.sequenceSelf = sequenceSelf;
+
+function tail(self) {
+  return isNonEmpty_1(self) ? tsplus_module_9.just(slice_1(self, 1)) : tsplus_module_9.nothing();
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray take
+ */
+
+
+function take_(self, n) {
+  return slice_1(self, 0, n);
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray takeLast
+ */
+
+
+function takeLast_(as, n) {
+  return isEmpty_1(as) ? tsplus_module_2.empty() : slice_1(as, -n);
+}
+
+function takeWhile_(self, p) {
+  const i = spanIndexLeft_1(self, p);
+  const init = Array(i);
+
+  for (let j = 0; j < i; j++) {
+    init[j] = self._array[j];
+  }
+
+  return tsplus_module_2.asImmutableArray(init);
+}
+
+const traverseWithIndex_ = /*#__PURE__*/P.mkTraverseWithIndex_()(_ => A => (ta, f) => foldLeftWithIndex_1(ta, A.pure(tsplus_module_2.empty()), (i, fbs, a) => A.zipWith_(fbs, f(i, a), (bs, b) => append_1(bs, b))));
+/**
+ * @tsplus dataFirst traverseWithIndex_
+ */
+
+exports.traverseWithIndex_ = traverseWithIndex_;
+
+const traverseWithIndex = A => f => self => traverseWithIndex_(A)(self, f);
+/**
+ * @tsplus getter fncts.ImmutableArray traverseWithIndex
+ */
+
+
+exports.traverseWithIndex = traverseWithIndex;
+
+const traverseWithIndexSelf_1 = self => A => f => traverseWithIndex_(A)(self, f);
+
+const traverseWithIndexSelf = traverseWithIndexSelf_1;
+exports.traverseWithIndexSelf = traverseWithIndexSelf;
+
+const traverse_ = A => (self, f) => traverseWithIndexSelf_1(self)(A)((_, a) => f(a));
+/**
+ * @tsplus dataFirst traverse_
+ */
+
+
+exports.traverse_ = traverse_;
+
+const traverse = A => f => self => traverseWithIndexSelf_1(self)(A)((_, a) => f(a));
+/**
+ * @tsplus getter fncts.ImmutableArray traverse
+ */
+
+
+exports.traverse = traverse;
+
+const traverseSelf_1 = self => A => f => traverseWithIndexSelf_1(self)(A)((_, a) => f(a));
+
+const traverseSelf = traverseSelf_1;
+exports.traverseSelf = traverseSelf;
+
+function union_(E) {
+  const elemE = elem_(E);
+  return (self, that) => concat_1(self, filter_1(that, a => !elemE(self, a)));
+}
+
+function uniq(E) {
+  return self => {
+    if (length_1(self) === 1) {
+      return self;
+    }
+
+    const elemE_ = elem_(E);
+    const out = [];
+    const len = length_1(self);
+
+    for (let i = 0; i < len; i++) {
+      const a = self._array[i];
+
+      if (!elemE_(tsplus_module_2.asImmutableArray(out), a)) {
+        out.push(a);
+      }
+    }
+
+    return tsplus_module_2.asImmutableArray(out);
+  };
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray uniq
+ */
+
+
+function uniqSelf(self, E) {
+  return uniq(E)(self);
+}
+/**
+ * @tsplus getter fncts.ImmutableArray unprepend
+ */
+
+
+function unprepend(self) {
+  return isNonEmpty_1(self) ? tsplus_module_9.just([unsafeGet_1(self, 0), slice_1(self, 1)]) : tsplus_module_9.nothing();
+}
+/**
+ * @tsplus index fncts.ImmutableArray
+ */
+
+
+function unsafeGet_1(self, i) {
+  return self._array[i];
+}
+/**
+ * @tsplus getter fncts.ImmutableArray unsafeAsMutable
+ */
+
+
+function unsafeAsMutable_1(self) {
+  return self._array;
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray unsafeDeleteAt
+ */
+
+
+function unsafeDeleteAt_1(self, i) {
+  return mutate_1(self, xs => {
+    xs.splice(i, 1);
+  });
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray unsafeInsertAt
+ */
+
+
+function unsafeInsertAt_1(as, i, a) {
+  return mutate_1(as, xs => {
+    xs.splice(i, 0, a);
+  });
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray unsafeModifyAt
+ */
+
+
+function unsafeModifyAt_1(as, i, f) {
+  const next = f(unsafeGet_1(as, i));
+
+  if (unsafeGet_1(as, i) === next) {
+    return as;
+  }
+
+  return mutate_1(as, xs => {
+    xs[i] = next;
+  });
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray unsafeUpdateAt
+ */
+
+
+function unsafeUpdateAt_1(as, i, a) {
+  if (unsafeGet_1(as, i) === a) {
+    return as;
+  } else {
+    return mutate_1(as, xs => {
+      xs[i] = a;
+    });
+  }
+}
+/**
+ * @tsplus getter fncts.ImmutableArray unzip
+ */
+
+
+function unzip(self) {
+  const fa = Array(length_1(self));
+  const fb = Array(length_1(self));
+
+  for (let i = 0; i < length_1(self); i++) {
+    fa[i] = self._array[i][0];
+    fb[i] = self._array[i][1];
+  }
+
+  return [tsplus_module_2.asImmutableArray(fa), tsplus_module_2.asImmutableArray(fb)];
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray updateAt
+ */
+
+
+function updateAt_(as, i, a) {
+  return isOutOfBound_1(as, i) ? tsplus_module_9.nothing() : tsplus_module_9.just(unsafeUpdateAt_1(as, i, a));
+}
+
+const wilt_ = A => (self, f) => wiltWithIndexSelf_1(self)(A)((_, a) => f(a));
+/**
+ * @tsplus pipeable fncts.ImmutableArray wilt_
+ */
+
+
+exports.wilt_ = wilt_;
+
+const wilt = A => f => self => wiltWithIndexSelf_1(self)(A)((_, a) => f(a));
+/**
+ * @tsplus fluent fncts.ImmutableArray wilt
+ */
+
+
+exports.wilt = wilt;
+
+const wiltSelf = self => A => f => wiltWithIndexSelf_1(self)(A)((_, a) => f(a));
+
+exports.wiltSelf = wiltSelf;
+const wiltWithIndex_ = /*#__PURE__*/P.mkWiltWithIndex_()(_ => A => (self, f) => A.map_(foldLeftWithIndex_1(self, A.pure([[], []]), (i, fbs, a) => A.zipWith_(f(i, a), fbs, (eb, r) => tsplus_module_15.match_(eb, b1 => {
+  r[0].push(b1);
+  return r;
+}, b2 => {
+  r[1].push(b2);
+  return r;
+}))), ([b1s, b2s]) => [tsplus_module_2.asImmutableArray(b1s), tsplus_module_2.asImmutableArray(b2s)]));
+/**
+ * @tsplus dataFirst wiltWithIndex_
+ */
+
+exports.wiltWithIndex_ = wiltWithIndex_;
+
+const wiltWithIndex = A => f => self => wiltWithIndex_(A)(self, f);
+/**
+ * @tsplus getter fncts.ImmutableArray wiltWithIndex
+ */
+
+
+exports.wiltWithIndex = wiltWithIndex;
+
+const wiltWithIndexSelf_1 = self => A => f => wiltWithIndex_(A)(self, f);
+
+const wiltWithIndexSelf = wiltWithIndexSelf_1;
+exports.wiltWithIndexSelf = wiltWithIndexSelf;
+
+const wither_ = A => (self, f) => witherWithIndex_(A)(self, (_, a) => f(a));
+/**
+ * @tsplus dataFirst wither_
+ */
+
+
+exports.wither_ = wither_;
+
+const wither = A => f => self => wither_(A)(self, f);
+/**
+ * @tsplus fluent fncts.ImmutableArray wither
+ */
+
+
+exports.wither = wither;
+
+const witherSelf = self => A => f => witherWithIndex_(A)(self, (_, a) => f(a));
+
+exports.witherSelf = witherSelf;
+const witherWithIndex_ = /*#__PURE__*/P.mkWitherWithIndex_()(_ => A => (self, f) => A.map_(foldLeftWithIndex_1(self, A.pure([]), (i, b, a) => A.zipWith_(f(i, a), b, (maybeB, bs) => {
+  if (tsplus_module_4.isJust(maybeB)) {
+    bs.push(maybeB.value);
+  }
+
+  return bs;
+})), bs => tsplus_module_2.asImmutableArray(bs)));
+/**
+ * @tsplus dataFirst witherWithIndex_
+ */
+
+exports.witherWithIndex_ = witherWithIndex_;
+
+const witherWithIndex = A => f => self => witherWithIndex_(A)(self, f);
+/**
+ * @tsplus fluent fncts.ImmutableArray witherWithIndex
+ */
+
+
+exports.witherWithIndex = witherWithIndex;
+
+const witherWithIndexSelf = self => A => f => witherWithIndex_(A)(self, f);
+/**
+ * @tsplus fluent fncts.ImmutableArray zip
+ */
+
+
+exports.witherWithIndexSelf = witherWithIndexSelf;
+
+function zip_(self, that) {
+  return zipWith_1(self, that, _function.tuple);
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray zipWith
+ */
+
+
+function zipWith_1(self, fb, f) {
+  const len = Math.min(length_1(self), length_1(fb));
+  const fc = Array(len);
+
+  for (let i = 0; i < len; i++) {
+    fc[i] = f(self._array[i], fb._array[i]);
+  }
+
+  return tsplus_module_2.asImmutableArray(fc);
+}
+//# sourceMappingURL=api.cjs.map