effect 2.0.0-next.42 → 2.0.0-next.43

package/dist/Chunk-6cf5a8e6.cjs.prod.js

@@ -1,1248 +0,0 @@
-'use strict';
-
-var Equal_dist_effectEqual = require('./Equal-ce9977a8.cjs.prod.js');
-var Equivalence_dist_effectEquivalence = require('./Equivalence-0bc84518.cjs.prod.js');
-var Function_dist_effectFunction = require('./Function-2e6b0cda.cjs.prod.js');
-var Hash_dist_effectHash = require('./Hash-1bd73210.cjs.prod.js');
-var Inspectable_dist_effectInspectable = require('./Inspectable-3c4a0f5d.cjs.prod.js');
-var Option_dist_effectOption = require('./Option-02025c86.cjs.prod.js');
-var Order_dist_effectOrder = require('./Order-8a112bfb.cjs.prod.js');
-var Pipeable_dist_effectPipeable = require('./Pipeable-d3ec6711.cjs.prod.js');
-var Predicate_dist_effectPredicate = require('./Predicate-daa86e61.cjs.prod.js');
-var ReadonlyArray_dist_effectReadonlyArray = require('./ReadonlyArray-8157f697.cjs.prod.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;
-
-var Chunk = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  getEquivalence: getEquivalence,
-  isChunk: isChunk,
-  empty: empty,
-  make: make,
-  of: of,
-  fromIterable: fromIterable,
-  toReadonlyArray: toReadonlyArray,
-  reverse: reverse,
-  get: get,
-  unsafeFromArray: unsafeFromArray,
-  unsafeFromNonEmptyArray: unsafeFromNonEmptyArray,
-  unsafeGet: unsafeGet,
-  append: append,
-  prepend: prepend,
-  take: take,
-  drop: drop,
-  dropRight: dropRight,
-  dropWhile: dropWhile,
-  prependAll: prependAll,
-  prependAllNonEmpty: prependAllNonEmpty,
-  appendAll: appendAll,
-  appendAllNonEmpty: appendAllNonEmpty,
-  filterMap: filterMap,
-  filter: filter,
-  filterMapWhile: filterMapWhile,
-  compact: compact,
-  flatMap: flatMap,
-  flatMapNonEmpty: flatMapNonEmpty,
-  forEach: forEach,
-  flatten: flatten,
-  flattenNonEmpty: flattenNonEmpty,
-  chunksOf: chunksOf,
-  intersection: intersection,
-  isEmpty: isEmpty,
-  isNonEmpty: isNonEmpty,
-  head: head,
-  unsafeHead: unsafeHead,
-  headNonEmpty: headNonEmpty,
-  last: last,
-  unsafeLast: unsafeLast,
-  map: map,
-  mapAccum: mapAccum,
-  partition: partition,
-  partitionMap: partitionMap,
-  separate: separate,
-  size: size,
-  sort: sort,
-  sortWith: sortWith,
-  splitAt: splitAt,
-  split: split,
-  splitWhere: splitWhere,
-  tail: tail,
-  tailNonEmpty: tailNonEmpty,
-  takeRight: takeRight,
-  takeWhile: takeWhile,
-  union: union,
-  dedupe: dedupe,
-  dedupeAdjacent: dedupeAdjacent,
-  unzip: unzip,
-  zipWith: zipWith,
-  zip: zip,
-  remove: remove,
-  modifyOption: modifyOption,
-  modify: modify,
-  replace: replace,
-  replaceOption: replaceOption,
-  makeBy: makeBy,
-  range: range,
-  contains: contains,
-  containsWith: containsWith,
-  findFirst: findFirst,
-  findFirstIndex: findFirstIndex,
-  findLast: findLast,
-  findLastIndex: findLastIndex,
-  every: every,
-  some: some,
-  join: join,
-  reduce: reduce,
-  reduceRight: reduceRight
-});
-
-exports.Chunk = Chunk;
-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;