effect 2.0.0-next.41 → 2.0.0-next.43

package/Chunk/dist/effect-Chunk.cjs.dev.js

@@ -2,105 +2,1174 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-require('../../dist/Equal-281b6ca8.cjs.dev.js');
-require('../../dist/Equivalence-de7a0d51.cjs.dev.js');
-require('../../dist/Function-41ce433d.cjs.dev.js');
-require('../../dist/Hash-bd154268.cjs.dev.js');
-require('../../dist/Inspectable-ac929af4.cjs.dev.js');
-require('../../dist/Option-03997d77.cjs.dev.js');
-require('../../dist/Order-28bdebd2.cjs.dev.js');
-require('../../dist/Pipeable-4698db72.cjs.dev.js');
-require('../../dist/Predicate-9e859c9c.cjs.dev.js');
-require('../../dist/ReadonlyArray-48949ee7.cjs.dev.js');
-var Chunk_dist_effectChunk = require('../../dist/Chunk-bd290b8e.cjs.dev.js');
-require('../../dist/GlobalValue-81ab6908.cjs.dev.js');
-require('../../dist/Utils-b0c14d1b.cjs.dev.js');
-require('../../dist/Either-9c349424.cjs.dev.js');
-require('../../dist/Effectable-a6403e5f.cjs.dev.js');
-require('../../dist/Data-85559fb3.cjs.dev.js');
-require('../../dist/Number-588f6483.cjs.dev.js');
-require('../../dist/Either-a806809d.cjs.dev.js');
+var Equal_dist_effectEqual = require('../../Equal/dist/effect-Equal.cjs.dev.js');
+var Equivalence_dist_effectEquivalence = require('../../Equivalence/dist/effect-Equivalence.cjs.dev.js');
+var Function_dist_effectFunction = require('../../Function/dist/effect-Function.cjs.dev.js');
+var Hash_dist_effectHash = require('../../Hash/dist/effect-Hash.cjs.dev.js');
+var Inspectable_dist_effectInspectable = require('../../Inspectable/dist/effect-Inspectable.cjs.dev.js');
+var Option_dist_effectOption = require('../../Option/dist/effect-Option.cjs.dev.js');
+var Order_dist_effectOrder = require('../../Order/dist/effect-Order.cjs.dev.js');
+var Pipeable_dist_effectPipeable = require('../../Pipeable/dist/effect-Pipeable.cjs.dev.js');
+var Predicate_dist_effectPredicate = require('../../Predicate/dist/effect-Predicate.cjs.dev.js');
+var ReadonlyArray_dist_effectReadonlyArray = require('../../ReadonlyArray/dist/effect-ReadonlyArray.cjs.dev.js');
+require('../../GlobalValue/dist/effect-GlobalValue.cjs.dev.js');
+require('../../Utils/dist/effect-Utils.cjs.dev.js');
+require('../../dist/Either-12bbe00c.cjs.dev.js');
+require('../../dist/Effectable-2f022879.cjs.dev.js');
+require('../../Data/dist/effect-Data.cjs.dev.js');
+require('../../Number/dist/effect-Number.cjs.dev.js');
+require('../../Either/dist/effect-Either.cjs.dev.js');
 require('../../dist/ReadonlyArray-9a1474f6.cjs.dev.js');
-require('../../dist/ReadonlyRecord-605a625b.cjs.dev.js');
-
-
-
-exports.append = Chunk_dist_effectChunk.append;
-exports.appendAll = Chunk_dist_effectChunk.appendAll;
-exports.appendAllNonEmpty = Chunk_dist_effectChunk.appendAllNonEmpty;
-exports.chunksOf = Chunk_dist_effectChunk.chunksOf;
-exports.compact = Chunk_dist_effectChunk.compact;
-exports.contains = Chunk_dist_effectChunk.contains;
-exports.containsWith = Chunk_dist_effectChunk.containsWith;
-exports.dedupe = Chunk_dist_effectChunk.dedupe;
-exports.dedupeAdjacent = Chunk_dist_effectChunk.dedupeAdjacent;
-exports.drop = Chunk_dist_effectChunk.drop;
-exports.dropRight = Chunk_dist_effectChunk.dropRight;
-exports.dropWhile = Chunk_dist_effectChunk.dropWhile;
-exports.empty = Chunk_dist_effectChunk.empty;
-exports.every = Chunk_dist_effectChunk.every;
-exports.filter = Chunk_dist_effectChunk.filter;
-exports.filterMap = Chunk_dist_effectChunk.filterMap;
-exports.filterMapWhile = Chunk_dist_effectChunk.filterMapWhile;
-exports.findFirst = Chunk_dist_effectChunk.findFirst;
-exports.findFirstIndex = Chunk_dist_effectChunk.findFirstIndex;
-exports.findLast = Chunk_dist_effectChunk.findLast;
-exports.findLastIndex = Chunk_dist_effectChunk.findLastIndex;
-exports.flatMap = Chunk_dist_effectChunk.flatMap;
-exports.flatMapNonEmpty = Chunk_dist_effectChunk.flatMapNonEmpty;
-exports.flatten = Chunk_dist_effectChunk.flatten;
-exports.flattenNonEmpty = Chunk_dist_effectChunk.flattenNonEmpty;
-exports.forEach = Chunk_dist_effectChunk.forEach;
-exports.fromIterable = Chunk_dist_effectChunk.fromIterable;
-exports.get = Chunk_dist_effectChunk.get;
-exports.getEquivalence = Chunk_dist_effectChunk.getEquivalence;
-exports.head = Chunk_dist_effectChunk.head;
-exports.headNonEmpty = Chunk_dist_effectChunk.headNonEmpty;
-exports.intersection = Chunk_dist_effectChunk.intersection;
-exports.isChunk = Chunk_dist_effectChunk.isChunk;
-exports.isEmpty = Chunk_dist_effectChunk.isEmpty;
-exports.isNonEmpty = Chunk_dist_effectChunk.isNonEmpty;
-exports.join = Chunk_dist_effectChunk.join;
-exports.last = Chunk_dist_effectChunk.last;
-exports.make = Chunk_dist_effectChunk.make;
-exports.makeBy = Chunk_dist_effectChunk.makeBy;
-exports.map = Chunk_dist_effectChunk.map;
-exports.mapAccum = Chunk_dist_effectChunk.mapAccum;
-exports.modify = Chunk_dist_effectChunk.modify;
-exports.modifyOption = Chunk_dist_effectChunk.modifyOption;
-exports.of = Chunk_dist_effectChunk.of;
-exports.partition = Chunk_dist_effectChunk.partition;
-exports.partitionMap = Chunk_dist_effectChunk.partitionMap;
-exports.prepend = Chunk_dist_effectChunk.prepend;
-exports.prependAll = Chunk_dist_effectChunk.prependAll;
-exports.prependAllNonEmpty = Chunk_dist_effectChunk.prependAllNonEmpty;
-exports.range = Chunk_dist_effectChunk.range;
-exports.reduce = Chunk_dist_effectChunk.reduce;
-exports.reduceRight = Chunk_dist_effectChunk.reduceRight;
-exports.remove = Chunk_dist_effectChunk.remove;
-exports.replace = Chunk_dist_effectChunk.replace;
-exports.replaceOption = Chunk_dist_effectChunk.replaceOption;
-exports.reverse = Chunk_dist_effectChunk.reverse;
-exports.separate = Chunk_dist_effectChunk.separate;
-exports.size = Chunk_dist_effectChunk.size;
-exports.some = Chunk_dist_effectChunk.some;
-exports.sort = Chunk_dist_effectChunk.sort;
-exports.sortWith = Chunk_dist_effectChunk.sortWith;
-exports.split = Chunk_dist_effectChunk.split;
-exports.splitAt = Chunk_dist_effectChunk.splitAt;
-exports.splitWhere = Chunk_dist_effectChunk.splitWhere;
-exports.tail = Chunk_dist_effectChunk.tail;
-exports.tailNonEmpty = Chunk_dist_effectChunk.tailNonEmpty;
-exports.take = Chunk_dist_effectChunk.take;
-exports.takeRight = Chunk_dist_effectChunk.takeRight;
-exports.takeWhile = Chunk_dist_effectChunk.takeWhile;
-exports.toReadonlyArray = Chunk_dist_effectChunk.toReadonlyArray;
-exports.union = Chunk_dist_effectChunk.union;
-exports.unsafeFromArray = Chunk_dist_effectChunk.unsafeFromArray;
-exports.unsafeFromNonEmptyArray = Chunk_dist_effectChunk.unsafeFromNonEmptyArray;
-exports.unsafeGet = Chunk_dist_effectChunk.unsafeGet;
-exports.unsafeHead = Chunk_dist_effectChunk.unsafeHead;
-exports.unsafeLast = Chunk_dist_effectChunk.unsafeLast;
-exports.unzip = Chunk_dist_effectChunk.unzip;
-exports.zip = Chunk_dist_effectChunk.zip;
-exports.zipWith = Chunk_dist_effectChunk.zipWith;
+require('../../ReadonlyRecord/dist/effect-ReadonlyRecord.cjs.dev.js');
+
+/**
+ * @since 2.0.0
+ */
+const TypeId = /*#__PURE__*/Symbol.for("effect/Chunk");
+
+/**
+ * @category symbol
+ * @since 2.0.0
+ */
+
+/**
+ * @category models
+ * @since 2.0.0
+ */
+
+/**
+ * @category model
+ * @since 2.0.0
+ */
+
+/**
+ * @category type lambdas
+ * @since 2.0.0
+ */
+
+function copy(src, srcPos, dest, destPos, len) {
+  for (let i = srcPos; i < Math.min(src.length, srcPos + len); i++) {
+    dest[destPos + i - srcPos] = src[i];
+  }
+  return dest;
+}
+const emptyArray = [];
+
+/**
+ * Compares the two chunks of equal length using the specified function
+ *
+ * @category equivalence
+ * @since 2.0.0
+ */
+const getEquivalence = isEquivalent => Equivalence_dist_effectEquivalence.make((self, that) => toReadonlyArray(self).every((value, i) => isEquivalent(value, unsafeGet(that, i))));
+const _equivalence = /*#__PURE__*/getEquivalence(Equal_dist_effectEqual.equals);
+const ChunkProto = {
+  [TypeId]: {
+    _A: _ => _
+  },
+  toString() {
+    return Inspectable_dist_effectInspectable.toString(this.toJSON());
+  },
+  toJSON() {
+    return {
+      _id: "Chunk",
+      values: toReadonlyArray(this).map(Inspectable_dist_effectInspectable.toJSON)
+    };
+  },
+  [Inspectable_dist_effectInspectable.NodeInspectSymbol]() {
+    return this.toJSON();
+  },
+  [Equal_dist_effectEqual.symbol](that) {
+    return isChunk(that) && _equivalence(this, that);
+  },
+  [Hash_dist_effectHash.symbol]() {
+    return Hash_dist_effectHash.array(toReadonlyArray(this));
+  },
+  [Symbol.iterator]() {
+    switch (this.backing._tag) {
+      case "IArray":
+        {
+          return this.backing.array[Symbol.iterator]();
+        }
+      case "IEmpty":
+        {
+          return emptyArray[Symbol.iterator]();
+        }
+      default:
+        {
+          return toReadonlyArray(this)[Symbol.iterator]();
+        }
+    }
+  },
+  pipe() {
+    return Pipeable_dist_effectPipeable.pipeArguments(this, arguments);
+  }
+};
+const makeChunk = backing => {
+  const chunk = Object.create(ChunkProto);
+  chunk.backing = backing;
+  switch (backing._tag) {
+    case "IEmpty":
+      {
+        chunk.length = 0;
+        chunk.depth = 0;
+        chunk.left = chunk;
+        chunk.right = chunk;
+        break;
+      }
+    case "IConcat":
+      {
+        chunk.length = backing.left.length + backing.right.length;
+        chunk.depth = 1 + Math.max(backing.left.depth, backing.right.depth);
+        chunk.left = backing.left;
+        chunk.right = backing.right;
+        break;
+      }
+    case "IArray":
+      {
+        chunk.length = backing.array.length;
+        chunk.depth = 0;
+        chunk.left = _empty;
+        chunk.right = _empty;
+        break;
+      }
+    case "ISingleton":
+      {
+        chunk.length = 1;
+        chunk.depth = 0;
+        chunk.left = _empty;
+        chunk.right = _empty;
+        break;
+      }
+    case "ISlice":
+      {
+        chunk.length = backing.length;
+        chunk.depth = backing.chunk.depth + 1;
+        chunk.left = _empty;
+        chunk.right = _empty;
+        break;
+      }
+  }
+  return chunk;
+};
+
+/**
+ * Checks if `u` is a `Chunk<unknown>`
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+const isChunk = u => Predicate_dist_effectPredicate.isObject(u) && TypeId in u;
+const _empty = /*#__PURE__*/makeChunk({
+  _tag: "IEmpty"
+});
+
+/**
+ * @category constructors
+ * @since 2.0.0
+ */
+const empty = () => _empty;
+
+/**
+ * Builds a `NonEmptyChunk` from an non-empty collection of elements.
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+const make = (...as) => as.length === 1 ? of(as[0]) : unsafeFromNonEmptyArray(as);
+
+/**
+ * Builds a `NonEmptyChunk` from a single element.
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+const of = a => makeChunk({
+  _tag: "ISingleton",
+  a
+});
+
+/**
+ * Converts from an `Iterable<A>`
+ *
+ * @category conversions
+ * @since 2.0.0
+ */
+const fromIterable = self => isChunk(self) ? self : makeChunk({
+  _tag: "IArray",
+  array: ReadonlyArray_dist_effectReadonlyArray.fromIterable(self)
+});
+const copyToArray = (self, array, initial) => {
+  switch (self.backing._tag) {
+    case "IArray":
+      {
+        copy(self.backing.array, 0, array, initial, self.length);
+        break;
+      }
+    case "IConcat":
+      {
+        copyToArray(self.left, array, initial);
+        copyToArray(self.right, array, initial + self.left.length);
+        break;
+      }
+    case "ISingleton":
+      {
+        array[initial] = self.backing.a;
+        break;
+      }
+    case "ISlice":
+      {
+        let i = 0;
+        let j = initial;
+        while (i < self.length) {
+          array[j] = unsafeGet(self, i);
+          i += 1;
+          j += 1;
+        }
+        break;
+      }
+  }
+};
+
+/**
+ * Converts the specified `Chunk` to a `ReadonlyArray`.
+ *
+ * @category conversions
+ * @since 2.0.0
+ */
+const toReadonlyArray = self => {
+  switch (self.backing._tag) {
+    case "IEmpty":
+      {
+        return emptyArray;
+      }
+    case "IArray":
+      {
+        return self.backing.array;
+      }
+    default:
+      {
+        const arr = new Array(self.length);
+        copyToArray(self, arr, 0);
+        self.backing = {
+          _tag: "IArray",
+          array: arr
+        };
+        self.left = _empty;
+        self.right = _empty;
+        self.depth = 0;
+        return arr;
+      }
+  }
+};
+
+/**
+ * @since 2.0.0
+ * @category elements
+ */
+const reverse = self => {
+  switch (self.backing._tag) {
+    case "IEmpty":
+    case "ISingleton":
+      return self;
+    case "IArray":
+      {
+        return makeChunk({
+          _tag: "IArray",
+          array: ReadonlyArray_dist_effectReadonlyArray.reverse(self.backing.array)
+        });
+      }
+    case "IConcat":
+      {
+        return makeChunk({
+          _tag: "IConcat",
+          left: reverse(self.backing.right),
+          right: reverse(self.backing.left)
+        });
+      }
+    case "ISlice":
+      return unsafeFromArray(ReadonlyArray_dist_effectReadonlyArray.reverse(toReadonlyArray(self)));
+  }
+};
+
+/**
+ * This function provides a safe way to read a value at a particular index from a `Chunk`.
+ *
+ * @category elements
+ * @since 2.0.0
+ */
+const get = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, index) => index < 0 || index >= self.length ? Option_dist_effectOption.none() : Option_dist_effectOption.some(unsafeGet(self, index)));
+
+/**
+ * Wraps an array into a chunk without copying, unsafe on mutable arrays
+ *
+ * @since 2.0.0
+ * @category unsafe
+ */
+const unsafeFromArray = self => makeChunk({
+  _tag: "IArray",
+  array: self
+});
+
+/**
+ * Wraps an array into a chunk without copying, unsafe on mutable arrays
+ *
+ * @since 2.0.0
+ * @category unsafe
+ */
+const unsafeFromNonEmptyArray = self => unsafeFromArray(self);
+
+/**
+ * Gets an element unsafely, will throw on out of bounds
+ *
+ * @since 2.0.0
+ * @category unsafe
+ */
+const unsafeGet = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, index) => {
+  switch (self.backing._tag) {
+    case "IEmpty":
+      {
+        throw new Error(`Index out of bounds`);
+      }
+    case "ISingleton":
+      {
+        if (index !== 0) {
+          throw new Error(`Index out of bounds`);
+        }
+        return self.backing.a;
+      }
+    case "IArray":
+      {
+        if (index >= self.length || index < 0) {
+          throw new Error(`Index out of bounds`);
+        }
+        return self.backing.array[index];
+      }
+    case "IConcat":
+      {
+        return index < self.left.length ? unsafeGet(self.left, index) : unsafeGet(self.right, index - self.left.length);
+      }
+    case "ISlice":
+      {
+        return unsafeGet(self.backing.chunk, index + self.backing.offset);
+      }
+  }
+});
+
+/**
+ * Appends the specified element to the end of the `Chunk`.
+ *
+ * @category concatenating
+ * @since 2.0.0
+ */
+const append = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, a) => appendAllNonEmpty(self, of(a)));
+
+/**
+ * Prepend an element to the front of a `Chunk`, creating a new `NonEmptyChunk`.
+ *
+ * @category concatenating
+ * @since 2.0.0
+ */
+const prepend = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, elem) => appendAllNonEmpty(of(elem), self));
+
+/**
+ * Takes the first up to `n` elements from the chunk
+ *
+ * @since 2.0.0
+ */
+const take = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, n) => {
+  if (n <= 0) {
+    return _empty;
+  } else if (n >= self.length) {
+    return self;
+  } else {
+    switch (self.backing._tag) {
+      case "ISlice":
+        {
+          return makeChunk({
+            _tag: "ISlice",
+            chunk: self.backing.chunk,
+            length: n,
+            offset: self.backing.offset
+          });
+        }
+      case "IConcat":
+        {
+          if (n > self.left.length) {
+            return makeChunk({
+              _tag: "IConcat",
+              left: self.left,
+              right: take(self.right, n - self.left.length)
+            });
+          }
+          return take(self.left, n);
+        }
+      default:
+        {
+          return makeChunk({
+            _tag: "ISlice",
+            chunk: self,
+            offset: 0,
+            length: n
+          });
+        }
+    }
+  }
+});
+
+/**
+ * Drops the first up to `n` elements from the chunk
+ *
+ * @since 2.0.0
+ */
+const drop = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, n) => {
+  if (n <= 0) {
+    return self;
+  } else if (n >= self.length) {
+    return _empty;
+  } else {
+    switch (self.backing._tag) {
+      case "ISlice":
+        {
+          return makeChunk({
+            _tag: "ISlice",
+            chunk: self.backing.chunk,
+            offset: self.backing.offset + n,
+            length: self.backing.length - n
+          });
+        }
+      case "IConcat":
+        {
+          if (n > self.left.length) {
+            return drop(self.right, n - self.left.length);
+          }
+          return makeChunk({
+            _tag: "IConcat",
+            left: drop(self.left, n),
+            right: self.right
+          });
+        }
+      default:
+        {
+          return makeChunk({
+            _tag: "ISlice",
+            chunk: self,
+            offset: n,
+            length: self.length - n
+          });
+        }
+    }
+  }
+});
+
+/**
+ * Drops the last `n` elements.
+ *
+ * @since 2.0.0
+ */
+const dropRight = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, n) => take(self, Math.max(0, self.length - n)));
+
+/**
+ * Drops all elements so long as the predicate returns true.
+ *
+ * @since 2.0.0
+ */
+const dropWhile = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
+  const arr = toReadonlyArray(self);
+  const len = arr.length;
+  let i = 0;
+  while (i < len && f(arr[i])) {
+    i++;
+  }
+  return drop(self, i);
+});
+
+/**
+ * @category concatenating
+ * @since 2.0.0
+ */
+const prependAll = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => appendAll(that, self));
+
+/**
+ * @category concatenating
+ * @since 2.0.0
+ */
+const prependAllNonEmpty = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => prependAll(self, that));
+
+/**
+ * Concatenates the two chunks
+ *
+ * @category concatenating
+ * @since 2.0.0
+ */
+const appendAll = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => {
+  if (self.backing._tag === "IEmpty") {
+    return that;
+  }
+  if (that.backing._tag === "IEmpty") {
+    return self;
+  }
+  const diff = that.depth - self.depth;
+  if (Math.abs(diff) <= 1) {
+    return makeChunk({
+      _tag: "IConcat",
+      left: self,
+      right: that
+    });
+  } else if (diff < -1) {
+    if (self.left.depth >= self.right.depth) {
+      const nr = appendAll(self.right, that);
+      return makeChunk({
+        _tag: "IConcat",
+        left: self.left,
+        right: nr
+      });
+    } else {
+      const nrr = appendAll(self.right.right, that);
+      if (nrr.depth === self.depth - 3) {
+        const nr = makeChunk({
+          _tag: "IConcat",
+          left: self.right.left,
+          right: nrr
+        });
+        return makeChunk({
+          _tag: "IConcat",
+          left: self.left,
+          right: nr
+        });
+      } else {
+        const nl = makeChunk({
+          _tag: "IConcat",
+          left: self.left,
+          right: self.right.left
+        });
+        return makeChunk({
+          _tag: "IConcat",
+          left: nl,
+          right: nrr
+        });
+      }
+    }
+  } else {
+    if (that.right.depth >= that.left.depth) {
+      const nl = appendAll(self, that.left);
+      return makeChunk({
+        _tag: "IConcat",
+        left: nl,
+        right: that.right
+      });
+    } else {
+      const nll = appendAll(self, that.left.left);
+      if (nll.depth === that.depth - 3) {
+        const nl = makeChunk({
+          _tag: "IConcat",
+          left: nll,
+          right: that.left.right
+        });
+        return makeChunk({
+          _tag: "IConcat",
+          left: nl,
+          right: that.right
+        });
+      } else {
+        const nr = makeChunk({
+          _tag: "IConcat",
+          left: that.left.right,
+          right: that.right
+        });
+        return makeChunk({
+          _tag: "IConcat",
+          left: nll,
+          right: nr
+        });
+      }
+    }
+  }
+});
+
+/**
+ * @category concatenating
+ * @since 2.0.0
+ */
+const appendAllNonEmpty = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => appendAll(self, that));
+
+/**
+ * Returns a filtered and mapped subset of the elements.
+ *
+ * @since 2.0.0
+ * @category filtering
+ */
+const filterMap = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => unsafeFromArray(ReadonlyArray_dist_effectReadonlyArray.filterMap(self, f)));
+
+/**
+ * Returns a filtered and mapped subset of the elements.
+ *
+ * @since 2.0.0
+ * @category filtering
+ */
+const filter = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, predicate) => unsafeFromArray(ReadonlyArray_dist_effectReadonlyArray.filterMap(self, Option_dist_effectOption.liftPredicate(predicate))));
+
+/**
+ * Transforms all elements of the chunk for as long as the specified function returns some value
+ *
+ * @since 2.0.0
+ * @category filtering
+ */
+const filterMapWhile = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => unsafeFromArray(ReadonlyArray_dist_effectReadonlyArray.filterMapWhile(self, f)));
+
+/**
+ * Filter out optional values
+ *
+ * @since 2.0.0
+ * @category filtering
+ */
+const compact = self => filterMap(self, Function_dist_effectFunction.identity);
+
+/**
+ * Returns a chunk with the elements mapped by the specified function.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const flatMap = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
+  if (self.backing._tag === "ISingleton") {
+    return f(self.backing.a, 0);
+  }
+  let out = _empty;
+  let i = 0;
+  for (const k of self) {
+    out = appendAll(out, f(k, i++));
+  }
+  return out;
+});
+
+/**
+ * @category sequencing
+ * @since 2.0.0
+ */
+const flatMapNonEmpty = flatMap;
+
+/**
+ * Applies the specified function to each element of the `List`.
+ *
+ * @since 2.0.0
+ * @category combinators
+ */
+const forEach = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => toReadonlyArray(self).forEach(f));
+
+/**
+ * Flattens a chunk of chunks into a single chunk by concatenating all chunks.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const flatten = /*#__PURE__*/flatMap(Function_dist_effectFunction.identity);
+
+/**
+ * @category sequencing
+ * @since 2.0.0
+ */
+const flattenNonEmpty = /*#__PURE__*/flatMapNonEmpty(Function_dist_effectFunction.identity);
+
+/**
+ * Groups elements in chunks of up to `n` elements.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+const chunksOf = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, n) => {
+  const gr = [];
+  let current = [];
+  toReadonlyArray(self).forEach(a => {
+    current.push(a);
+    if (current.length >= n) {
+      gr.push(unsafeFromArray(current));
+      current = [];
+    }
+  });
+  if (current.length > 0) {
+    gr.push(unsafeFromArray(current));
+  }
+  return unsafeFromArray(gr);
+});
+
+/**
+ * Creates a Chunk of unique values that are included in all given Chunks.
+ *
+ * The order and references of result values are determined by the Chunk.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+const intersection = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => unsafeFromArray(ReadonlyArray_dist_effectReadonlyArray.intersection(toReadonlyArray(self), toReadonlyArray(that))));
+
+/**
+ * Determines if the chunk is empty.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+const isEmpty = self => self.length === 0;
+
+/**
+ * Determines if the chunk is not empty.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+const isNonEmpty = self => self.length > 0;
+
+/**
+ * Returns the first element of this chunk if it exists.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+const head = /*#__PURE__*/get(0);
+
+/**
+ * Returns the first element of this chunk.
+ *
+ * @since 2.0.0
+ * @category unsafe
+ */
+const unsafeHead = self => unsafeGet(self, 0);
+
+/**
+ * Returns the first element of this non empty chunk.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+const headNonEmpty = unsafeHead;
+
+/**
+ * Returns the last element of this chunk if it exists.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+const last = self => get(self, self.length - 1);
+
+/**
+ * Returns the last element of this chunk.
+ *
+ * @since 2.0.0
+ * @category unsafe
+ */
+const unsafeLast = self => unsafeGet(self, self.length - 1);
+
+/**
+ * Returns an effect whose success is mapped by the specified f function.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const map = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => self.backing._tag === "ISingleton" ? of(f(self.backing.a, 0)) : unsafeFromArray(Function_dist_effectFunction.pipe(toReadonlyArray(self), ReadonlyArray_dist_effectReadonlyArray.map((a, i) => f(a, i)))));
+
+/**
+ * Statefully maps over the chunk, producing new elements of type `B`.
+ *
+ * @since 2.0.0
+ * @category folding
+ */
+const mapAccum = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, s, f) => {
+  const [s1, as] = ReadonlyArray_dist_effectReadonlyArray.mapAccum(self, s, f);
+  return [s1, unsafeFromArray(as)];
+});
+
+/**
+ * Separate elements based on a predicate that also exposes the index of the element.
+ *
+ * @category filtering
+ * @since 2.0.0
+ */
+const partition = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, predicate) => Function_dist_effectFunction.pipe(ReadonlyArray_dist_effectReadonlyArray.partition(toReadonlyArray(self), predicate), ([l, r]) => [unsafeFromArray(l), unsafeFromArray(r)]));
+
+/**
+ * Partitions the elements of this chunk into two chunks using f.
+ *
+ * @category filtering
+ * @since 2.0.0
+ */
+const partitionMap = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => Function_dist_effectFunction.pipe(ReadonlyArray_dist_effectReadonlyArray.partitionMap(toReadonlyArray(self), f), ([l, r]) => [unsafeFromArray(l), unsafeFromArray(r)]));
+
+/**
+ * Partitions the elements of this chunk into two chunks.
+ *
+ * @category filtering
+ * @since 2.0.0
+ */
+const separate = self => Function_dist_effectFunction.pipe(ReadonlyArray_dist_effectReadonlyArray.separate(toReadonlyArray(self)), ([l, r]) => [unsafeFromArray(l), unsafeFromArray(r)]);
+
+/**
+ * Retireves the size of the chunk
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+const size = self => self.length;
+
+/**
+ * Sort the elements of a Chunk in increasing order, creating a new Chunk.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+const sort = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, O) => unsafeFromArray(ReadonlyArray_dist_effectReadonlyArray.sort(toReadonlyArray(self), O)));
+
+/**
+ * @since 2.0.0
+ * @category elements
+ */
+const sortWith = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, f, order) => sort(self, Order_dist_effectOrder.mapInput(order, f)));
+
+/**
+ *  Returns two splits of this chunk at the specified index.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+const splitAt = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, n) => [take(self, n), drop(self, n)]);
+
+/**
+ * Splits this chunk into `n` equally sized chunks.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+const split = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, n) => chunksOf(self, Math.ceil(self.length / Math.floor(n))));
+
+/**
+ * Splits this chunk on the first element that matches this predicate.
+ *
+ * @category elements
+ * @since 2.0.0
+ */
+const splitWhere = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, predicate) => {
+  let i = 0;
+  for (const a of toReadonlyArray(self)) {
+    if (predicate(a)) {
+      break;
+    } else {
+      i++;
+    }
+  }
+  return splitAt(self, i);
+});
+
+/**
+ * Returns every elements after the first.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+const tail = self => self.length > 0 ? Option_dist_effectOption.some(drop(self, 1)) : Option_dist_effectOption.none();
+
+/**
+ * Returns every elements after the first.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+const tailNonEmpty = self => drop(self, 1);
+
+/**
+ * Takes the last `n` elements.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+const takeRight = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, n) => drop(self, self.length - n));
+
+/**
+ * Takes all elements so long as the predicate returns true.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+const takeWhile = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, predicate) => {
+  const res = [];
+  for (const a of toReadonlyArray(self)) {
+    if (predicate(a)) {
+      res.push(a);
+    } else {
+      break;
+    }
+  }
+  return unsafeFromArray(res);
+});
+
+/**
+ * Creates a Chunks of unique values, in order, from all given Chunks.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+const union = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => unsafeFromArray(ReadonlyArray_dist_effectReadonlyArray.union(toReadonlyArray(self), toReadonlyArray(that))));
+
+/**
+ * Remove duplicates from an array, keeping the first occurrence of an element.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+const dedupe = self => unsafeFromArray(ReadonlyArray_dist_effectReadonlyArray.dedupe(toReadonlyArray(self)));
+
+/**
+ * Deduplicates adjacent elements that are identical.
+ *
+ * @since 2.0.0
+ * @category filtering
+ */
+const dedupeAdjacent = self => unsafeFromArray(ReadonlyArray_dist_effectReadonlyArray.dedupeAdjacent(self));
+
+/**
+ * Takes a `Chunk` of pairs and return two corresponding `Chunk`s.
+ *
+ * Note: The function is reverse of `zip`.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+const unzip = self => {
+  const [left, right] = ReadonlyArray_dist_effectReadonlyArray.unzip(self);
+  return [unsafeFromArray(left), unsafeFromArray(right)];
+};
+
+/**
+ * Zips this chunk pointwise with the specified chunk using the specified combiner.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+const zipWith = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, that, f) => unsafeFromArray(ReadonlyArray_dist_effectReadonlyArray.zipWith(self, that, f)));
+
+/**
+ * Zips this chunk pointwise with the specified chunk.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+const zip = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => zipWith(self, that, (a, b) => [a, b]));
+
+/**
+ * Delete the element at the specified index, creating a new `Chunk`,
+ * or returning the input if the index is out of bounds.
+ *
+ * @since 2.0.0
+ */
+const remove = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, i) => unsafeFromArray(ReadonlyArray_dist_effectReadonlyArray.remove(toReadonlyArray(self), i)));
+
+/**
+ * @since 2.0.0
+ */
+const modifyOption = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, i, f) => Option_dist_effectOption.map(ReadonlyArray_dist_effectReadonlyArray.modifyOption(toReadonlyArray(self), i, f), unsafeFromArray));
+
+/**
+ * Apply a function to the element at the specified index, creating a new `Chunk`,
+ * or returning the input if the index is out of bounds.
+ *
+ * @since 2.0.0
+ */
+const modify = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, i, f) => Option_dist_effectOption.getOrElse(modifyOption(self, i, f), () => self));
+
+/**
+ * Change the element at the specified index, creating a new `Chunk`,
+ * or returning the input if the index is out of bounds.
+ *
+ * @since 2.0.0
+ */
+const replace = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, i, b) => modify(self, i, () => b));
+
+/**
+ * @since 2.0.0
+ */
+const replaceOption = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, i, b) => modifyOption(self, i, () => b));
+
+/**
+ * Return a Chunk of length n with element i initialized with f(i).
+ *
+ * **Note**. `n` is normalized to an integer >= 1.
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+const makeBy = /*#__PURE__*/Function_dist_effectFunction.dual(2, (n, f) => fromIterable(ReadonlyArray_dist_effectReadonlyArray.makeBy(n, f)));
+
+/**
+ * Create a non empty `Chunk` containing a range of integers, including both endpoints.
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+const range = (start, end) => start <= end ? makeBy(end - start + 1, i => start + i) : of(start);
+
+// -------------------------------------------------------------------------------------
+// re-exports from ReadonlyArray
+// -------------------------------------------------------------------------------------
+
+/**
+ * Returns a function that checks if a `Chunk` contains a given value using the default `Equivalence`.
+ *
+ * @category elements
+ * @since 2.0.0
+ */
+const contains = ReadonlyArray_dist_effectReadonlyArray.contains;
+
+/**
+ * Returns a function that checks if a `Chunk` contains a given value using a provided `isEquivalent` function.
+ *
+ * @category elements
+ * @since 2.0.0
+ */
+const containsWith = ReadonlyArray_dist_effectReadonlyArray.containsWith;
+
+/**
+ * Returns the first element that satisfies the specified
+ * predicate, or `None` if no such element exists.
+ *
+ * @category elements
+ * @since 2.0.0
+ */
+const findFirst = ReadonlyArray_dist_effectReadonlyArray.findFirst;
+
+/**
+ * Return the first index for which a predicate holds.
+ *
+ * @category elements
+ * @since 2.0.0
+ */
+const findFirstIndex = ReadonlyArray_dist_effectReadonlyArray.findFirstIndex;
+
+/**
+ * Find the last element for which a predicate holds.
+ *
+ * @category elements
+ * @since 2.0.0
+ */
+const findLast = ReadonlyArray_dist_effectReadonlyArray.findLast;
+
+/**
+ * Return the last index for which a predicate holds.
+ *
+ * @category elements
+ * @since 2.0.0
+ */
+const findLastIndex = ReadonlyArray_dist_effectReadonlyArray.findLastIndex;
+
+/**
+ * Check if a predicate holds true for every `Chunk` element.
+ *
+ * @category elements
+ * @since 2.0.0
+ */
+const every = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, refinement) => ReadonlyArray_dist_effectReadonlyArray.fromIterable(self).every(refinement));
+
+/**
+ * Check if a predicate holds true for some `Chunk` element.
+ *
+ * @category elements
+ * @since 2.0.0
+ */
+const some = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, predicate) => ReadonlyArray_dist_effectReadonlyArray.fromIterable(self).some(predicate));
+
+/**
+ * Joins the elements together with "sep" in the middle.
+ *
+ * @category folding
+ * @since 2.0.0
+ */
+const join = ReadonlyArray_dist_effectReadonlyArray.join;
+
+/**
+ * @category folding
+ * @since 2.0.0
+ */
+const reduce = ReadonlyArray_dist_effectReadonlyArray.reduce;
+
+/**
+ * @category folding
+ * @since 2.0.0
+ */
+const reduceRight = ReadonlyArray_dist_effectReadonlyArray.reduceRight;
+
+exports.append = append;
+exports.appendAll = appendAll;
+exports.appendAllNonEmpty = appendAllNonEmpty;
+exports.chunksOf = chunksOf;
+exports.compact = compact;
+exports.contains = contains;
+exports.containsWith = containsWith;
+exports.dedupe = dedupe;
+exports.dedupeAdjacent = dedupeAdjacent;
+exports.drop = drop;
+exports.dropRight = dropRight;
+exports.dropWhile = dropWhile;
+exports.empty = empty;
+exports.every = every;
+exports.filter = filter;
+exports.filterMap = filterMap;
+exports.filterMapWhile = filterMapWhile;
+exports.findFirst = findFirst;
+exports.findFirstIndex = findFirstIndex;
+exports.findLast = findLast;
+exports.findLastIndex = findLastIndex;
+exports.flatMap = flatMap;
+exports.flatMapNonEmpty = flatMapNonEmpty;
+exports.flatten = flatten;
+exports.flattenNonEmpty = flattenNonEmpty;
+exports.forEach = forEach;
+exports.fromIterable = fromIterable;
+exports.get = get;
+exports.getEquivalence = getEquivalence;
+exports.head = head;
+exports.headNonEmpty = headNonEmpty;
+exports.intersection = intersection;
+exports.isChunk = isChunk;
+exports.isEmpty = isEmpty;
+exports.isNonEmpty = isNonEmpty;
+exports.join = join;
+exports.last = last;
+exports.make = make;
+exports.makeBy = makeBy;
+exports.map = map;
+exports.mapAccum = mapAccum;
+exports.modify = modify;
+exports.modifyOption = modifyOption;
+exports.of = of;
+exports.partition = partition;
+exports.partitionMap = partitionMap;
+exports.prepend = prepend;
+exports.prependAll = prependAll;
+exports.prependAllNonEmpty = prependAllNonEmpty;
+exports.range = range;
+exports.reduce = reduce;
+exports.reduceRight = reduceRight;
+exports.remove = remove;
+exports.replace = replace;
+exports.replaceOption = replaceOption;
+exports.reverse = reverse;
+exports.separate = separate;
+exports.size = size;
+exports.some = some;
+exports.sort = sort;
+exports.sortWith = sortWith;
+exports.split = split;
+exports.splitAt = splitAt;
+exports.splitWhere = splitWhere;
+exports.tail = tail;
+exports.tailNonEmpty = tailNonEmpty;
+exports.take = take;
+exports.takeRight = takeRight;
+exports.takeWhile = takeWhile;
+exports.toReadonlyArray = toReadonlyArray;
+exports.union = union;
+exports.unsafeFromArray = unsafeFromArray;
+exports.unsafeFromNonEmptyArray = unsafeFromNonEmptyArray;
+exports.unsafeGet = unsafeGet;
+exports.unsafeHead = unsafeHead;
+exports.unsafeLast = unsafeLast;
+exports.unzip = unzip;
+exports.zip = zip;
+exports.zipWith = zipWith;