@fncts/base 0.0.1

package/_mjs/collection/immutable/Vector/api.mjs

@@ -0,0 +1,1367 @@
+import * as tsplus_module_1 from "@fncts/base/collection/immutable/Vector";
+import * as tsplus_module_2 from "@fncts/base/collection/immutable/Vector/internal";
+import * as tsplus_module_3 from "@fncts/base/typeclass/Equatable/api";
+import * as tsplus_module_4 from "@fncts/base/collection/immutable/Vector/definition";
+import * as tsplus_module_5 from "@fncts/base/data/Maybe/constructors";
+import * as tsplus_module_6 from "@fncts/base/collection/mutable/ListBuffer";
+import * as tsplus_module_7 from "@fncts/base/data/Maybe/definition";
+export const append_ = append_1;
+export const concat_ = concat_1;
+export const dropRepeatsWith_ = dropRepeatsWith_1;
+export const empty = empty_1;
+export const emptyPushable = emptyPushable_1;
+export const exists_ = exists_1;
+export const findIndex_ = findIndex_1;
+export const flatten = flatten_1;
+export const foldLeft_ = foldLeft_1;
+export const foldLeftWithIndex_ = foldLeftWithIndex_1;
+export const foldMapWithIndex_ = foldMapWithIndex_1;
+export const foldRightWithIndex_ = foldRightWithIndex_1;
+export const forEach_ = forEach_1;
+export const map_ = map_1;
+export const mapWithIndex_ = mapWithIndex_1;
+export const mutableClone = mutableClone_1;
+export const pop = pop_1;
+export const slice_ = slice_1;
+export const sortWith_ = sortWith_1;
+export const splitAt_ = splitAt_1;
+export const unsafeFind_ = unsafeFind_1;
+export const unsafeFindLast_ = unsafeFindLast_1;
+export const unsafeGet_ = unsafeGet_1;
+export const unsafeHead = unsafeHead_1;
+export const unsafeLast = unsafeLast_1;
+export const updateAt_ = updateAt_1;
+export const vector = vector_1;
+import { affixPush, appendNodeToTree, arrayPush, branchBits, concatAffixes, concatBuffer, concatSubTree, copyArray, emptyAffix, foldLeftCb, foldLeftNode, foldLeftPrefix, foldLeftSuffix, foldRightCb, foldRightNode, foldRightPrefix, foldRightSuffix, getDepth, getHeight, getPrefixSize, getSuffixSize, handleOffset, incrementPrefix, incrementSuffix, mapAffix, mapNode, mapPrefix, mask, newAffix, newOffset, nodeNth, nodeNthDense, prependNodeToTree, reverseArray, setDepth, setPrefix, setSizes, setSuffix, sliceLeft, sliceRight, sliceTreeVector, updateNode, zeroOffset } from "@fncts/base/collection/immutable/Vector/internal";
+/**
+ * Appends an element to the end of a Vector and returns the new Vector.
+ *
+ * @complexity O(n)
+ *
+ * @tsplus fluent fncts.Vector append
+ */
+
+function append_1(as, a) {
+  const suffixSize = getSuffixSize(as);
+
+  if (suffixSize < 32) {
+    return new tsplus_module_1.Vector(incrementSuffix(as.bits), as.offset, as.length + 1, as.prefix, as.root, affixPush(a, as.suffix, suffixSize));
+  }
+
+  const newSuffix = [a];
+  const newVector = mutableClone_1(as);
+  appendNodeToTree(newVector, as.suffix);
+  newVector.suffix = newSuffix;
+  newVector.length++;
+  newVector.bits = setSuffix(1, newVector.bits);
+  return newVector;
+}
+/**
+ * Maps a function over a Vector and concatenates all the resulting
+ * Vectors together.
+ *
+ * @tsplus fluent fncts.Vector flatMap
+ */
+
+
+export function flatMap_(ma, f) {
+  return flatten_1(map_1(ma, f));
+}
+/**
+ * Splits the Vector into chunks of the given size.
+ *
+ * @tsplus fluent fncts.Vector chunksOf
+ */
+
+export function chunksOf_(as, size) {
+  const {
+    buffer,
+    l2
+  } = foldLeft_1(as, {
+    l2: emptyPushable_1(),
+    buffer: emptyPushable_1()
+  }, ({
+    buffer,
+    l2
+  }, elem) => {
+    tsplus_module_2.push(buffer, elem);
+
+    if (buffer.length === size) {
+      return {
+        l2: tsplus_module_2.push(l2, buffer),
+        buffer: emptyPushable_1()
+      };
+    } else {
+      return {
+        l2,
+        buffer
+      };
+    }
+  });
+  return buffer.length === 0 ? l2 : tsplus_module_2.push(l2, buffer);
+}
+
+function concat_1(self, that) {
+  if (self.length === 0) {
+    return that;
+  } else if (that.length === 0) {
+    return self;
+  }
+
+  const newSize = self.length + that.length;
+  const rightSuffixSize = getSuffixSize(that);
+  let newVector = mutableClone_1(self);
+
+  if (that.root === undefined) {
+    // right is nothing but a prefix and a suffix
+    const nrOfAffixes = concatAffixes(self, that);
+
+    for (let i = 0; i < nrOfAffixes; ++i) {
+      newVector = appendNodeToTree(newVector, concatBuffer[i]);
+      newVector.length += concatBuffer[i].length; // wipe pointer, otherwise it might end up keeping the array alive
+
+      concatBuffer[i] = undefined;
+    }
+
+    newVector.length = newSize;
+    newVector.suffix = concatBuffer[nrOfAffixes];
+    newVector.bits = setSuffix(concatBuffer[nrOfAffixes].length, newVector.bits);
+    concatBuffer[nrOfAffixes] = undefined;
+    return newVector;
+  } else {
+    const leftSuffixSize = getSuffixSize(self);
+
+    if (leftSuffixSize > 0) {
+      newVector = appendNodeToTree(newVector, self.suffix.slice(0, leftSuffixSize));
+      newVector.length += leftSuffixSize;
+    }
+
+    newVector = appendNodeToTree(newVector, that.prefix.slice(0, getPrefixSize(that)).reverse());
+    const newNode = concatSubTree(newVector.root, getDepth(newVector), that.root, getDepth(that), true);
+    const newDepth = getHeight(newNode);
+    setSizes(newNode, newDepth);
+    newVector.root = newNode;
+    newVector.offset &= ~(mask << getDepth(self) * branchBits);
+    newVector.length = newSize;
+    newVector.bits = setSuffix(rightSuffixSize, setDepth(newDepth, newVector.bits));
+    newVector.suffix = that.suffix;
+    return newVector;
+  }
+}
+
+const containsState = {
+  element: undefined,
+  result: false
+};
+
+function containsCb(value, state) {
+  return !(state.result = value === state.element);
+}
+/**
+ * Returns `true` if the Vector contains the specified element.
+ * Otherwise it returns `false`.
+ *
+ * @complexity O(n)
+ * @tsplus fluent fncts.Vector contains
+ */
+
+
+export function contains_(as, element) {
+  containsState.element = element;
+  containsState.result = false;
+  return foldLeftCb(containsCb, containsState, as).result;
+}
+/**
+ * Returns a new Vector without the first `n` elements.
+ *
+ * @complexity `O(log(n))`
+ * @tsplus fluent fncts.Vector drop
+ */
+
+export function drop_(as, n) {
+  return slice_1(as, n, as.length);
+}
+/**
+ * Returns a new Vector without the last `n` elements.
+ *
+ * @complexity `O(log(n))`
+ * @tsplus fluent fncts.Vector dropLast
+ */
+
+export function dropLast_(as, n) {
+  return slice_1(as, 0, as.length - n);
+}
+/**
+ * Returns a new Vector without repeated elements.
+ *
+ * @complexity `O(n)`
+ * @tsplus getter fncts.Vector dropRepeats
+ */
+
+export function dropRepeats(as) {
+  return dropRepeatsWith_1(as, tsplus_module_3.strictEquals);
+}
+/**
+ * Returns a new Vector without repeated elements by using the given
+ * function to determine when elements are equal.
+ *
+ * @complexity `O(n)`
+ * @tsplus fluent fncts.Vector dropRepeatsWith
+ */
+
+function dropRepeatsWith_1(as, predicate) {
+  return foldLeft_1(as, emptyPushable_1(), (acc, a) => acc.length !== 0 && predicate(unsafeLast_1(acc), a) ? acc : tsplus_module_2.push(acc, a));
+}
+
+function findNotIndexCb(value, state) {
+  if (state.predicate(value)) {
+    ++state.index;
+    return true;
+  } else {
+    return false;
+  }
+}
+/**
+ * Removes the first elements in the Vector for which the predicate returns
+ * `true`.
+ *
+ * @complexity `O(k + log(n))` where `k` is the number of elements
+ * satisfying the predicate.
+ * @tsplus fluent fncts.Vector dropWhile
+ */
+
+
+export function dropWhile_(as, predicate) {
+  const {
+    index
+  } = foldLeftCb(findNotIndexCb, {
+    predicate,
+    index: 0
+  }, as);
+  return slice_1(as, index, as.length);
+}
+
+function elemCb(value, state) {
+  return !(state.result = state.equals(value, state.element));
+}
+/**
+ * @tsplus getter fncts.Vector elem
+ */
+
+
+export function elem_(self) {
+  return E => {
+    const elemState = {
+      equals: E.equals_,
+      element: undefined,
+      result: false
+    };
+    return a => {
+      elemState.element = a;
+      return foldLeftCb(elemCb, elemState, self).result;
+    };
+  };
+}
+/**
+ * Returns true if the two Vectors are equivalent.
+ *
+ * @complexity O(n)
+ * @tsplus fluent fncts.Vector equals
+ */
+
+export function equals_(self, that) {
+  return tsplus_module_4.corresponds_(self, that, tsplus_module_3.strictEquals);
+}
+
+function everyCb(value, state) {
+  return state.result = state.predicate(value);
+}
+
+export function every_(as, predicate) {
+  return foldLeftCb(everyCb, {
+    predicate,
+    result: true
+  }, as).result;
+}
+/**
+ * Creates an empty Vector.
+ *
+ * @complexity O(1)
+ * @tsplus static fncts.VectorOps empty
+ */
+
+function empty_1() {
+  return new tsplus_module_1.Vector(0, 0, 0, emptyAffix, undefined, emptyAffix);
+}
+/**
+ * @tsplus static fncts.VectorOps emptyPushable
+ */
+
+
+function emptyPushable_1() {
+  return new tsplus_module_1.Vector(0, 0, 0, [], undefined, []);
+}
+
+function existsCb(value, state) {
+  return !(state.result = state.predicate(value));
+}
+/**
+ * Returns true if and only if there exists an element in the Vector for
+ * which the predicate returns true.
+ *
+ * @complexity O(n)
+ *
+ * @tsplus fluent fncts.Vector exists
+ */
+
+
+function exists_1(as, predicate) {
+  return foldLeftCb(existsCb, {
+    predicate,
+    result: false
+  }, as).result;
+}
+/**
+ * Returns the _first_ element for which the predicate returns `true`.
+ * If no such element is found the function returns `undefined`.
+ *
+ * @complexity O(n)
+ * @tsplus fluent fncts.Vector find
+ */
+
+
+export function find_(as, predicate) {
+  return tsplus_module_5.fromNullable(unsafeFind_1(as, predicate));
+}
+
+function findIndexCb(value, state) {
+  ++state.index;
+  return !(state.found = state.predicate(value));
+}
+/**
+ * Returns the index of the `first` element for which the predicate
+ * returns true. If no such element is found the function returns
+ * `-1`.
+ *
+ * @complexity O(n)
+ * @tsplus fluent fncts.Vector findIndex
+ */
+
+
+function findIndex_1(as, predicate) {
+  const {
+    found,
+    index
+  } = foldLeftCb(findIndexCb, {
+    predicate,
+    found: false,
+    index: -1
+  }, as);
+  return found ? index : -1;
+}
+/**
+ * Returns the _last_ element for which the predicate returns `true`.
+ * If no such element is found the function returns `undefined`.
+ *
+ * @complexity O(n)
+ * @tsplus fluent fncts.Vector findLast
+ */
+
+
+export function findLast_(as, predicate) {
+  return tsplus_module_5.fromNullable(unsafeFindLast_1(as, predicate));
+}
+/**
+ * Returns the index of the `last` element for which the predicate
+ * returns true. If no such element is found the function returns
+ * `-1`.
+ *
+ * @complexity O(n)
+ * @tsplus fluent fncts.Vector findLastIndex
+ */
+
+export function findLastIndex_(as, predicate) {
+  const {
+    found,
+    index
+  } = foldRightCb(findIndexCb, {
+    predicate,
+    found: false,
+    index: -0
+  }, as);
+  return found ? index : -1;
+}
+/**
+ * Flattens a Vector of Vectors into a Vector. Note that this function does
+ * not flatten recursively. It removes one level of nesting only.
+ *
+ * @complexity O(n * log(m)), where n is the length of the outer Vector and m the length of the inner Vectors.
+ *
+ * @tsplus getter fncts.Vector flatten
+ */
+
+function flatten_1(mma) {
+  return foldLeft_1(mma, empty_1(), (acc, a) => concat_1(acc, a));
+}
+
+export function from(sequence) {
+  const l = emptyPushable_1();
+
+  if (sequence.length > 0 && (sequence[0] !== undefined || 0 in sequence)) {
+    for (let i = 0; i < sequence.length; ++i) {
+      tsplus_module_2.push(l, sequence[i]);
+    }
+  } else if (Symbol.iterator in sequence) {
+    const iterator = sequence[Symbol.iterator]();
+    let cur;
+
+    while (!(cur = iterator.next()).done) {
+      tsplus_module_2.push(l, cur.value);
+    }
+  }
+
+  return l;
+}
+/**
+ * Folds a function over a Vector. Left-associative.
+ *
+ * @tsplus fluent fncts.Vector foldLeft
+ */
+
+function foldLeft_1(fa, initial, f) {
+  return foldLeftWithIndex_1(fa, initial, (_, b, a) => f(b, a));
+}
+/**
+ * @tsplus fluent fncts.Vector foldLeftWithIndex
+ */
+
+
+function foldLeftWithIndex_1(fa, b, f) {
+  const suffixSize = getSuffixSize(fa);
+  const prefixSize = getPrefixSize(fa);
+  let [acc, index] = foldLeftPrefix(f, b, fa.prefix, prefixSize);
+
+  if (fa.root !== undefined) {
+    [acc, index] = foldLeftNode(f, acc, fa.root, getDepth(fa), index);
+  }
+
+  return foldLeftSuffix(f, acc, fa.suffix, suffixSize, index)[0];
+}
+/**
+ * Similar to `foldl`. But, for each element it calls the predicate function
+ * _before_ the folding function and stops folding if it returns `false`.
+ *
+ *
+ * @example
+ * const isOdd = (_acc:, x) => x % 2 === 1;
+ *
+ * const xs = V.vector(1, 3, 5, 60, 777, 800);
+ * foldlWhile(isOdd, (n, m) => n + m, 0, xs) //=> 9
+ *
+ * const ys = V.vector(2, 4, 6);
+ * foldlWhile(isOdd, (n, m) => n + m, 111, ys) //=> 111
+ */
+
+
+function foldWhileCb(a, state, i) {
+  if (state.predicate(state.result) === false) {
+    return false;
+  }
+
+  state.result = state.f(i, state.result, a);
+  return true;
+}
+/**
+ * @tsplus fluent fncts.Vector foldLeftWhile
+ */
+
+
+export function foldLeftWhile_(fa, b, cont, f) {
+  if (!cont(b)) {
+    return b;
+  }
+
+  return foldLeftCb(foldWhileCb, {
+    predicate: cont,
+    f,
+    result: b
+  }, fa).result;
+}
+/**
+ * @tsplus fluent fncts.Vector foldRightWhile
+ */
+
+export function foldRightWhile_(fa, b, cont, f) {
+  return foldRightCb(foldWhileCb, {
+    predicate: cont,
+    result: b,
+    f: (i, b, a) => f(i, a, b)
+  }, fa).result;
+}
+/**
+ * @tsplus getter fncts.Vector foldMap
+ */
+
+export function foldMap_(self) {
+  return M => f => foldMapWithIndex_1(self)(M)((_, a) => f(a));
+}
+/**
+ * @tsplus getter fncts.Vector foldMapWithIndex
+ */
+
+function foldMapWithIndex_1(self) {
+  return M => f => foldLeftWithIndex_1(self, M.nat, (i, b, a) => M.combine_(b, f(i, a)));
+}
+/**
+ * Folds a function over a Vector. Right-associative.
+ *
+ * @complexity O(n)
+ * @tsplus fluent fncts.Vector foldRight
+ */
+
+
+export function foldRight_(fa, initial, f) {
+  return foldRightWithIndex_1(fa, initial, (_, a, b) => f(a, b));
+}
+/**
+ * Folds a function over a Vector. Right-associative.
+ *
+ * @complexity O(n)
+ * @tsplus fluent fncts.Vector foldRightWithIndex
+ */
+
+function foldRightWithIndex_1(fa, b, f) {
+  const suffixSize = getSuffixSize(fa);
+  const prefixSize = getPrefixSize(fa);
+  let [acc, j] = foldRightSuffix(f, b, fa.suffix, suffixSize, fa.length - 1);
+
+  if (fa.root !== undefined) {
+    [acc, j] = foldRightNode(f, acc, fa.root, getDepth(fa), j);
+  }
+
+  return foldRightPrefix(f, acc, fa.prefix, prefixSize, j)[0];
+}
+/**
+ * Invokes a given callback for each element in the Vector from left to
+ * right. Returns `undefined`.
+ *
+ * This function is very similar to map. It should be used instead of
+ * `map` when the mapping function has side-effects. Whereas `map`
+ * constructs a new Vector `forEach` merely returns `undefined`. This
+ * makes `forEach` faster when the new Vector is unneeded.
+ *
+ * @complexity O(n)
+ * @tsplus fluent fncts.Vector forEach
+ */
+
+
+function forEach_1(as, f) {
+  foldLeft_1(as, undefined, (_, element) => f(element));
+}
+/**
+ * @tsplus fluent fncts.Vector forEachWithIndex
+ */
+
+
+export function forEachWithIndex_(as, f) {
+  foldLeftWithIndex_1(as, undefined, (index, _, element) => f(index, element));
+}
+/**
+ * Gets the nth element of the Vector. If `n` is out of bounds
+ * `undefined` is returned.
+ *
+ * @complexity O(log(n))
+ * @tsplus fluent fncts.Vector get
+ */
+
+export function get_(self, index) {
+  return tsplus_module_5.fromNullable(unsafeGet_1(self, index));
+}
+/**
+ * Returns a Vector of Vectors where each subvector's elements are pairwise
+ * equal based on the given comparison function.
+ *
+ * Note that only adjacent elements are compared for equality. If all
+ * equal elements should be grouped together the Vector should be sorted
+ * before grouping.
+ *
+ * @tsplus fluent fncts.Vector groupWith
+ */
+
+export function groupWith_(as, f) {
+  const result = emptyPushable_1();
+  let buffer = emptyPushable_1();
+  forEach_1(as, a => {
+    if (buffer.length !== 0 && !f(unsafeLast_1(buffer), a)) {
+      tsplus_module_2.push(result, buffer);
+      buffer = emptyPushable_1();
+    }
+
+    tsplus_module_2.push(buffer, a);
+  });
+  return buffer.length === 0 ? result : tsplus_module_2.push(result, buffer);
+}
+/**
+ * Returns the first element of the Vector.
+ *
+ * @complexity O(1)
+ * @tsplus getter fncts.Vector head
+ */
+
+export function head(self) {
+  return tsplus_module_5.fromNullable(unsafeHead_1(self));
+}
+
+function indexOfCb(value, state) {
+  ++state.index;
+  return !(state.found = tsplus_module_3.strictEquals(value, state.element));
+}
+/**
+ * Returns the index of the _first_ element in the Vector that is equal
+ * to the given element. If no such element is found `-1` is returned.
+ *
+ * @complexity O(n)
+ * @tsplus fluent fncts.Vector indexOf
+ */
+
+
+export function indexOf_(as, element) {
+  const state = {
+    element,
+    found: false,
+    index: -1
+  };
+  foldLeftCb(indexOfCb, state, as);
+  return state.found ? state.index : -1;
+}
+/**
+ * Inserts the given element at the given index in the Vector.
+ *
+ * @complexity O(log(n))
+ * @tsplus fluent fncts.Vector insertAt
+ */
+
+export function insertAt_(as, index, element) {
+  return concat_1(append_1(slice_1(as, 0, index), element), slice_1(as, index, as.length));
+}
+/**
+ * Inserts the given Vector of elements at the given index in the Vector.
+ *
+ * @complexity `O(log(n))`
+ * @tsplus fluent fncts.Vector insertAllAt
+ */
+
+export function insertAllAt_(as, index, elements) {
+  return concat_1(concat_1(slice_1(as, 0, index), elements), slice_1(as, index, as.length));
+}
+/**
+ * Inserts a separator between each element in a Vector.
+ *
+ * @tsplus fluent fncts.Vector intersperse
+ */
+
+export function intersperse_(as, separator) {
+  return pop_1(foldLeft_1(as, emptyPushable_1(), (l2, a) => tsplus_module_2.push(tsplus_module_2.push(l2, a), separator)));
+}
+/**
+ * @tsplus fluent fncts.Vector isEmpty
+ */
+
+export function isEmpty(l) {
+  return l.length === 0;
+}
+/**
+ * @tsplus fluent fncts.Vector isNonEmpty
+ */
+
+export function isNonEmpty(l) {
+  return l.length > 0;
+}
+/**
+ * Concatenates the strings in the Vector separated by a specified separator.
+ *
+ * @tsplus fluent fncts.Vector join
+ */
+
+export function join_(as, separator) {
+  return foldLeft_1(as, "", (a, b) => a.length === 0 ? b : a + separator + b);
+}
+/**
+ * Returns the last element of the Vector.
+ *
+ * @complexity O(1)
+ * @tsplus getter fncts.Vector last
+ */
+
+export function last(l) {
+  return tsplus_module_5.fromNullable(unsafeLast_1(l));
+}
+/**
+ * Returns the index of the _last_ element in the Vector that is equal
+ * to the given element. If no such element is found `-1` is returned.
+ *
+ * @complexity O(n)
+ * @tsplus fluent fncts.Vector lastIndexOf
+ */
+
+export function lastIndexOf_(as, element) {
+  const state = {
+    element,
+    found: false,
+    index: 0
+  };
+  foldRightCb(indexOfCb, state, as);
+  return state.found ? as.length - state.index : -1;
+}
+/**
+ * Generates a new Vector by calling a function with the current index
+ * `n` times.
+ *
+ * @complexity O(n)
+ * @tsplus static fncts.VectorOps makeBy
+ */
+
+export function makeBy(n, f) {
+  const l = emptyPushable_1();
+
+  for (let i = 0; i < n; i++) {
+    tsplus_module_2.push(l, f(i));
+  }
+
+  return l;
+}
+/**
+ * @tsplus fluent fncts.Vector mapAccum
+ */
+
+export function mapAccum_(fa, s, f) {
+  return foldLeft_1(fa, [emptyPushable_1(), s], ([acc, s], a) => {
+    const r = f(s, a);
+    tsplus_module_2.push(acc, r[0]);
+    return [acc, r[1]];
+  });
+}
+/**
+ * Applies a function to each element in the given Vector and returns a
+ * new Vector of the values that the function return.
+ *
+ * @complexity O(n)
+ * @tsplus fluent fncts.Vector map
+ */
+
+function map_1(fa, f) {
+  return mapWithIndex_1(fa, (_, a) => f(a));
+}
+/**
+ * Applies a function to each element in the given Vector and returns a
+ * new Vector of the values that the function return.
+ *
+ * @complexity O(n)
+ * @tsplus fluent fncts.Vector mapWithIndex
+ */
+
+
+function mapWithIndex_1(fa, f) {
+  return new tsplus_module_1.Vector(fa.bits, fa.offset, fa.length, mapPrefix(f, fa.prefix, getPrefixSize(fa)), fa.root === undefined ? undefined : mapNode(f, fa.root, getDepth(fa), getPrefixSize(fa), 1)[0], mapAffix(f, fa.suffix, getSuffixSize(fa), fa.length));
+}
+/**
+ * @tsplus getter fncts.Vector mutableClone
+ */
+
+
+function mutableClone_1(as) {
+  return new tsplus_module_1.Vector(as.bits, as.offset, as.length, as.prefix, as.root, as.suffix);
+}
+/**
+ * Returns a Vector that has the entry specified by the index replaced with
+ * the value returned by applying the function to the value.
+ *
+ * If the index is out of bounds the given Vector is
+ * returned unchanged.
+ *
+ * @complexity `O(log(n))`
+ *
+ * @tsplus fluent fncts.Vector modifyAt
+ */
+
+
+export function modifyAt_(as, i, f) {
+  if (i < 0 || as.length <= i) {
+    return as;
+  }
+
+  return updateAt_1(as, i, f(unsafeGet_1(as, i)));
+}
+/**
+ * Returns `true` if and only if the predicate function returns
+ * `false` for every element in the given Vector.
+ *
+ * @complexity O(n)
+ *
+ * @tsplus fluent fncts.Vector none
+ */
+
+export function none_(as, predicate) {
+  return !exists_1(as, predicate);
+}
+/**
+ * Takes two arguments and returns a Vector that contains them.
+ *
+ * @complexity O(1)
+ * @tsplus static fncts.VectorOps pair
+ */
+
+export function pair(first, second) {
+  return new tsplus_module_1.Vector(2, 0, 2, emptyAffix, undefined, [first, second]);
+}
+/**
+ * Returns a new Vector with the last element removed. If the Vector is
+ * empty the empty Vector is returned.
+ *
+ * @complexity `O(1)`
+ * @tsplus getter fncts.Vector pop
+ */
+
+function pop_1(as) {
+  return slice_1(as, 0, -1);
+}
+/**
+ * Prepends an element to the front of a Vector and returns the new Vector.
+ *
+ * @complexity O(1)
+ *
+ * @tsplus fluent fncts.Vector prepend
+ */
+
+
+export function prepend_(as, a) {
+  const prefixSize = getPrefixSize(as);
+
+  if (prefixSize < 32) {
+    return new tsplus_module_1.Vector(incrementPrefix(as.bits), as.offset, as.length + 1, affixPush(a, as.prefix, prefixSize), as.root, as.suffix);
+  } else {
+    const newVector = mutableClone_1(as);
+    prependNodeToTree(newVector, reverseArray(as.prefix));
+    const newPrefix = [a];
+    newVector.prefix = newPrefix;
+    newVector.length++;
+    newVector.bits = setPrefix(1, newVector.bits);
+    return newVector;
+  }
+}
+/**
+ * Returns a Vector of numbers between an inclusive lower bound and an exclusive upper bound.
+ *
+ * @complexity O(n)
+ * @tsplus static fncts.VectorOps range
+ */
+
+export function range(start, end) {
+  const vec = emptyPushable_1();
+
+  for (let i = start; i < end; ++i) {
+    tsplus_module_2.push(vec, i);
+  }
+
+  return vec;
+}
+/**
+ * Takes an index, a number of elements to remove and a Vector. Returns a
+ * new Vector with the given amount of elements removed from the specified
+ * index.
+ *
+ * @complexity `O(log(n))`
+ *
+ * @tsplus fluent fncts.Vector remove
+ */
+
+export function remove_(as, from, amount) {
+  return concat_1(slice_1(as, 0, from), slice_1(as, from + amount, as.length));
+}
+/**
+ * Returns a Vector of a given length that contains the specified value
+ * in all positions.
+ *
+ * @complexity O(n)
+ * @tsplus static fncts.VectorOps replicate
+ */
+
+export function replicate(n, a) {
+  let t = n;
+  const l = emptyPushable_1();
+
+  while (--t >= 0) {
+    tsplus_module_2.push(l, a);
+  }
+
+  return l;
+}
+/**
+ * Folds a function over a Vector from left to right while collecting
+ * all the intermediate steps in a resulting Vector.
+ *
+ * @tsplus fluent fncts.Vector scanLeft
+ */
+
+export function scanLeft_(as, initial, f) {
+  return foldLeft_1(as, tsplus_module_2.push(emptyPushable_1(), initial), (l2, a) => tsplus_module_2.push(l2, f(unsafeLast_1(l2), a)));
+}
+/**
+ * Takes a single arguments and returns a singleton Vector that contains it.
+ *
+ * @complexity O(1)
+ * @tsplus static fncts.VectorOps single
+ */
+
+export function single(a) {
+  return vector_1(a);
+}
+/**
+ * Returns a slice of a Vector. Elements are removed from the beginning and
+ * end. Both the indices can be negative in which case they will count
+ * from the right end of the Vector.
+ *
+ * @complexity `O(log(n))`
+ * @tsplus fluent fncts.Vector slice
+ */
+
+function slice_1(as, from, to) {
+  let {
+    bits,
+    length
+  } = as;
+  let _to = to;
+  let _from = from;
+  _to = Math.min(length, to); // Handle negative indices
+
+  if (_from < 0) {
+    _from = length + from;
+  }
+
+  if (_to < 0) {
+    _to = length + to;
+  } // Should we just return the empty Vector?
+
+
+  if (_to <= _from || _to <= 0 || length <= _from) {
+    return empty_1();
+  } // Return Vector unchanged if we are slicing nothing off
+
+
+  if (_from <= 0 && length <= _to) {
+    return as;
+  }
+
+  const newLength = _to - _from;
+  let prefixSize = getPrefixSize(as);
+  const suffixSize = getSuffixSize(as); // Both indices lie in the prefix
+
+  if (_to <= prefixSize) {
+    return new tsplus_module_1.Vector(setPrefix(newLength, 0), 0, newLength, as.prefix.slice(prefixSize - _to, prefixSize - _from), undefined, emptyAffix);
+  }
+
+  const suffixStart = length - suffixSize; // Both indices lie in the suffix
+
+  if (suffixStart <= _from) {
+    return new tsplus_module_1.Vector(setSuffix(newLength, 0), 0, newLength, emptyAffix, undefined, as.suffix.slice(_from - suffixStart, _to - suffixStart));
+  }
+
+  const newVector = mutableClone_1(as);
+  newVector.length = newLength; // Both indices lie in the tree
+
+  if (prefixSize <= _from && _to <= suffixStart) {
+    sliceTreeVector(_from - prefixSize + as.offset, _to - prefixSize + as.offset - 1, as.root, getDepth(as), as.offset, newVector);
+    return newVector;
+  }
+
+  if (0 < _from) {
+    // we need _to slice something off of the left
+    if (_from < prefixSize) {
+      // shorten the prefix even though it's not strictly needed,
+      // so that referenced items can be GC'd
+      newVector.prefix = as.prefix.slice(0, prefixSize - _from);
+      bits = setPrefix(prefixSize - _from, bits);
+    } else {
+      // if we're here `_to` can't lie in the tree, so we can set the
+      // root
+      zeroOffset();
+      newVector.root = sliceLeft(newVector.root, getDepth(as), _from - prefixSize, as.offset, true);
+      newVector.offset = newOffset;
+
+      if (newVector.root === undefined) {
+        bits = setDepth(0, bits);
+      }
+
+      bits = setPrefix(newAffix.length, bits);
+      prefixSize = newAffix.length;
+      newVector.prefix = newAffix;
+    }
+  }
+
+  if (_to < length) {
+    // we need _to slice something off of the right
+    if (length - _to < suffixSize) {
+      bits = setSuffix(suffixSize - (length - _to), bits); // slice the suffix even though it's not strictly needed,
+      // _to allow the removed items _to be GC'd
+
+      newVector.suffix = as.suffix.slice(0, suffixSize - (length - _to));
+    } else {
+      newVector.root = sliceRight(newVector.root, getDepth(as), _to - prefixSize - 1, newVector.offset);
+
+      if (newVector.root === undefined) {
+        bits = setDepth(0, bits);
+        newVector.offset = 0;
+      }
+
+      bits = setSuffix(newAffix.length, bits);
+      newVector.suffix = newAffix;
+    }
+  }
+
+  newVector.bits = bits;
+  return newVector;
+}
+/**
+ * @tsplus getter fncts.Vector sort
+ */
+
+
+export function sort_(self) {
+  return O => sortWith_1(self, O.compare_);
+}
+/**
+ * Sort the given Vector by comparing values using the given function.
+ * The function receieves two values and should return `-1` if the
+ * first value is stricty larger than the second, `0` is they are
+ * equal and `1` if the first values is strictly smaller than the
+ * second.
+ *
+ * @complexity O(n * log(n))
+ *
+ * @tsplus fluent fncts.Vector sortWith
+ */
+
+function sortWith_1(as, compare) {
+  const arr = [];
+  let i = 0;
+  forEach_1(as, elm => arr.push({
+    idx: i++,
+    elm
+  }));
+  arr.sort(({
+    elm: a,
+    idx: i
+  }, {
+    elm: b,
+    idx: j
+  }) => {
+    const c = compare(a, b);
+    return c !== 0 ? c : i < j ? -1 : 1;
+  });
+  const newL = emptyPushable_1();
+
+  for (let i = 0; i < arr.length; ++i) {
+    tsplus_module_2.push(newL, arr[i].elm);
+  }
+
+  return newL;
+}
+/**
+ * Splits a Vector at the given index and return the two sides in a pair.
+ * The left side will contain all elements before but not including the
+ * element at the given index. The right side contains the element at the
+ * index and all elements after it.
+ *
+ * @complexity `O(log(n))`
+ *
+ * @tsplus fluent fncts.Vector splitAt
+ */
+
+
+function splitAt_1(as, index) {
+  return [slice_1(as, 0, index), slice_1(as, index, as.length)];
+}
+/**
+ * Splits a Vector at the first element in the Vector for which the given
+ * predicate returns `true`.
+ *
+ * @complexity `O(n)`
+ *
+ * @tsplus fluent fncts.Vector splitWhen
+ */
+
+
+export function splitWhen_(as, predicate) {
+  const idx = findIndex_1(as, predicate);
+  return idx === -1 ? [as, empty_1()] : splitAt_1(as, idx);
+}
+/**
+ * Returns a new Vector with the first element removed. If the Vector is
+ * empty the empty Vector is returned.
+ *
+ * @complexity `O(1)`
+ *
+ * @tsplus getter fncts.Vector tail
+ */
+
+export function tail(as) {
+  return slice_1(as, 1, as.length);
+}
+/**
+ * Takes the first `n` elements from a Vector and returns them in a new Vector.
+ *
+ * @complexity `O(log(n))`
+ * @tsplus fluent fncts.Vector take
+ */
+
+export function take_(as, n) {
+  return slice_1(as, 0, n);
+}
+/**
+ * Takes the first elements in the Vector for which the predicate returns
+ * `true`.
+ *
+ * @complexity `O(k + log(n))` where `k` is the number of elements satisfying
+ * the predicate.
+ *
+ * @tsplus fluent fncts.Vector takeWhile
+ */
+
+export function takeWhile_(as, predicate) {
+  const {
+    index
+  } = foldLeftCb(findNotIndexCb, {
+    predicate,
+    index: 0
+  }, as);
+  return slice_1(as, 0, index);
+}
+/**
+ * Takes the last `n` elements from a Vector and returns them in a new
+ * Vector.
+ *
+ * @complexity `O(log(n))`
+ * @tsplus fluent fncts.Vector takeLast
+ */
+
+export function takeLast_(as, n) {
+  return slice_1(as, as.length - n, as.length);
+}
+/**
+ * Takes the last elements in the Vector for which the predicate returns
+ * `true`.
+ *
+ * @complexity `O(k + log(n))` where `k` is the number of elements
+ * satisfying the predicate.
+ *
+ * @tsplus fluent fncts.Vector takeLastWhile
+ */
+
+export function takeLastWhile_(as, predicate) {
+  const {
+    index
+  } = foldRightCb(findNotIndexCb, {
+    predicate,
+    index: 0
+  }, as);
+  return slice_1(as, as.length - index, as.length);
+}
+/**
+ * Converts a Vector into an array.
+ *
+ * @complexity `O(n)`
+ * @tsplus getter fncts.Vector toArray
+ */
+
+export function toArray(self) {
+  return foldLeft_1(self, [], arrayPush);
+}
+/**
+ * Converts a Vector into a List.
+ *
+ * @complexity `O(n)`
+ * @tsplus getter fncts.Vector toList
+ */
+
+export function toList(self) {
+  const buffer = new tsplus_module_6.ListBuffer();
+  forEach_1(self, a => {
+    buffer.append(a);
+  });
+  return buffer.toList;
+}
+/**
+ * Returns a new Vector without repeated elements by using the given
+ * Eq instance to determine when elements are equal
+ *
+ * @complexity `O(n)`
+ * @tsplus getter fncts.Vector uniq
+ */
+
+export function uniq(as) {
+  return E => dropRepeatsWith_1(as, E.equals_);
+}
+/**
+ * @tsplus static fncts.VectorOps unfold
+ */
+
+export function unfold(b, f) {
+  const out = emptyPushable_1();
+  let state = b; // eslint-disable-next-line no-constant-condition
+
+  while (true) {
+    const mt = f(state);
+
+    if (tsplus_module_7.isJust(mt)) {
+      const [a, b] = mt.value;
+      tsplus_module_2.push(out, a);
+      state = b;
+    } else {
+      break;
+    }
+  }
+
+  return out;
+}
+
+function findCb(value, state) {
+  if (state.predicate(value)) {
+    state.result = value;
+    return false;
+  } else {
+    return true;
+  }
+}
+/**
+ * Returns the _first_ element for which the predicate returns `true`.
+ * If no such element is found the function returns `undefined`.
+ *
+ * @complexity O(n)
+ * @tsplus fluent fncts.Vector unsafeFind
+ */
+
+
+function unsafeFind_1(as, predicate) {
+  return foldLeftCb(findCb, {
+    predicate,
+    result: undefined
+  }, as).result;
+}
+/**
+ * Returns the _last_ element for which the predicate returns `true`.
+ * If no such element is found the function returns `undefined`.
+ *
+ * @complexity O(n)
+ * @tsplus fluent fncts.Vector unsafeFindLast
+ */
+
+
+function unsafeFindLast_1(as, predicate) {
+  return foldRightCb(findCb, {
+    predicate,
+    result: undefined
+  }, as).result;
+}
+/**
+ * Gets the nth element of the Vector. If `n` is out of bounds
+ * `undefined` is returned.
+ *
+ * @complexity O(log(n))
+ * @tsplus fluent fncts.Vector unsafeGet
+ */
+
+
+function unsafeGet_1(l, index) {
+  if (index < 0 || l.length <= index) {
+    return undefined;
+  }
+
+  const prefixSize = getPrefixSize(l);
+  const suffixSize = getSuffixSize(l);
+
+  if (index < prefixSize) {
+    return l.prefix[prefixSize - index - 1];
+  } else if (index >= l.length - suffixSize) {
+    return l.suffix[index - (l.length - suffixSize)];
+  }
+
+  const {
+    offset
+  } = l;
+  const depth = getDepth(l);
+  return l.root.sizes === undefined ? nodeNthDense(l.root, depth, offset === 0 ? index - prefixSize : handleOffset(depth, offset, index - prefixSize)) : nodeNth(l.root, depth, offset, index - prefixSize);
+}
+/**
+ * Returns the first element of the Vector. If the Vector is empty the
+ * function returns undefined.
+ *
+ * @complexity O(1)
+ * @tsplus getter fncts.Vector unsafeHead
+ */
+
+
+function unsafeHead_1(l) {
+  const prefixSize = getPrefixSize(l);
+  return prefixSize !== 0 ? l.prefix[prefixSize - 1] : l.length !== 0 ? l.suffix[0] : undefined;
+}
+/**
+ * Returns the last element of the Vector. If the Vector is empty the
+ * function returns `undefined`.
+ *
+ * @complexity O(1)
+ * @tsplus getter fncts.Vector unsafeLast
+ */
+
+
+function unsafeLast_1(l) {
+  const suffixSize = getSuffixSize(l);
+  return suffixSize !== 0 ? l.suffix[suffixSize - 1] : l.length !== 0 ? l.prefix[0] : undefined;
+}
+/**
+ * Returns a Vector that has the entry specified by the index replaced with the given value.
+ *
+ * If the index is out of bounds the given Vector is returned unchanged.
+ *
+ * @complexity O(log(n))
+ * @tsplus fluent fncts.Vector updateAt
+ */
+
+
+function updateAt_1(as, i, a) {
+  if (i < 0 || as.length <= i) {
+    return as;
+  }
+
+  const prefixSize = getPrefixSize(as);
+  const suffixSize = getSuffixSize(as);
+  const newVector = mutableClone_1(as);
+
+  if (i < prefixSize) {
+    const newPrefix = copyArray(newVector.prefix);
+    newPrefix[newPrefix.length - i - 1] = a;
+    newVector.prefix = newPrefix;
+  } else if (i >= as.length - suffixSize) {
+    const newSuffix = copyArray(newVector.suffix);
+    newSuffix[i - (as.length - suffixSize)] = a;
+    newVector.suffix = newSuffix;
+  } else {
+    newVector.root = updateNode(as.root, getDepth(as), i - prefixSize, as.offset, a);
+  }
+
+  return newVector;
+}
+/**
+ * @tsplus static fncts.VectorOps __call
+ */
+
+
+function vector_1(...elements) {
+  const v = emptyPushable_1();
+
+  for (const element of elements) {
+    tsplus_module_2.push(v, element);
+  }
+
+  return v;
+}
+//# sourceMappingURL=api.mjs.map