effect 2.0.0-next.38 → 2.0.0-next.39

package/dist/Chunk-4c1f4599.esm.js

@@ -1,1167 +0,0 @@
-import { s as symbol, e as equals } from './Equal-2a99fde3.esm.js';
-import { m as make$1 } from './Equivalence-cf2752b1.esm.js';
-import { d as dual, i as identity, p as pipe } from './Function-12511160.esm.js';
-import { s as symbol$1, a as array } from './Hash-7910f34f.esm.js';
-import { t as toString, a as toJSON, N as NodeInspectSymbol } from './Inspectable-b0c51e90.esm.js';
-import { n as none, s as some$1, l as liftPredicate, m as map$2, g as getOrElse } from './Option-df40d2b9.esm.js';
-import { m as mapInput } from './Order-a875fe30.esm.js';
-import { p as pipeArguments } from './Pipeable-10760a1d.esm.js';
-import { i as isObject } from './Predicate-6b61b95b.esm.js';
-import { f as fromIterable$1, r as reverse$1, a as filterMap$1, b as filterMapWhile$1, i as intersection$1, m as map$1, c as mapAccum$1, p as partition$1, d as partitionMap$1, s as separate$1, e as sort$1, u as union$1, g as dedupe$1, h as dedupeAdjacent$1, j as unzip$1, z as zipWith$1, k as remove$1, l as modifyOption$1, n as makeBy$1, o as contains$1, q as containsWith$1, t as findFirst$1, v as findFirstIndex$1, w as findLast$1, x as findLastIndex$1, y as join$1, A as reduce$1, B as reduceRight$1 } from './ReadonlyArray-0a71b226.esm.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 => make$1((self, that) => toReadonlyArray(self).every((value, i) => isEquivalent(value, unsafeGet(that, i))));
-const _equivalence = /*#__PURE__*/getEquivalence(equals);
-const ChunkProto = {
-  [TypeId]: {
-    _A: _ => _
-  },
-  toString() {
-    return toString(this.toJSON());
-  },
-  toJSON() {
-    return {
-      _id: "Chunk",
-      values: toReadonlyArray(this).map(toJSON)
-    };
-  },
-  [NodeInspectSymbol]() {
-    return this.toJSON();
-  },
-  [symbol](that) {
-    return isChunk(that) && _equivalence(this, that);
-  },
-  [symbol$1]() {
-    return 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 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 => 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: fromIterable$1(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: reverse$1(self.backing.array)
-        });
-      }
-    case "IConcat":
-      {
-        return makeChunk({
-          _tag: "IConcat",
-          left: reverse(self.backing.right),
-          right: reverse(self.backing.left)
-        });
-      }
-    case "ISlice":
-      return unsafeFromArray(reverse$1(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__*/dual(2, (self, index) => index < 0 || index >= self.length ? none() : some$1(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__*/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__*/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__*/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__*/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__*/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__*/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__*/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__*/dual(2, (self, that) => appendAll(that, self));
-
-/**
- * @category concatenating
- * @since 2.0.0
- */
-const prependAllNonEmpty = /*#__PURE__*/dual(2, (self, that) => prependAll(self, that));
-
-/**
- * Concatenates the two chunks
- *
- * @category concatenating
- * @since 2.0.0
- */
-const appendAll = /*#__PURE__*/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__*/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__*/dual(2, (self, f) => unsafeFromArray(filterMap$1(self, f)));
-
-/**
- * Returns a filtered and mapped subset of the elements.
- *
- * @since 2.0.0
- * @category filtering
- */
-const filter = /*#__PURE__*/dual(2, (self, predicate) => unsafeFromArray(filterMap$1(self, 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__*/dual(2, (self, f) => unsafeFromArray(filterMapWhile$1(self, f)));
-
-/**
- * Filter out optional values
- *
- * @since 2.0.0
- * @category filtering
- */
-const compact = self => filterMap(self, identity);
-
-/**
- * Returns a chunk with the elements mapped by the specified function.
- *
- * @since 2.0.0
- * @category sequencing
- */
-const flatMap = /*#__PURE__*/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__*/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(identity);
-
-/**
- * @category sequencing
- * @since 2.0.0
- */
-const flattenNonEmpty = /*#__PURE__*/flatMapNonEmpty(identity);
-
-/**
- * Groups elements in chunks of up to `n` elements.
- *
- * @since 2.0.0
- * @category elements
- */
-const chunksOf = /*#__PURE__*/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__*/dual(2, (self, that) => unsafeFromArray(intersection$1(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__*/dual(2, (self, f) => self.backing._tag === "ISingleton" ? of(f(self.backing.a, 0)) : unsafeFromArray(pipe(toReadonlyArray(self), map$1((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__*/dual(3, (self, s, f) => {
-  const [s1, as] = mapAccum$1(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__*/dual(2, (self, predicate) => pipe(partition$1(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__*/dual(2, (self, f) => pipe(partitionMap$1(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 => pipe(separate$1(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__*/dual(2, (self, O) => unsafeFromArray(sort$1(toReadonlyArray(self), O)));
-
-/**
- * @since 2.0.0
- * @category elements
- */
-const sortWith = /*#__PURE__*/dual(3, (self, f, order) => sort(self, mapInput(order, f)));
-
-/**
- *  Returns two splits of this chunk at the specified index.
- *
- * @since 2.0.0
- * @category elements
- */
-const splitAt = /*#__PURE__*/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__*/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__*/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 ? some$1(drop(self, 1)) : 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__*/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__*/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__*/dual(2, (self, that) => unsafeFromArray(union$1(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(dedupe$1(toReadonlyArray(self)));
-
-/**
- * Deduplicates adjacent elements that are identical.
- *
- * @since 2.0.0
- * @category filtering
- */
-const dedupeAdjacent = self => unsafeFromArray(dedupeAdjacent$1(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] = unzip$1(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__*/dual(3, (self, that, f) => unsafeFromArray(zipWith$1(self, that, f)));
-
-/**
- * Zips this chunk pointwise with the specified chunk.
- *
- * @since 2.0.0
- * @category elements
- */
-const zip = /*#__PURE__*/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__*/dual(2, (self, i) => unsafeFromArray(remove$1(toReadonlyArray(self), i)));
-
-/**
- * @since 2.0.0
- */
-const modifyOption = /*#__PURE__*/dual(3, (self, i, f) => map$2(modifyOption$1(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__*/dual(3, (self, i, f) => 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__*/dual(3, (self, i, b) => modify(self, i, () => b));
-
-/**
- * @since 2.0.0
- */
-const replaceOption = /*#__PURE__*/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__*/dual(2, (n, f) => fromIterable(makeBy$1(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 = contains$1;
-
-/**
- * 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 = containsWith$1;
-
-/**
- * Returns the first element that satisfies the specified
- * predicate, or `None` if no such element exists.
- *
- * @category elements
- * @since 2.0.0
- */
-const findFirst = findFirst$1;
-
-/**
- * Return the first index for which a predicate holds.
- *
- * @category elements
- * @since 2.0.0
- */
-const findFirstIndex = findFirstIndex$1;
-
-/**
- * Find the last element for which a predicate holds.
- *
- * @category elements
- * @since 2.0.0
- */
-const findLast = findLast$1;
-
-/**
- * Return the last index for which a predicate holds.
- *
- * @category elements
- * @since 2.0.0
- */
-const findLastIndex = findLastIndex$1;
-
-/**
- * Check if a predicate holds true for every `Chunk` element.
- *
- * @category elements
- * @since 2.0.0
- */
-const every = /*#__PURE__*/dual(2, (self, refinement) => fromIterable$1(self).every(refinement));
-
-/**
- * Check if a predicate holds true for some `Chunk` element.
- *
- * @category elements
- * @since 2.0.0
- */
-const some = /*#__PURE__*/dual(2, (self, predicate) => fromIterable$1(self).some(predicate));
-
-/**
- * Joins the elements together with "sep" in the middle.
- *
- * @category folding
- * @since 2.0.0
- */
-const join = join$1;
-
-/**
- * @category folding
- * @since 2.0.0
- */
-const reduce = reduce$1;
-
-/**
- * @category folding
- * @since 2.0.0
- */
-const reduceRight = reduceRight$1;
-
-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
-});
-
-export { flatMapNonEmpty as $, dropWhile as A, splitAt as B, last as C, range as D, reduceRight as E, filterMap as F, filterMapWhile as G, findFirst as H, flatMap as I, takeWhile as J, take as K, zipWith as L, mapAccum as M, isChunk as N, takeRight as O, partition as P, some as Q, Chunk as R, chunksOf as S, getEquivalence as T, get as U, unsafeFromNonEmptyArray as V, dropRight as W, prependAll as X, prependAllNonEmpty as Y, appendAllNonEmpty as Z, compact as _, unsafeHead as a, forEach as a0, flattenNonEmpty as a1, intersection as a2, partitionMap as a3, separate as a4, size as a5, sortWith as a6, split as a7, tail as a8, union as a9, dedupeAdjacent as aa, unzip as ab, zip as ac, remove as ad, modifyOption as ae, modify as af, replace as ag, replaceOption as ah, makeBy as ai, contains as aj, containsWith as ak, findFirstIndex as al, findLast as am, findLastIndex as an, every as ao, join as ap, appendAll as b, append as c, drop as d, empty as e, fromIterable as f, filter as g, isNonEmpty as h, isEmpty as i, headNonEmpty as j, head as k, unsafeFromArray as l, make as m, toReadonlyArray as n, of as o, prepend as p, dedupe as q, reverse as r, map as s, tailNonEmpty as t, unsafeGet as u, sort as v, unsafeLast as w, splitWhere as x, reduce as y, flatten as z };