@fncts/base 0.0.1

package/_cjs/collection/immutable/Vector/api.cjs

@@ -0,0 +1,1525 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.append_ = void 0;
+exports.chunksOf_ = chunksOf_;
+exports.concat_ = void 0;
+exports.contains_ = contains_;
+exports.dropLast_ = dropLast_;
+exports.dropRepeats = dropRepeats;
+exports.dropRepeatsWith_ = void 0;
+exports.dropWhile_ = dropWhile_;
+exports.drop_ = drop_;
+exports.elem_ = elem_;
+exports.emptyPushable = exports.empty = void 0;
+exports.equals_ = equals_;
+exports.every_ = every_;
+exports.findIndex_ = exports.exists_ = void 0;
+exports.findLastIndex_ = findLastIndex_;
+exports.findLast_ = findLast_;
+exports.find_ = find_;
+exports.flatMap_ = flatMap_;
+exports.flatten = void 0;
+exports.foldLeftWhile_ = foldLeftWhile_;
+exports.foldMapWithIndex_ = exports.foldLeft_ = exports.foldLeftWithIndex_ = void 0;
+exports.foldMap_ = foldMap_;
+exports.foldRightWhile_ = foldRightWhile_;
+exports.foldRightWithIndex_ = void 0;
+exports.foldRight_ = foldRight_;
+exports.forEachWithIndex_ = forEachWithIndex_;
+exports.forEach_ = void 0;
+exports.from = from;
+exports.get_ = get_;
+exports.groupWith_ = groupWith_;
+exports.head = head;
+exports.indexOf_ = indexOf_;
+exports.insertAllAt_ = insertAllAt_;
+exports.insertAt_ = insertAt_;
+exports.intersperse_ = intersperse_;
+exports.isEmpty = isEmpty;
+exports.isNonEmpty = isNonEmpty;
+exports.join_ = join_;
+exports.last = last;
+exports.lastIndexOf_ = lastIndexOf_;
+exports.makeBy = makeBy;
+exports.mapAccum_ = mapAccum_;
+exports.map_ = exports.mapWithIndex_ = void 0;
+exports.modifyAt_ = modifyAt_;
+exports.mutableClone = void 0;
+exports.none_ = none_;
+exports.pair = pair;
+exports.pop = void 0;
+exports.prepend_ = prepend_;
+exports.range = range;
+exports.remove_ = remove_;
+exports.replicate = replicate;
+exports.scanLeft_ = scanLeft_;
+exports.single = single;
+exports.sortWith_ = exports.slice_ = void 0;
+exports.sort_ = sort_;
+exports.splitAt_ = void 0;
+exports.splitWhen_ = splitWhen_;
+exports.tail = tail;
+exports.takeLastWhile_ = takeLastWhile_;
+exports.takeLast_ = takeLast_;
+exports.takeWhile_ = takeWhile_;
+exports.take_ = take_;
+exports.toArray = toArray;
+exports.toList = toList;
+exports.unfold = unfold;
+exports.uniq = uniq;
+exports.vector = exports.updateAt_ = exports.unsafeLast = exports.unsafeHead = exports.unsafeGet_ = exports.unsafeFind_ = exports.unsafeFindLast_ = void 0;
+
+var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/Vector"));
+
+var tsplus_module_2 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/Vector/internal"));
+
+var tsplus_module_3 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/typeclass/Equatable/api"));
+
+var tsplus_module_4 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/Vector/definition"));
+
+var tsplus_module_5 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/constructors"));
+
+var tsplus_module_6 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/mutable/ListBuffer"));
+
+var tsplus_module_7 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/definition"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const append_ = append_1;
+exports.append_ = append_;
+const concat_ = concat_1;
+exports.concat_ = concat_;
+const dropRepeatsWith_ = dropRepeatsWith_1;
+exports.dropRepeatsWith_ = dropRepeatsWith_;
+const empty = empty_1;
+exports.empty = empty;
+const emptyPushable = emptyPushable_1;
+exports.emptyPushable = emptyPushable;
+const exists_ = exists_1;
+exports.exists_ = exists_;
+const findIndex_ = findIndex_1;
+exports.findIndex_ = findIndex_;
+const flatten = flatten_1;
+exports.flatten = flatten;
+const foldLeft_ = foldLeft_1;
+exports.foldLeft_ = foldLeft_;
+const foldLeftWithIndex_ = foldLeftWithIndex_1;
+exports.foldLeftWithIndex_ = foldLeftWithIndex_;
+const foldMapWithIndex_ = foldMapWithIndex_1;
+exports.foldMapWithIndex_ = foldMapWithIndex_;
+const foldRightWithIndex_ = foldRightWithIndex_1;
+exports.foldRightWithIndex_ = foldRightWithIndex_;
+const forEach_ = forEach_1;
+exports.forEach_ = forEach_;
+const map_ = map_1;
+exports.map_ = map_;
+const mapWithIndex_ = mapWithIndex_1;
+exports.mapWithIndex_ = mapWithIndex_;
+const mutableClone = mutableClone_1;
+exports.mutableClone = mutableClone;
+const pop = pop_1;
+exports.pop = pop;
+const slice_ = slice_1;
+exports.slice_ = slice_;
+const sortWith_ = sortWith_1;
+exports.sortWith_ = sortWith_;
+const splitAt_ = splitAt_1;
+exports.splitAt_ = splitAt_;
+const unsafeFind_ = unsafeFind_1;
+exports.unsafeFind_ = unsafeFind_;
+const unsafeFindLast_ = unsafeFindLast_1;
+exports.unsafeFindLast_ = unsafeFindLast_;
+const unsafeGet_ = unsafeGet_1;
+exports.unsafeGet_ = unsafeGet_;
+const unsafeHead = unsafeHead_1;
+exports.unsafeHead = unsafeHead;
+const unsafeLast = unsafeLast_1;
+exports.unsafeLast = unsafeLast;
+const updateAt_ = updateAt_1;
+exports.updateAt_ = updateAt_;
+const vector = vector_1;
+exports.vector = vector;
+
+/**
+ * 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 = (0, tsplus_module_2.getSuffixSize)(as);
+
+  if (suffixSize < 32) {
+    return new tsplus_module_1.Vector((0, tsplus_module_2.incrementSuffix)(as.bits), as.offset, as.length + 1, as.prefix, as.root, (0, tsplus_module_2.affixPush)(a, as.suffix, suffixSize));
+  }
+
+  const newSuffix = [a];
+  const newVector = mutableClone_1(as);
+  (0, tsplus_module_2.appendNodeToTree)(newVector, as.suffix);
+  newVector.suffix = newSuffix;
+  newVector.length++;
+  newVector.bits = (0, tsplus_module_2.setSuffix)(1, newVector.bits);
+  return newVector;
+}
+/**
+ * Maps a function over a Vector and concatenates all the resulting
+ * Vectors together.
+ *
+ * @tsplus fluent fncts.Vector flatMap
+ */
+
+
+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
+ */
+
+
+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 = (0, tsplus_module_2.getSuffixSize)(that);
+  let newVector = mutableClone_1(self);
+
+  if (that.root === undefined) {
+    // right is nothing but a prefix and a suffix
+    const nrOfAffixes = (0, tsplus_module_2.concatAffixes)(self, that);
+
+    for (let i = 0; i < nrOfAffixes; ++i) {
+      newVector = (0, tsplus_module_2.appendNodeToTree)(newVector, tsplus_module_2.concatBuffer[i]);
+      newVector.length += tsplus_module_2.concatBuffer[i].length; // wipe pointer, otherwise it might end up keeping the array alive
+
+      tsplus_module_2.concatBuffer[i] = undefined;
+    }
+
+    newVector.length = newSize;
+    newVector.suffix = tsplus_module_2.concatBuffer[nrOfAffixes];
+    newVector.bits = (0, tsplus_module_2.setSuffix)(tsplus_module_2.concatBuffer[nrOfAffixes].length, newVector.bits);
+    tsplus_module_2.concatBuffer[nrOfAffixes] = undefined;
+    return newVector;
+  } else {
+    const leftSuffixSize = (0, tsplus_module_2.getSuffixSize)(self);
+
+    if (leftSuffixSize > 0) {
+      newVector = (0, tsplus_module_2.appendNodeToTree)(newVector, self.suffix.slice(0, leftSuffixSize));
+      newVector.length += leftSuffixSize;
+    }
+
+    newVector = (0, tsplus_module_2.appendNodeToTree)(newVector, that.prefix.slice(0, (0, tsplus_module_2.getPrefixSize)(that)).reverse());
+    const newNode = (0, tsplus_module_2.concatSubTree)(newVector.root, (0, tsplus_module_2.getDepth)(newVector), that.root, (0, tsplus_module_2.getDepth)(that), true);
+    const newDepth = (0, tsplus_module_2.getHeight)(newNode);
+    (0, tsplus_module_2.setSizes)(newNode, newDepth);
+    newVector.root = newNode;
+    newVector.offset &= ~(tsplus_module_2.mask << (0, tsplus_module_2.getDepth)(self) * tsplus_module_2.branchBits);
+    newVector.length = newSize;
+    newVector.bits = (0, tsplus_module_2.setSuffix)(rightSuffixSize, (0, tsplus_module_2.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
+ */
+
+
+function contains_(as, element) {
+  containsState.element = element;
+  containsState.result = false;
+  return (0, tsplus_module_2.foldLeftCb)(containsCb, containsState, as).result;
+}
+/**
+ * Returns a new Vector without the first `n` elements.
+ *
+ * @complexity `O(log(n))`
+ * @tsplus fluent fncts.Vector drop
+ */
+
+
+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
+ */
+
+
+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
+ */
+
+
+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
+ */
+
+
+function dropWhile_(as, predicate) {
+  const {
+    index
+  } = (0, tsplus_module_2.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
+ */
+
+
+function elem_(self) {
+  return E => {
+    const elemState = {
+      equals: E.equals_,
+      element: undefined,
+      result: false
+    };
+    return a => {
+      elemState.element = a;
+      return (0, tsplus_module_2.foldLeftCb)(elemCb, elemState, self).result;
+    };
+  };
+}
+/**
+ * Returns true if the two Vectors are equivalent.
+ *
+ * @complexity O(n)
+ * @tsplus fluent fncts.Vector equals
+ */
+
+
+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);
+}
+
+function every_(as, predicate) {
+  return (0, tsplus_module_2.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, tsplus_module_2.emptyAffix, undefined, tsplus_module_2.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 (0, tsplus_module_2.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
+ */
+
+
+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
+  } = (0, tsplus_module_2.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
+ */
+
+
+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
+ */
+
+
+function findLastIndex_(as, predicate) {
+  const {
+    found,
+    index
+  } = (0, tsplus_module_2.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));
+}
+
+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 = (0, tsplus_module_2.getSuffixSize)(fa);
+  const prefixSize = (0, tsplus_module_2.getPrefixSize)(fa);
+  let [acc, index] = (0, tsplus_module_2.foldLeftPrefix)(f, b, fa.prefix, prefixSize);
+
+  if (fa.root !== undefined) {
+    [acc, index] = (0, tsplus_module_2.foldLeftNode)(f, acc, fa.root, (0, tsplus_module_2.getDepth)(fa), index);
+  }
+
+  return (0, tsplus_module_2.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
+ */
+
+
+function foldLeftWhile_(fa, b, cont, f) {
+  if (!cont(b)) {
+    return b;
+  }
+
+  return (0, tsplus_module_2.foldLeftCb)(foldWhileCb, {
+    predicate: cont,
+    f,
+    result: b
+  }, fa).result;
+}
+/**
+ * @tsplus fluent fncts.Vector foldRightWhile
+ */
+
+
+function foldRightWhile_(fa, b, cont, f) {
+  return (0, tsplus_module_2.foldRightCb)(foldWhileCb, {
+    predicate: cont,
+    result: b,
+    f: (i, b, a) => f(i, a, b)
+  }, fa).result;
+}
+/**
+ * @tsplus getter fncts.Vector foldMap
+ */
+
+
+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
+ */
+
+
+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 = (0, tsplus_module_2.getSuffixSize)(fa);
+  const prefixSize = (0, tsplus_module_2.getPrefixSize)(fa);
+  let [acc, j] = (0, tsplus_module_2.foldRightSuffix)(f, b, fa.suffix, suffixSize, fa.length - 1);
+
+  if (fa.root !== undefined) {
+    [acc, j] = (0, tsplus_module_2.foldRightNode)(f, acc, fa.root, (0, tsplus_module_2.getDepth)(fa), j);
+  }
+
+  return (0, tsplus_module_2.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
+ */
+
+
+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
+ */
+
+
+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
+ */
+
+
+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
+ */
+
+
+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
+ */
+
+
+function indexOf_(as, element) {
+  const state = {
+    element,
+    found: false,
+    index: -1
+  };
+  (0, tsplus_module_2.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
+ */
+
+
+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
+ */
+
+
+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
+ */
+
+
+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
+ */
+
+
+function isEmpty(l) {
+  return l.length === 0;
+}
+/**
+ * @tsplus fluent fncts.Vector isNonEmpty
+ */
+
+
+function isNonEmpty(l) {
+  return l.length > 0;
+}
+/**
+ * Concatenates the strings in the Vector separated by a specified separator.
+ *
+ * @tsplus fluent fncts.Vector join
+ */
+
+
+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
+ */
+
+
+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
+ */
+
+
+function lastIndexOf_(as, element) {
+  const state = {
+    element,
+    found: false,
+    index: 0
+  };
+  (0, tsplus_module_2.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
+ */
+
+
+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
+ */
+
+
+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, (0, tsplus_module_2.mapPrefix)(f, fa.prefix, (0, tsplus_module_2.getPrefixSize)(fa)), fa.root === undefined ? undefined : (0, tsplus_module_2.mapNode)(f, fa.root, (0, tsplus_module_2.getDepth)(fa), (0, tsplus_module_2.getPrefixSize)(fa), 1)[0], (0, tsplus_module_2.mapAffix)(f, fa.suffix, (0, tsplus_module_2.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
+ */
+
+
+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
+ */
+
+
+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
+ */
+
+
+function pair(first, second) {
+  return new tsplus_module_1.Vector(2, 0, 2, tsplus_module_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
+ */
+
+
+function prepend_(as, a) {
+  const prefixSize = (0, tsplus_module_2.getPrefixSize)(as);
+
+  if (prefixSize < 32) {
+    return new tsplus_module_1.Vector((0, tsplus_module_2.incrementPrefix)(as.bits), as.offset, as.length + 1, (0, tsplus_module_2.affixPush)(a, as.prefix, prefixSize), as.root, as.suffix);
+  } else {
+    const newVector = mutableClone_1(as);
+    (0, tsplus_module_2.prependNodeToTree)(newVector, (0, tsplus_module_2.reverseArray)(as.prefix));
+    const newPrefix = [a];
+    newVector.prefix = newPrefix;
+    newVector.length++;
+    newVector.bits = (0, tsplus_module_2.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
+ */
+
+
+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
+ */
+
+
+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
+ */
+
+
+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
+ */
+
+
+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
+ */
+
+
+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 = (0, tsplus_module_2.getPrefixSize)(as);
+  const suffixSize = (0, tsplus_module_2.getSuffixSize)(as); // Both indices lie in the prefix
+
+  if (_to <= prefixSize) {
+    return new tsplus_module_1.Vector((0, tsplus_module_2.setPrefix)(newLength, 0), 0, newLength, as.prefix.slice(prefixSize - _to, prefixSize - _from), undefined, tsplus_module_2.emptyAffix);
+  }
+
+  const suffixStart = length - suffixSize; // Both indices lie in the suffix
+
+  if (suffixStart <= _from) {
+    return new tsplus_module_1.Vector((0, tsplus_module_2.setSuffix)(newLength, 0), 0, newLength, tsplus_module_2.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) {
+    (0, tsplus_module_2.sliceTreeVector)(_from - prefixSize + as.offset, _to - prefixSize + as.offset - 1, as.root, (0, tsplus_module_2.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 = (0, tsplus_module_2.setPrefix)(prefixSize - _from, bits);
+    } else {
+      // if we're here `_to` can't lie in the tree, so we can set the
+      // root
+      (0, tsplus_module_2.zeroOffset)();
+      newVector.root = (0, tsplus_module_2.sliceLeft)(newVector.root, (0, tsplus_module_2.getDepth)(as), _from - prefixSize, as.offset, true);
+      newVector.offset = tsplus_module_2.newOffset;
+
+      if (newVector.root === undefined) {
+        bits = (0, tsplus_module_2.setDepth)(0, bits);
+      }
+
+      bits = (0, tsplus_module_2.setPrefix)(tsplus_module_2.newAffix.length, bits);
+      prefixSize = tsplus_module_2.newAffix.length;
+      newVector.prefix = tsplus_module_2.newAffix;
+    }
+  }
+
+  if (_to < length) {
+    // we need _to slice something off of the right
+    if (length - _to < suffixSize) {
+      bits = (0, tsplus_module_2.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 = (0, tsplus_module_2.sliceRight)(newVector.root, (0, tsplus_module_2.getDepth)(as), _to - prefixSize - 1, newVector.offset);
+
+      if (newVector.root === undefined) {
+        bits = (0, tsplus_module_2.setDepth)(0, bits);
+        newVector.offset = 0;
+      }
+
+      bits = (0, tsplus_module_2.setSuffix)(tsplus_module_2.newAffix.length, bits);
+      newVector.suffix = tsplus_module_2.newAffix;
+    }
+  }
+
+  newVector.bits = bits;
+  return newVector;
+}
+/**
+ * @tsplus getter fncts.Vector sort
+ */
+
+
+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
+ */
+
+
+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
+ */
+
+
+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
+ */
+
+
+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
+ */
+
+
+function takeWhile_(as, predicate) {
+  const {
+    index
+  } = (0, tsplus_module_2.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
+ */
+
+
+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
+ */
+
+
+function takeLastWhile_(as, predicate) {
+  const {
+    index
+  } = (0, tsplus_module_2.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
+ */
+
+
+function toArray(self) {
+  return foldLeft_1(self, [], tsplus_module_2.arrayPush);
+}
+/**
+ * Converts a Vector into a List.
+ *
+ * @complexity `O(n)`
+ * @tsplus getter fncts.Vector toList
+ */
+
+
+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
+ */
+
+
+function uniq(as) {
+  return E => dropRepeatsWith_1(as, E.equals_);
+}
+/**
+ * @tsplus static fncts.VectorOps unfold
+ */
+
+
+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 (0, tsplus_module_2.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 (0, tsplus_module_2.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 = (0, tsplus_module_2.getPrefixSize)(l);
+  const suffixSize = (0, tsplus_module_2.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 = (0, tsplus_module_2.getDepth)(l);
+  return l.root.sizes === undefined ? (0, tsplus_module_2.nodeNthDense)(l.root, depth, offset === 0 ? index - prefixSize : (0, tsplus_module_2.handleOffset)(depth, offset, index - prefixSize)) : (0, tsplus_module_2.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 = (0, tsplus_module_2.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 = (0, tsplus_module_2.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 = (0, tsplus_module_2.getPrefixSize)(as);
+  const suffixSize = (0, tsplus_module_2.getSuffixSize)(as);
+  const newVector = mutableClone_1(as);
+
+  if (i < prefixSize) {
+    const newPrefix = (0, tsplus_module_2.copyArray)(newVector.prefix);
+    newPrefix[newPrefix.length - i - 1] = a;
+    newVector.prefix = newPrefix;
+  } else if (i >= as.length - suffixSize) {
+    const newSuffix = (0, tsplus_module_2.copyArray)(newVector.suffix);
+    newSuffix[i - (as.length - suffixSize)] = a;
+    newVector.suffix = newSuffix;
+  } else {
+    newVector.root = (0, tsplus_module_2.updateNode)(as.root, (0, tsplus_module_2.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.cjs.map