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

package/dist/ReadonlyArray-48949ee7.cjs.dev.js

@@ -1,1721 +0,0 @@
-'use strict';
-
-var Either_dist_effectEither = require('./Either-a806809d.cjs.dev.js');
-var Equal_dist_effectEqual = require('./Equal-281b6ca8.cjs.dev.js');
-var Equivalence_dist_effectEquivalence = require('./Equivalence-de7a0d51.cjs.dev.js');
-var Function_dist_effectFunction = require('./Function-41ce433d.cjs.dev.js');
-var ReadonlyArray$1 = require('./ReadonlyArray-9a1474f6.cjs.dev.js');
-var Option_dist_effectOption = require('./Option-03997d77.cjs.dev.js');
-var Order_dist_effectOrder = require('./Order-28bdebd2.cjs.dev.js');
-var ReadonlyRecord_dist_effectReadonlyRecord = require('./ReadonlyRecord-605a625b.cjs.dev.js');
-
-/**
- * This module provides utility functions for working with arrays in TypeScript.
- *
- * @since 2.0.0
- */
-
-/**
- * @category type lambdas
- * @since 2.0.0
- */
-
-/**
- * @category models
- * @since 2.0.0
- */
-
-/**
- * @category models
- * @since 2.0.0
- */
-
-/**
- * Builds a `NonEmptyArray` from an non-empty collection of elements.
- *
- * @category constructors
- * @since 2.0.0
- */
-const make = (...elements) => elements;
-
-/**
- * Return a `NonEmptyArray` of length `n` with element `i` initialized with `f(i)`.
- *
- * **Note**. `n` is normalized to an integer >= 1.
- *
- * @example
- * import { makeBy } from 'effect/ReadonlyArray'
- *
- * assert.deepStrictEqual(makeBy(5, n => n * 2), [0, 2, 4, 6, 8])
- *
- * @category constructors
- * @since 2.0.0
- */
-const makeBy = (n, f) => {
-  const max = Math.max(1, Math.floor(n));
-  const out = [f(0)];
-  for (let i = 1; i < max; i++) {
-    out.push(f(i));
-  }
-  return out;
-};
-
-/**
- * Return a `NonEmptyArray` containing a range of integers, including both endpoints.
- *
- * @example
- * import { range } from 'effect/ReadonlyArray'
- *
- * assert.deepStrictEqual(range(1, 3), [1, 2, 3])
- *
- * @category constructors
- * @since 2.0.0
- */
-const range = (start, end) => start <= end ? makeBy(end - start + 1, i => start + i) : [start];
-
-/**
- * Return a `NonEmptyArray` containing a value repeated the specified number of times.
- *
- * **Note**. `n` is normalized to an integer >= 1.
- *
- * @example
- * import { replicate } from 'effect/ReadonlyArray'
- *
- * assert.deepStrictEqual(replicate("a", 3), ["a", "a", "a"])
- *
- * @category constructors
- * @since 2.0.0
- */
-const replicate = /*#__PURE__*/Function_dist_effectFunction.dual(2, (a, n) => makeBy(n, () => a));
-
-/**
- * @category conversions
- * @since 2.0.0
- */
-const fromIterable = collection => Array.isArray(collection) ? collection : Array.from(collection);
-
-/**
- * Takes a record and returns an array of tuples containing its keys and values.
- *
- * @param self - The record to transform.
- *
- * @example
- * import { fromRecord } from "effect/ReadonlyArray"
- *
- * const x = { a: 1, b: 2, c: 3 }
- * assert.deepStrictEqual(fromRecord(x), [["a", 1], ["b", 2], ["c", 3]])
- *
- * @category conversions
- * @since 2.0.0
- */
-const fromRecord = ReadonlyRecord_dist_effectReadonlyRecord.toEntries;
-
-/**
- * @category conversions
- * @since 2.0.0
- */
-const fromOption = Option_dist_effectOption.toArray;
-
-/**
- * @category pattern matching
- * @since 2.0.0
- */
-const match = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, {
-  onEmpty,
-  onNonEmpty
-}) => isNonEmptyReadonlyArray(self) ? onNonEmpty(self) : onEmpty());
-
-/**
- * @category pattern matching
- * @since 2.0.0
- */
-const matchLeft = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, {
-  onEmpty,
-  onNonEmpty
-}) => isNonEmptyReadonlyArray(self) ? onNonEmpty(headNonEmpty(self), tailNonEmpty(self)) : onEmpty());
-
-/**
- * @category pattern matching
- * @since 2.0.0
- */
-const matchRight = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, {
-  onEmpty,
-  onNonEmpty
-}) => isNonEmptyReadonlyArray(self) ? onNonEmpty(initNonEmpty(self), lastNonEmpty(self)) : onEmpty());
-
-/**
- * Prepend an element to the front of an `Iterable`, creating a new `NonEmptyArray`.
- *
- * @category concatenating
- * @since 2.0.0
- */
-const prepend = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, head) => [head, ...self]);
-
-/**
- * @category concatenating
- * @since 2.0.0
- */
-const prependAll = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => fromIterable(that).concat(fromIterable(self)));
-
-/**
- * @category concatenating
- * @since 2.0.0
- */
-const prependAllNonEmpty = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => prependAll(self, that));
-
-/**
- * Append an element to the end of an `Iterable`, creating a new `NonEmptyArray`.
- *
- * @category concatenating
- * @since 2.0.0
- */
-const append = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, last) => [...self, last]);
-
-/**
- * @category concatenating
- * @since 2.0.0
- */
-const appendAll = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => fromIterable(self).concat(fromIterable(that)));
-
-/**
- * @category concatenating
- * @since 2.0.0
- */
-const appendAllNonEmpty = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => appendAll(self, that));
-
-/**
- * Reduce an `Iterable` from the left, keeping all intermediate results instead of only the final result.
- *
- * @category folding
- * @since 2.0.0
- */
-const scan = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, b, f) => {
-  const out = [b];
-  let i = 0;
-  for (const a of self) {
-    out[i + 1] = f(out[i], a);
-    i++;
-  }
-  return out;
-});
-
-/**
- * Reduce an `Iterable` from the right, keeping all intermediate results instead of only the final result.
- *
- * @category folding
- * @since 2.0.0
- */
-const scanRight = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, b, f) => {
-  const input = fromIterable(self);
-  const out = new Array(input.length + 1);
-  out[input.length] = b;
-  for (let i = input.length - 1; i >= 0; i--) {
-    out[i] = f(out[i + 1], input[i]);
-  }
-  return out;
-});
-
-/**
- * Determine if an `Array` is empty narrowing down the type to `[]`.
- *
- * @param self - The `Array` to check.
- *
- * @example
- * import { isEmptyArray } from "effect/ReadonlyArray"
- *
- * assert.deepStrictEqual(isEmptyArray([]), true);
- * assert.deepStrictEqual(isEmptyArray([1, 2, 3]), false);
- *
- * @category guards
- * @since 2.0.0
- */
-const isEmptyArray = self => self.length === 0;
-
-/**
- * Determine if a `ReadonlyArray` is empty narrowing down the type to `readonly []`.
- *
- * @param self - The `ReadonlyArray` to check.
- *
- * @example
- * import { isEmptyReadonlyArray } from "effect/ReadonlyArray"
- *
- * assert.deepStrictEqual(isEmptyReadonlyArray([]), true);
- * assert.deepStrictEqual(isEmptyReadonlyArray([1, 2, 3]), false);
- *
- * @category guards
- * @since 2.0.0
- */
-const isEmptyReadonlyArray = isEmptyArray;
-
-/**
- * Determine if an `Array` is non empty narrowing down the type to `NonEmptyArray`.
- *
- * An `Array` is considered to be a `NonEmptyArray` if it contains at least one element.
- *
- * @param self - The `Array` to check.
- *
- * @example
- * import { isNonEmptyArray } from "effect/ReadonlyArray"
- *
- * assert.deepStrictEqual(isNonEmptyArray([]), false);
- * assert.deepStrictEqual(isNonEmptyArray([1, 2, 3]), true);
- *
- * @category guards
- * @since 2.0.0
- */
-const isNonEmptyArray = ReadonlyArray$1.isNonEmptyArray;
-
-/**
- * Determine if a `ReadonlyArray` is non empty narrowing down the type to `NonEmptyReadonlyArray`.
- *
- * A `ReadonlyArray` is considered to be a `NonEmptyReadonlyArray` if it contains at least one element.
- *
- * @param self - The `ReadonlyArray` to check.
- *
- * @example
- * import { isNonEmptyReadonlyArray } from "effect/ReadonlyArray"
- *
- * assert.deepStrictEqual(isNonEmptyReadonlyArray([]), false);
- * assert.deepStrictEqual(isNonEmptyReadonlyArray([1, 2, 3]), true);
- *
- * @category guards
- * @since 2.0.0
- */
-const isNonEmptyReadonlyArray = ReadonlyArray$1.isNonEmptyArray;
-
-/**
- * Return the number of elements in a `ReadonlyArray`.
- *
- * @category getters
- * @since 2.0.0
- */
-const length = self => self.length;
-const isOutOfBound = (i, as) => i < 0 || i >= as.length;
-const clamp = (i, as) => Math.floor(Math.min(Math.max(0, i), as.length));
-
-/**
- * This function provides a safe way to read a value at a particular index from a `ReadonlyArray`.
- *
- * @category getters
- * @since 2.0.0
- */
-const get = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, index) => {
-  const i = Math.floor(index);
-  return isOutOfBound(i, self) ? Option_dist_effectOption.none() : Option_dist_effectOption.some(self[i]);
-});
-
-/**
- * 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) => {
-  const i = Math.floor(index);
-  if (isOutOfBound(i, self)) {
-    throw new Error(`Index ${i} out of bounds`);
-  }
-  return self[i];
-});
-
-/**
- * Return a tuple containing the first element, and a new `Array` of the remaining elements, if any.
- *
- * @category getters
- * @since 2.0.0
- */
-const unprepend = self => [headNonEmpty(self), tailNonEmpty(self)];
-
-/**
- * Return a tuple containing a copy of the `NonEmptyReadonlyArray` without its last element, and that last element.
- *
- * @category getters
- * @since 2.0.0
- */
-const unappend = self => [initNonEmpty(self), lastNonEmpty(self)];
-
-/**
- * Get the first element of a `ReadonlyArray`, or `None` if the `ReadonlyArray` is empty.
- *
- * @category getters
- * @since 2.0.0
- */
-const head = /*#__PURE__*/get(0);
-
-/**
- * @category getters
- * @since 2.0.0
- */
-const headNonEmpty = /*#__PURE__*/unsafeGet(0);
-
-/**
- * Get the last element in a `ReadonlyArray`, or `None` if the `ReadonlyArray` is empty.
- *
- * @category getters
- * @since 2.0.0
- */
-const last = self => isNonEmptyReadonlyArray(self) ? Option_dist_effectOption.some(lastNonEmpty(self)) : Option_dist_effectOption.none();
-
-/**
- * @category getters
- * @since 2.0.0
- */
-const lastNonEmpty = self => self[self.length - 1];
-
-/**
- * Get all but the first element of an `Iterable`, creating a new `Array`, or `None` if the `Iterable` is empty.
- *
- * @category getters
- * @since 2.0.0
- */
-const tail = self => {
-  const input = fromIterable(self);
-  return isNonEmptyReadonlyArray(input) ? Option_dist_effectOption.some(tailNonEmpty(input)) : Option_dist_effectOption.none();
-};
-
-/**
- * @category getters
- * @since 2.0.0
- */
-const tailNonEmpty = self => self.slice(1);
-
-/**
- * Get all but the last element of an `Iterable`, creating a new `Array`, or `None` if the `Iterable` is empty.
- *
- * @category getters
- * @since 2.0.0
- */
-const init = self => {
-  const input = fromIterable(self);
-  return isNonEmptyReadonlyArray(input) ? Option_dist_effectOption.some(initNonEmpty(input)) : Option_dist_effectOption.none();
-};
-
-/**
- * Get all but the last element of a non empty array, creating a new array.
- *
- * @category getters
- * @since 2.0.0
- */
-const initNonEmpty = self => self.slice(0, -1);
-
-/**
- * Keep only a max number of elements from the start of an `Iterable`, creating a new `Array`.
- *
- * **Note**. `n` is normalized to a non negative integer.
- *
- * @category getters
- * @since 2.0.0
- */
-const take = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, n) => {
-  const input = fromIterable(self);
-  return input.slice(0, clamp(n, input));
-});
-
-/**
- * Keep only a max number of elements from the end of an `Iterable`, creating a new `Array`.
- *
- * **Note**. `n` is normalized to a non negative integer.
- *
- * @category getters
- * @since 2.0.0
- */
-const takeRight = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, n) => {
-  const input = fromIterable(self);
-  const i = clamp(n, input);
-  return i === 0 ? [] : input.slice(-i);
-});
-
-/**
- * Calculate the longest initial subarray for which all element satisfy the specified predicate, creating a new `Array`.
- *
- * @category getters
- * @since 2.0.0
- */
-const takeWhile = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, predicate) => {
-  const out = [];
-  for (const a of self) {
-    if (!predicate(a)) {
-      break;
-    }
-    out.push(a);
-  }
-  return out;
-});
-const spanIndex = (self, predicate) => {
-  let i = 0;
-  for (const a of self) {
-    if (!predicate(a)) {
-      break;
-    }
-    i++;
-  }
-  return i;
-};
-
-/**
- * Split an `Iterable` into two parts:
- *
- * 1. the longest initial subarray for which all elements satisfy the specified predicate
- * 2. the remaining elements
- *
- * @category filtering
- * @since 2.0.0
- */
-const span = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, predicate) => splitAt(self, spanIndex(self, predicate)));
-
-/**
- * Drop a max number of elements from the start of an `Iterable`, creating a new `Array`.
- *
- * **Note**. `n` is normalized to a non negative integer.
- *
- * @category getters
- * @since 2.0.0
- */
-const drop = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, n) => {
-  const input = fromIterable(self);
-  return input.slice(clamp(n, input), input.length);
-});
-
-/**
- * Drop a max number of elements from the end of an `Iterable`, creating a new `Array`.
- *
- * **Note**. `n` is normalized to a non negative integer.
- *
- * @category getters
- * @since 2.0.0
- */
-const dropRight = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, n) => {
-  const input = fromIterable(self);
-  return input.slice(0, input.length - clamp(n, input));
-});
-
-/**
- * Remove the longest initial subarray for which all element satisfy the specified predicate, creating a new `Array`.
- *
- * @category getters
- * @since 2.0.0
- */
-const dropWhile = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, predicate) => fromIterable(self).slice(spanIndex(self, predicate)));
-
-/**
- * Return the first index for which a predicate holds.
- *
- * @category elements
- * @since 2.0.0
- */
-const findFirstIndex = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, predicate) => {
-  let i = 0;
-  for (const a of self) {
-    if (predicate(a)) {
-      return Option_dist_effectOption.some(i);
-    }
-    i++;
-  }
-  return Option_dist_effectOption.none();
-});
-
-/**
- * Return the last index for which a predicate holds.
- *
- * @category elements
- * @since 2.0.0
- */
-const findLastIndex = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, predicate) => {
-  const input = fromIterable(self);
-  for (let i = input.length - 1; i >= 0; i--) {
-    if (predicate(input[i])) {
-      return Option_dist_effectOption.some(i);
-    }
-  }
-  return Option_dist_effectOption.none();
-});
-
-/**
- * Returns the first element that satisfies the specified
- * predicate, or `None` if no such element exists.
- *
- * @category elements
- * @since 2.0.0
- */
-const findFirst = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, predicate) => {
-  const input = fromIterable(self);
-  for (let i = 0; i < input.length; i++) {
-    if (predicate(input[i])) {
-      return Option_dist_effectOption.some(input[i]);
-    }
-  }
-  return Option_dist_effectOption.none();
-});
-
-/**
- * Find the last element for which a predicate holds.
- *
- * @category elements
- * @since 2.0.0
- */
-const findLast = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, predicate) => {
-  const input = fromIterable(self);
-  for (let i = input.length - 1; i >= 0; i--) {
-    if (predicate(input[i])) {
-      return Option_dist_effectOption.some(input[i]);
-    }
-  }
-  return Option_dist_effectOption.none();
-});
-
-/**
- * Insert an element at the specified index, creating a new `NonEmptyArray`,
- * or return `None` if the index is out of bounds.
- *
- * @since 2.0.0
- */
-const insertAt = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, i, b) => {
-  const out = Array.from(self);
-  //             v--- `= self.length` is ok, it means inserting in last position
-  if (i < 0 || i > out.length) {
-    return Option_dist_effectOption.none();
-  }
-  out.splice(i, 0, b);
-  return Option_dist_effectOption.some(out);
-});
-
-/**
- * Change the element at the specified index, creating a new `Array`,
- * or return a copy of 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));
-
-/**
- * Apply a function to the element at the specified index, creating a new `Array`,
- * or return a copy of 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), () => Array.from(self)));
-
-/**
- * Apply a function to the element at the specified index, creating a new `Array`,
- * or return `None` if the index is out of bounds.
- *
- * @since 2.0.0
- */
-const modifyOption = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, i, f) => {
-  const out = Array.from(self);
-  if (isOutOfBound(i, out)) {
-    return Option_dist_effectOption.none();
-  }
-  const next = f(out[i]);
-  // @ts-expect-error
-  out[i] = next;
-  return Option_dist_effectOption.some(out);
-});
-
-/**
- * Delete the element at the specified index, creating a new `Array`,
- * or return a copy of the input if the index is out of bounds.
- *
- * @since 2.0.0
- */
-const remove = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, i) => {
-  const out = Array.from(self);
-  if (isOutOfBound(i, out)) {
-    return out;
-  }
-  out.splice(i, 1);
-  return out;
-});
-
-/**
- * Reverse an `Iterable`, creating a new `Array`.
- *
- * @category elements
- * @since 2.0.0
- */
-const reverse = self => Array.from(self).reverse();
-
-/**
- * @category elements
- * @since 2.0.0
- */
-const reverseNonEmpty = self => [lastNonEmpty(self), ...self.slice(0, -1).reverse()];
-
-/**
- * Sort the elements of an `Iterable` in increasing order, creating a new `Array`.
- *
- * @category sorting
- * @since 2.0.0
- */
-const sort = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, O) => {
-  const out = Array.from(self);
-  out.sort(O);
-  return out;
-});
-
-/**
- * @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)));
-
-/**
- * Sort the elements of a `NonEmptyReadonlyArray` in increasing order, creating a new `NonEmptyArray`.
- *
- * @category sorting
- * @since 2.0.0
- */
-const sortNonEmpty = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, O) => sort(O)(self));
-
-/**
- * Sort the elements of an `Iterable` in increasing order, where elements are compared
- * using first `orders[0]`, then `orders[1]`, etc...
- *
- * @category sorting
- * @since 2.0.0
- */
-const sortBy = (...orders) => self => {
-  const input = fromIterable(self);
-  return isNonEmptyReadonlyArray(input) ? sortByNonEmpty(...orders)(input) : [];
-};
-
-/**
- * @category sorting
- * @since 2.0.0
- */
-const sortByNonEmpty = (...orders) => sortNonEmpty(Order_dist_effectOrder.combineAll(orders));
-
-/**
- * Takes two `Iterable`s and returns an `Array` of corresponding pairs.
- * If one input `Iterable` is short, excess elements of the
- * longer `Iterable` are discarded.
- *
- * @since 2.0.0
- */
-const zip = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => zipWith(self, that, (a, b) => [a, b]));
-
-/**
- * Apply a function to pairs of elements at the same index in two `Iterable`s, collecting the results in a new `Array`. If one
- * input `Iterable` is short, excess elements of the longer `Iterable` are discarded.
- *
- * @since 2.0.0
- */
-const zipWith = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, that, f) => {
-  const as = fromIterable(self);
-  const bs = fromIterable(that);
-  return isNonEmptyReadonlyArray(as) && isNonEmptyReadonlyArray(bs) ? zipNonEmptyWith(bs, f)(as) : [];
-});
-
-/**
- * @since 2.0.0
- */
-const zipNonEmpty = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => zipNonEmptyWith(self, that, (a, b) => [a, b]));
-
-/**
- * @since 2.0.0
- */
-const zipNonEmptyWith = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, that, f) => {
-  const cs = [f(headNonEmpty(self), headNonEmpty(that))];
-  const len = Math.min(self.length, that.length);
-  for (let i = 1; i < len; i++) {
-    cs[i] = f(self[i], that[i]);
-  }
-  return cs;
-});
-
-/**
- * This function is the inverse of `zip`. Takes an `Iterable` of pairs and return two corresponding `Array`s.
- *
- * @since 2.0.0
- */
-const unzip = self => {
-  const input = fromIterable(self);
-  return isNonEmptyReadonlyArray(input) ? unzipNonEmpty(input) : [[], []];
-};
-
-/**
- * @since 2.0.0
- */
-const unzipNonEmpty = self => {
-  const fa = [self[0][0]];
-  const fb = [self[0][1]];
-  for (let i = 1; i < self.length; i++) {
-    fa[i] = self[i][0];
-    fb[i] = self[i][1];
-  }
-  return [fa, fb];
-};
-
-/**
- * Places an element in between members of an `Iterable`
- *
- * @since 2.0.0
- */
-const intersperse = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, middle) => {
-  const input = fromIterable(self);
-  return isNonEmptyReadonlyArray(input) ? intersperseNonEmpty(input, middle) : [];
-});
-
-/**
- * Places an element in between members of a `NonEmptyReadonlyArray`
- *
- * @since 2.0.0
- */
-const intersperseNonEmpty = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, middle) => {
-  const out = [headNonEmpty(self)];
-  const tail = tailNonEmpty(self);
-  for (let i = 0; i < tail.length; i++) {
-    if (i < tail.length) {
-      out.push(middle);
-    }
-    out.push(tail[i]);
-  }
-  return out;
-});
-
-/**
- * Apply a function to the head, creating a new `NonEmptyReadonlyArray`.
- *
- * @since 2.0.0
- */
-const modifyNonEmptyHead = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => [f(headNonEmpty(self)), ...tailNonEmpty(self)]);
-
-/**
- * Change the head, creating a new `NonEmptyReadonlyArray`.
- *
- * @since 2.0.0
- */
-const setNonEmptyHead = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, b) => modifyNonEmptyHead(self, () => b));
-
-/**
- * Apply a function to the last element, creating a new `NonEmptyReadonlyArray`.
- *
- * @since 2.0.0
- */
-const modifyNonEmptyLast = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => append(initNonEmpty(self), f(lastNonEmpty(self))));
-
-/**
- * Change the last element, creating a new `NonEmptyReadonlyArray`.
- *
- * @since 2.0.0
- */
-const setNonEmptyLast = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, b) => modifyNonEmptyLast(self, () => b));
-
-/**
- * Rotate an `Iterable` by `n` steps.
- *
- * @since 2.0.0
- */
-const rotate = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, n) => {
-  const input = fromIterable(self);
-  return isNonEmptyReadonlyArray(input) ? rotateNonEmpty(input, n) : [];
-});
-
-/**
- * Rotate a `NonEmptyReadonlyArray` by `n` steps.
- *
- * @since 2.0.0
- */
-const rotateNonEmpty = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, n) => {
-  const len = self.length;
-  const m = Math.round(n) % len;
-  if (isOutOfBound(Math.abs(m), self) || m === 0) {
-    return copy(self);
-  }
-  if (m < 0) {
-    const [f, s] = splitNonEmptyAt(self, -m);
-    return appendAllNonEmpty(s, f);
-  } else {
-    return rotateNonEmpty(self, m - len);
-  }
-});
-
-/**
- * Returns a function that checks if a `ReadonlyArray` contains a given value using a provided `isEquivalent` function.
- *
- * @category elements
- * @since 2.0.0
- */
-const containsWith = isEquivalent => Function_dist_effectFunction.dual(2, (self, a) => {
-  for (const i of self) {
-    if (isEquivalent(a, i)) {
-      return true;
-    }
-  }
-  return false;
-});
-const _equivalence = /*#__PURE__*/Equal_dist_effectEqual.equivalence();
-
-/**
- * Returns a function that checks if a `ReadonlyArray` contains a given value using the default `Equivalence`.
- *
- * @category elements
- * @since 2.0.0
- */
-const contains = /*#__PURE__*/containsWith(_equivalence);
-
-/**
- * Remove duplicates from a `NonEmptyReadonlyArray`, keeping the first occurrence of an element using the provided `isEquivalent` function.
- *
- * @since 2.0.0
- */
-const dedupeNonEmptyWith = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, isEquivalent) => {
-  const out = [headNonEmpty(self)];
-  const rest = tailNonEmpty(self);
-  for (const a of rest) {
-    if (out.every(o => !isEquivalent(a, o))) {
-      out.push(a);
-    }
-  }
-  return out;
-});
-
-/**
- * Remove duplicates from a `NonEmptyReadonlyArray`, keeping the first occurrence of an element.
- *
- * @since 2.0.0
- */
-const dedupeNonEmpty = /*#__PURE__*/dedupeNonEmptyWith( /*#__PURE__*/Equal_dist_effectEqual.equivalence());
-
-/**
- * A useful recursion pattern for processing an `Iterable` to produce a new `Array`, often used for "chopping" up the input
- * `Iterable`. Typically chop is called with some function that will consume an initial prefix of the `Iterable` and produce a
- * value and the rest of the `Array`.
- *
- * @since 2.0.0
- */
-const chop = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
-  const input = fromIterable(self);
-  return isNonEmptyReadonlyArray(input) ? chopNonEmpty(input, f) : [];
-});
-
-/**
- * A useful recursion pattern for processing a `NonEmptyReadonlyArray` to produce a new `NonEmptyReadonlyArray`, often used for "chopping" up the input
- * `NonEmptyReadonlyArray`. Typically `chop` is called with some function that will consume an initial prefix of the `NonEmptyReadonlyArray` and produce a
- * value and the tail of the `NonEmptyReadonlyArray`.
- *
- * @since 2.0.0
- */
-const chopNonEmpty = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
-  const [b, rest] = f(self);
-  const out = [b];
-  let next = rest;
-  while (ReadonlyArray$1.isNonEmptyArray(next)) {
-    const [b, rest] = f(next);
-    out.push(b);
-    next = rest;
-  }
-  return out;
-});
-
-/**
- * Splits an `Iterable` into two pieces, the first piece has max `n` elements.
- *
- * @category getters
- * @since 2.0.0
- */
-const splitAt = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, n) => {
-  const input = Array.from(self);
-  return n >= 1 && isNonEmptyReadonlyArray(input) ? splitNonEmptyAt(input, n) : isEmptyReadonlyArray(input) ? [input, []] : [[], input];
-});
-
-/**
- * @since 2.0.0
- */
-const copy = self => self.slice();
-
-/**
- * Splits a `NonEmptyReadonlyArray` into two pieces, the first piece has max `n` elements.
- *
- * @category getters
- * @since 2.0.0
- */
-const splitNonEmptyAt = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, n) => {
-  const m = Math.max(1, n);
-  return m >= self.length ? [copy(self), []] : [prepend(self.slice(1, m), headNonEmpty(self)), self.slice(m)];
-});
-
-/**
- * Splits an `Iterable` into length-`n` pieces. The last piece will be shorter if `n` does not evenly divide the length of
- * the `Iterable`. Note that `chunksOf(n)([])` is `[]`, not `[[]]`. This is intentional, and is consistent with a recursive
- * definition of `chunksOf`; it satisfies the property that
- *
- * ```ts
- * chunksOf(n)(xs).concat(chunksOf(n)(ys)) == chunksOf(n)(xs.concat(ys)))
- * ```
- *
- * whenever `n` evenly divides the length of `self`.
- *
- * @category getters
- * @since 2.0.0
- */
-const chunksOf = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, n) => {
-  const input = fromIterable(self);
-  return isNonEmptyReadonlyArray(input) ? chunksOfNonEmpty(input, n) : [];
-});
-
-/**
- * Splits a `NonEmptyReadonlyArray` into length-`n` pieces. The last piece will be shorter if `n` does not evenly divide the length of
- * the `NonEmptyReadonlyArray`.
- *
- * @category getters
- * @since 2.0.0
- */
-const chunksOfNonEmpty = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, n) => chopNonEmpty(self, splitNonEmptyAt(n)));
-
-/**
- * Group equal, consecutive elements of a `NonEmptyReadonlyArray` into `NonEmptyArray`s using the provided `isEquivalent` function.
- *
- * @category grouping
- * @since 2.0.0
- */
-const groupWith = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, isEquivalent) => chopNonEmpty(self, as => {
-  const h = headNonEmpty(as);
-  const out = [h];
-  let i = 1;
-  for (; i < as.length; i++) {
-    const a = as[i];
-    if (isEquivalent(a, h)) {
-      out.push(a);
-    } else {
-      break;
-    }
-  }
-  return [out, as.slice(i)];
-}));
-
-/**
- * Group equal, consecutive elements of a `NonEmptyReadonlyArray` into `NonEmptyArray`s.
- *
- * @category grouping
- * @since 2.0.0
- */
-const group = /*#__PURE__*/groupWith( /*#__PURE__*/Equal_dist_effectEqual.equivalence());
-
-/**
- * Splits an `Iterable` into sub-non-empty-arrays stored in an object, based on the result of calling a `string`-returning
- * function on each element, and grouping the results according to values returned
- *
- * @category grouping
- * @since 2.0.0
- */
-const groupBy = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
-  const out = {};
-  for (const a of self) {
-    const k = f(a);
-    if (Object.prototype.hasOwnProperty.call(out, k)) {
-      out[k].push(a);
-    } else {
-      out[k] = [a];
-    }
-  }
-  return out;
-});
-
-/**
- * @since 2.0.0
- */
-const unionWith = isEquivalent => Function_dist_effectFunction.dual(2, (self, that) => {
-  const a = fromIterable(self);
-  const b = fromIterable(that);
-  return isNonEmptyReadonlyArray(a) && isNonEmptyReadonlyArray(b) ? unionNonEmptyWith(isEquivalent)(a, b) : isNonEmptyReadonlyArray(a) ? a : b;
-});
-
-/**
- * @since 2.0.0
- */
-const union = /*#__PURE__*/unionWith(_equivalence);
-
-/**
- * @since 2.0.0
- */
-const unionNonEmptyWith = isEquivalent => {
-  const dedupe = dedupeNonEmptyWith(isEquivalent);
-  return Function_dist_effectFunction.dual(2, (self, that) => dedupe(appendAllNonEmpty(self, that)));
-};
-
-/**
- * @since 2.0.0
- */
-const unionNonEmpty = /*#__PURE__*/unionNonEmptyWith(_equivalence);
-
-/**
- * Creates an `Array` of unique values that are included in all given `Iterable`s using the provided `isEquivalent` function.
- * The order and references of result values are determined by the first `Iterable`.
- *
- * @since 2.0.0
- */
-const intersectionWith = isEquivalent => {
-  const has = containsWith(isEquivalent);
-  return Function_dist_effectFunction.dual(2, (self, that) => fromIterable(self).filter(a => has(that, a)));
-};
-
-/**
- * Creates an `Array` of unique values that are included in all given `Iterable`s.
- * The order and references of result values are determined by the first `Iterable`.
- *
- * @since 2.0.0
- */
-const intersection = /*#__PURE__*/intersectionWith(_equivalence);
-
-/**
- * Creates a `Array` of values not included in the other given `Iterable` using the provided `isEquivalent` function.
- * The order and references of result values are determined by the first `Iterable`.
- *
- * @since 2.0.0
- */
-const differenceWith = isEquivalent => {
-  const has = containsWith(isEquivalent);
-  return Function_dist_effectFunction.dual(2, (self, that) => fromIterable(self).filter(a => !has(that, a)));
-};
-
-/**
- * Creates a `Array` of values not included in the other given `Iterable` using the provided `isEquivalent` function.
- * The order and references of result values are determined by the first `Iterable`.
- *
- * @since 2.0.0
- */
-const difference = /*#__PURE__*/differenceWith(_equivalence);
-
-/**
- * @category constructors
- * @since 2.0.0
- */
-const empty = () => [];
-
-/**
- * Constructs a new `NonEmptyArray<A>` from the specified value.
- *
- * @category constructors
- * @since 2.0.0
- */
-const of = a => [a];
-
-/**
- * @category mapping
- * @since 2.0.0
- */
-const map = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => self.map(f));
-
-/**
- * @category mapping
- * @since 2.0.0
- */
-const mapNonEmpty = map;
-
-/**
- * @category sequencing
- * @since 2.0.0
- */
-const flatMap = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
-  if (isEmptyReadonlyArray(self)) {
-    return [];
-  }
-  const out = [];
-  for (let i = 0; i < self.length; i++) {
-    out.push(...f(self[i], i));
-  }
-  return out;
-});
-
-/**
- * @category sequencing
- * @since 2.0.0
- */
-const flatMapNonEmpty = flatMap;
-
-/**
- * @category sequencing
- * @since 2.0.0
- */
-const flatten = /*#__PURE__*/flatMap(Function_dist_effectFunction.identity);
-
-/**
- * @category sequencing
- * @since 2.0.0
- */
-const flattenNonEmpty = /*#__PURE__*/flatMapNonEmpty(Function_dist_effectFunction.identity);
-
-/**
- * @category filtering
- * @since 2.0.0
- */
-const filterMap = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
-  const as = fromIterable(self);
-  const out = [];
-  for (let i = 0; i < as.length; i++) {
-    const o = f(as[i], i);
-    if (Option_dist_effectOption.isSome(o)) {
-      out.push(o.value);
-    }
-  }
-  return out;
-});
-
-/**
- * Transforms all elements of the `readonlyArray` for as long as the specified function returns some value
- *
- * @category filtering
- * @since 2.0.0
- */
-const filterMapWhile = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
-  const out = [];
-  for (const a of self) {
-    const b = f(a);
-    if (Option_dist_effectOption.isSome(b)) {
-      out.push(b.value);
-    } else {
-      break;
-    }
-  }
-  return out;
-});
-
-/**
- * @category filtering
- * @since 2.0.0
- */
-const partitionMap = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
-  const left = [];
-  const right = [];
-  const as = fromIterable(self);
-  for (let i = 0; i < as.length; i++) {
-    const e = f(as[i], i);
-    if (Either_dist_effectEither.isLeft(e)) {
-      left.push(e.left);
-    } else {
-      right.push(e.right);
-    }
-  }
-  return [left, right];
-});
-
-/**
- * @category filtering
- * @since 2.0.0
- */
-const compact = /*#__PURE__*/filterMap(Function_dist_effectFunction.identity);
-
-/**
- * @category filtering
- * @since 2.0.0
- */
-const filter = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, predicate) => {
-  const as = fromIterable(self);
-  const out = [];
-  for (let i = 0; i < as.length; i++) {
-    if (predicate(as[i], i)) {
-      out.push(as[i]);
-    }
-  }
-  return out;
-});
-
-/**
- * @category filtering
- * @since 2.0.0
- */
-const partition = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, predicate) => {
-  const left = [];
-  const right = [];
-  const as = fromIterable(self);
-  for (let i = 0; i < as.length; i++) {
-    if (predicate(as[i], i)) {
-      right.push(as[i]);
-    } else {
-      left.push(as[i]);
-    }
-  }
-  return [left, right];
-});
-
-/**
- * @category filtering
- * @since 2.0.0
- */
-const separate = /*#__PURE__*/partitionMap(Function_dist_effectFunction.identity);
-
-/**
- * @category folding
- * @since 2.0.0
- */
-const reduce = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, b, f) => fromIterable(self).reduce((b, a, i) => f(b, a, i), b));
-
-/**
- * @category folding
- * @since 2.0.0
- */
-const reduceRight = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, b, f) => fromIterable(self).reduceRight((b, a, i) => f(b, a, i), b));
-
-/**
- * @category lifting
- * @since 2.0.0
- */
-const liftPredicate = predicate => b => predicate(b) ? [b] : [];
-
-/**
- * @category lifting
- * @since 2.0.0
- */
-const liftOption = f => (...a) => fromOption(f(...a));
-
-/**
- * @category conversions
- * @since 2.0.0
- */
-const fromNullable = a => a == null ? empty() : [a];
-
-/**
- * @category lifting
- * @since 2.0.0
- */
-const liftNullable = f => (...a) => fromNullable(f(...a));
-
-/**
- * @category combining
- * @since 2.0.0
- */
-const flatMapNullable = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => isNonEmptyReadonlyArray(self) ? fromNullable(f(headNonEmpty(self))) : empty());
-
-/**
- * @category lifting
- * @since 2.0.0
- */
-const liftEither = f => (...a) => {
-  const e = f(...a);
-  return Either_dist_effectEither.isLeft(e) ? [] : [e.right];
-};
-
-/**
- * Check if a predicate holds true for every `ReadonlyArray` element.
- *
- * @category elements
- * @since 2.0.0
- */
-const every = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, refinement) => self.every(refinement));
-
-/**
- * Check if a predicate holds true for some `ReadonlyArray` element.
- *
- * @category elements
- * @since 2.0.0
- */
-const some = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, predicate) => self.some(predicate));
-
-/**
- * @since 2.0.0
- */
-const extend = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => self.map((_, i, as) => f(as.slice(i))));
-
-/**
- * @since 2.0.0
- */
-const min = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, O) => self.reduce(Order_dist_effectOrder.min(O)));
-
-/**
- * @since 2.0.0
- */
-const max = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, O) => self.reduce(Order_dist_effectOrder.max(O)));
-
-/**
- * @category constructors
- * @since 2.0.0
- */
-const unfold = (b, f) => {
-  const out = [];
-  let next = b;
-  let o;
-  while (Option_dist_effectOption.isSome(o = f(next))) {
-    const [a, b] = o.value;
-    out.push(a);
-    next = b;
-  }
-  return out;
-};
-
-/**
- * This function creates and returns a new `Order` for an array of values based on a given `Order` for the elements of the array.
- * The returned `Order` compares two arrays by applying the given `Order` to each element in the arrays.
- * If all elements are equal, the arrays are then compared based on their length.
- * It is useful when you need to compare two arrays of the same type and you have a specific way of comparing each element of the array.
- *
- * @category instances
- * @since 2.0.0
- */
-const getOrder = Order_dist_effectOrder.array;
-
-/**
- * @category instances
- * @since 2.0.0
- */
-const getEquivalence = Equivalence_dist_effectEquivalence.array;
-
-/**
- * Iterate over the `Iterable` applying `f`.
- *
- * @since 2.0.0
- */
-const forEach = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => fromIterable(self).forEach((a, i) => f(a, i)));
-
-/**
- * Remove duplicates from am `Iterable` using the provided `isEquivalent` function, keeping the first occurrence of an element.
- *
- * @since 2.0.0
- */
-const dedupeWith = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, isEquivalent) => {
-  const input = fromIterable(self);
-  return isNonEmptyReadonlyArray(input) ? dedupeNonEmptyWith(isEquivalent)(input) : [];
-});
-
-/**
- * Remove duplicates from am `Iterable`, keeping the first occurrence of an element.
- *
- * @since 2.0.0
- */
-const dedupe = /*#__PURE__*/dedupeWith( /*#__PURE__*/Equal_dist_effectEqual.equivalence());
-
-/**
- * Deduplicates adjacent elements that are identical using the provided `isEquivalent` function.
- *
- * @since 2.0.0
- */
-const dedupeAdjacentWith = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, isEquivalent) => {
-  const out = [];
-  let lastA = Option_dist_effectOption.none();
-  for (const a of self) {
-    if (Option_dist_effectOption.isNone(lastA) || !isEquivalent(a, lastA.value)) {
-      out.push(a);
-      lastA = Option_dist_effectOption.some(a);
-    }
-  }
-  return out;
-});
-
-/**
- * Deduplicates adjacent elements that are identical.
- *
- * @since 2.0.0
- */
-const dedupeAdjacent = /*#__PURE__*/dedupeAdjacentWith( /*#__PURE__*/Equal_dist_effectEqual.equivalence());
-
-/**
- * Joins the elements together with "sep" in the middle.
- *
- * @since 2.0.0
- * @category folding
- */
-const join = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, sep) => fromIterable(self).join(sep));
-
-/**
- * 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) => {
-  let s1 = s;
-  const out = [];
-  for (const a of self) {
-    const r = f(s1, a);
-    s1 = r[0];
-    out.push(r[1]);
-  }
-  return [s1, out];
-});
-
-/**
- * Zips this chunk crosswise with the specified chunk using the specified combiner.
- *
- * @since 2.0.0
- * @category elements
- */
-const cartesianWith = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, that, f) => flatMap(self, a => map(that, b => f(a, b))));
-
-/**
- * Zips this chunk crosswise with the specified chunk.
- *
- * @since 2.0.0
- * @category elements
- */
-const cartesian = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => cartesianWith(self, that, (a, b) => [a, b]));
-
-var ReadonlyArray = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  make: make,
-  makeBy: makeBy,
-  range: range,
-  replicate: replicate,
-  fromIterable: fromIterable,
-  fromRecord: fromRecord,
-  fromOption: fromOption,
-  match: match,
-  matchLeft: matchLeft,
-  matchRight: matchRight,
-  prepend: prepend,
-  prependAll: prependAll,
-  prependAllNonEmpty: prependAllNonEmpty,
-  append: append,
-  appendAll: appendAll,
-  appendAllNonEmpty: appendAllNonEmpty,
-  scan: scan,
-  scanRight: scanRight,
-  isEmptyArray: isEmptyArray,
-  isEmptyReadonlyArray: isEmptyReadonlyArray,
-  isNonEmptyArray: isNonEmptyArray,
-  isNonEmptyReadonlyArray: isNonEmptyReadonlyArray,
-  length: length,
-  get: get,
-  unsafeGet: unsafeGet,
-  unprepend: unprepend,
-  unappend: unappend,
-  head: head,
-  headNonEmpty: headNonEmpty,
-  last: last,
-  lastNonEmpty: lastNonEmpty,
-  tail: tail,
-  tailNonEmpty: tailNonEmpty,
-  init: init,
-  initNonEmpty: initNonEmpty,
-  take: take,
-  takeRight: takeRight,
-  takeWhile: takeWhile,
-  span: span,
-  drop: drop,
-  dropRight: dropRight,
-  dropWhile: dropWhile,
-  findFirstIndex: findFirstIndex,
-  findLastIndex: findLastIndex,
-  findFirst: findFirst,
-  findLast: findLast,
-  insertAt: insertAt,
-  replace: replace,
-  replaceOption: replaceOption,
-  modify: modify,
-  modifyOption: modifyOption,
-  remove: remove,
-  reverse: reverse,
-  reverseNonEmpty: reverseNonEmpty,
-  sort: sort,
-  sortWith: sortWith,
-  sortNonEmpty: sortNonEmpty,
-  sortBy: sortBy,
-  sortByNonEmpty: sortByNonEmpty,
-  zip: zip,
-  zipWith: zipWith,
-  zipNonEmpty: zipNonEmpty,
-  zipNonEmptyWith: zipNonEmptyWith,
-  unzip: unzip,
-  unzipNonEmpty: unzipNonEmpty,
-  intersperse: intersperse,
-  intersperseNonEmpty: intersperseNonEmpty,
-  modifyNonEmptyHead: modifyNonEmptyHead,
-  setNonEmptyHead: setNonEmptyHead,
-  modifyNonEmptyLast: modifyNonEmptyLast,
-  setNonEmptyLast: setNonEmptyLast,
-  rotate: rotate,
-  rotateNonEmpty: rotateNonEmpty,
-  containsWith: containsWith,
-  contains: contains,
-  dedupeNonEmptyWith: dedupeNonEmptyWith,
-  dedupeNonEmpty: dedupeNonEmpty,
-  chop: chop,
-  chopNonEmpty: chopNonEmpty,
-  splitAt: splitAt,
-  copy: copy,
-  splitNonEmptyAt: splitNonEmptyAt,
-  chunksOf: chunksOf,
-  chunksOfNonEmpty: chunksOfNonEmpty,
-  groupWith: groupWith,
-  group: group,
-  groupBy: groupBy,
-  unionWith: unionWith,
-  union: union,
-  unionNonEmptyWith: unionNonEmptyWith,
-  unionNonEmpty: unionNonEmpty,
-  intersectionWith: intersectionWith,
-  intersection: intersection,
-  differenceWith: differenceWith,
-  difference: difference,
-  empty: empty,
-  of: of,
-  map: map,
-  mapNonEmpty: mapNonEmpty,
-  flatMap: flatMap,
-  flatMapNonEmpty: flatMapNonEmpty,
-  flatten: flatten,
-  flattenNonEmpty: flattenNonEmpty,
-  filterMap: filterMap,
-  filterMapWhile: filterMapWhile,
-  partitionMap: partitionMap,
-  compact: compact,
-  filter: filter,
-  partition: partition,
-  separate: separate,
-  reduce: reduce,
-  reduceRight: reduceRight,
-  liftPredicate: liftPredicate,
-  liftOption: liftOption,
-  fromNullable: fromNullable,
-  liftNullable: liftNullable,
-  flatMapNullable: flatMapNullable,
-  liftEither: liftEither,
-  every: every,
-  some: some,
-  extend: extend,
-  min: min,
-  max: max,
-  unfold: unfold,
-  getOrder: getOrder,
-  getEquivalence: getEquivalence,
-  forEach: forEach,
-  dedupeWith: dedupeWith,
-  dedupe: dedupe,
-  dedupeAdjacentWith: dedupeAdjacentWith,
-  dedupeAdjacent: dedupeAdjacent,
-  join: join,
-  mapAccum: mapAccum,
-  cartesianWith: cartesianWith,
-  cartesian: cartesian
-});
-
-exports.ReadonlyArray = ReadonlyArray;
-exports.append = append;
-exports.appendAll = appendAll;
-exports.appendAllNonEmpty = appendAllNonEmpty;
-exports.cartesian = cartesian;
-exports.cartesianWith = cartesianWith;
-exports.chop = chop;
-exports.chopNonEmpty = chopNonEmpty;
-exports.chunksOf = chunksOf;
-exports.chunksOfNonEmpty = chunksOfNonEmpty;
-exports.compact = compact;
-exports.contains = contains;
-exports.containsWith = containsWith;
-exports.copy = copy;
-exports.dedupe = dedupe;
-exports.dedupeAdjacent = dedupeAdjacent;
-exports.dedupeAdjacentWith = dedupeAdjacentWith;
-exports.dedupeNonEmpty = dedupeNonEmpty;
-exports.dedupeNonEmptyWith = dedupeNonEmptyWith;
-exports.dedupeWith = dedupeWith;
-exports.difference = difference;
-exports.differenceWith = differenceWith;
-exports.drop = drop;
-exports.dropRight = dropRight;
-exports.dropWhile = dropWhile;
-exports.empty = empty;
-exports.every = every;
-exports.extend = extend;
-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.flatMapNullable = flatMapNullable;
-exports.flatten = flatten;
-exports.flattenNonEmpty = flattenNonEmpty;
-exports.forEach = forEach;
-exports.fromIterable = fromIterable;
-exports.fromNullable = fromNullable;
-exports.fromOption = fromOption;
-exports.fromRecord = fromRecord;
-exports.get = get;
-exports.getEquivalence = getEquivalence;
-exports.getOrder = getOrder;
-exports.group = group;
-exports.groupBy = groupBy;
-exports.groupWith = groupWith;
-exports.head = head;
-exports.headNonEmpty = headNonEmpty;
-exports.init = init;
-exports.initNonEmpty = initNonEmpty;
-exports.insertAt = insertAt;
-exports.intersection = intersection;
-exports.intersectionWith = intersectionWith;
-exports.intersperse = intersperse;
-exports.intersperseNonEmpty = intersperseNonEmpty;
-exports.isEmptyArray = isEmptyArray;
-exports.isEmptyReadonlyArray = isEmptyReadonlyArray;
-exports.isNonEmptyArray = isNonEmptyArray;
-exports.isNonEmptyReadonlyArray = isNonEmptyReadonlyArray;
-exports.join = join;
-exports.last = last;
-exports.lastNonEmpty = lastNonEmpty;
-exports.length = length;
-exports.liftEither = liftEither;
-exports.liftNullable = liftNullable;
-exports.liftOption = liftOption;
-exports.liftPredicate = liftPredicate;
-exports.make = make;
-exports.makeBy = makeBy;
-exports.map = map;
-exports.mapAccum = mapAccum;
-exports.mapNonEmpty = mapNonEmpty;
-exports.match = match;
-exports.matchLeft = matchLeft;
-exports.matchRight = matchRight;
-exports.max = max;
-exports.min = min;
-exports.modify = modify;
-exports.modifyNonEmptyHead = modifyNonEmptyHead;
-exports.modifyNonEmptyLast = modifyNonEmptyLast;
-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.replicate = replicate;
-exports.reverse = reverse;
-exports.reverseNonEmpty = reverseNonEmpty;
-exports.rotate = rotate;
-exports.rotateNonEmpty = rotateNonEmpty;
-exports.scan = scan;
-exports.scanRight = scanRight;
-exports.separate = separate;
-exports.setNonEmptyHead = setNonEmptyHead;
-exports.setNonEmptyLast = setNonEmptyLast;
-exports.some = some;
-exports.sort = sort;
-exports.sortBy = sortBy;
-exports.sortByNonEmpty = sortByNonEmpty;
-exports.sortNonEmpty = sortNonEmpty;
-exports.sortWith = sortWith;
-exports.span = span;
-exports.splitAt = splitAt;
-exports.splitNonEmptyAt = splitNonEmptyAt;
-exports.tail = tail;
-exports.tailNonEmpty = tailNonEmpty;
-exports.take = take;
-exports.takeRight = takeRight;
-exports.takeWhile = takeWhile;
-exports.unappend = unappend;
-exports.unfold = unfold;
-exports.union = union;
-exports.unionNonEmpty = unionNonEmpty;
-exports.unionNonEmptyWith = unionNonEmptyWith;
-exports.unionWith = unionWith;
-exports.unprepend = unprepend;
-exports.unsafeGet = unsafeGet;
-exports.unzip = unzip;
-exports.unzipNonEmpty = unzipNonEmpty;
-exports.zip = zip;
-exports.zipNonEmpty = zipNonEmpty;
-exports.zipNonEmptyWith = zipNonEmptyWith;
-exports.zipWith = zipWith;