@fncts/base 0.0.21 → 0.0.23

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

@@ -48,13 +48,11 @@ exports.sliceRight = sliceRight;
 exports.sliceTreeVector = sliceTreeVector;
 exports.updateNode = updateNode;
 exports.zeroOffset = zeroOffset;
-
 /*
  * -------------------------------------------------------------------------------------------------
  * Internal
  * -------------------------------------------------------------------------------------------------
  */
-
 /**
  * @internal
  */
@@ -68,51 +66,40 @@ class VectorIterator {
     this.idx = direction === 1 ? -1 : l.length;
     this.prefixSize = getPrefixSize(l);
     this.middleSize = l.length - getSuffixSize(l);
-
     if (l.root !== undefined) {
       const depth = getDepth(l);
       this.stack = new Array(depth + 1);
       this.indices = new Array(depth + 1);
       let currentNode = l.root.array;
-
       for (let i = depth; 0 <= i; --i) {
         this.stack[i] = currentNode;
         const idx = direction === 1 ? 0 : currentNode.length - 1;
         this.indices[i] = idx;
         currentNode = currentNode[idx].array;
       }
-
       this.indices[0] -= direction;
     }
   }
-
 }
 /**
  * @internal
  */
-
-
 exports.VectorIterator = VectorIterator;
-
 class ForwardVectorIterator extends VectorIterator {
   constructor(l) {
     super(l, 1);
   }
-
   nextInTree() {
     for (var i = 0; ++this.indices[i] === this.stack[i].length; ++i) {
       this.indices[i] = 0;
     }
-
     for (; 0 < i; --i) {
       this.stack[i - 1] = this.stack[i][this.indices[i]].array;
     }
   }
-
   next() {
     let newVal;
     const idx = ++this.idx;
-
     if (idx < this.prefixSize) {
       newVal = this.l.prefix[this.prefixSize - idx - 1];
     } else if (idx < this.middleSize) {
@@ -123,41 +110,32 @@ class ForwardVectorIterator extends VectorIterator {
     } else {
       this.result.done = true;
     }
-
     this.result.value = newVal;
     return this.result;
   }
-
 }
 /**
  * @internal
  */
-
-
 exports.ForwardVectorIterator = ForwardVectorIterator;
-
 class BackwardVectorIterator extends VectorIterator {
   constructor(l) {
     super(l, -1);
   }
-
   prevInTree() {
-    for (var i = 0; this.indices[i] === 0; ++i) {//
+    for (var i = 0; this.indices[i] === 0; ++i) {
+      //
     }
-
     --this.indices[i];
-
     for (; 0 < i; --i) {
       const n = this.stack[i][this.indices[i]].array;
       this.stack[i - 1] = n;
       this.indices[i - 1] = n.length - 1;
     }
   }
-
   next() {
     let newVal;
     const idx = --this.idx;
-
     if (this.middleSize <= idx) {
       newVal = this.l.suffix[idx - this.middleSize];
     } else if (this.prefixSize <= idx) {
@@ -168,85 +146,63 @@ class BackwardVectorIterator extends VectorIterator {
     } else {
       this.result.done = true;
     }
-
     this.result.value = newVal;
     return this.result;
   }
-
 }
 /**
  * @internal
  */
-
-
 exports.BackwardVectorIterator = BackwardVectorIterator;
 const branchingFactor = 32;
 /**
  * @internal
  */
-
 const branchBits = 5;
 /**
  * @internal
  */
-
 exports.branchBits = branchBits;
 const mask = 31;
 /** @internal */
-
 exports.mask = mask;
-
 class Node {
   constructor(sizes, array) {
     this.sizes = sizes;
     this.array = array;
   }
-
 }
 /**
  * @internal
  */
-
-
 exports.Node = Node;
-
 function elementEquals(a, b) {
   return a === b;
 }
 /**
  * @internal
  */
-
-
 function createPath(depth, value) {
   let current = value;
-
   for (let i = 0; i < depth; ++i) {
     current = new Node(undefined, [current]);
   }
-
   return current;
-} // Array Helpers
-
+}
+// Array Helpers
 /**
  * @internal
  */
-
-
 function copyArray(source) {
   const array = [];
-
   for (let i = 0; i < source.length; ++i) {
     array[i] = source[i];
   }
-
   return array;
 }
 /**
  * @internal
  */
-
-
 function pushElements(source, target, offset, amount) {
   for (let i = offset; i < offset + amount; ++i) {
     target.push(source[i]);
@@ -255,8 +211,6 @@ function pushElements(source, target, offset, amount) {
 /**
  * @internal
  */
-
-
 function copyIndices(source, sourceStart, target, targetStart, length) {
   for (let i = 0; i < length; ++i) {
     target[targetStart + i] = source[sourceStart + i];
@@ -265,45 +219,34 @@ function copyIndices(source, sourceStart, target, targetStart, length) {
 /**
  * @internal
  */
-
-
 function arrayPrepend(value, array) {
   const newLength = array.length + 1;
   const result = new Array(newLength);
   result[0] = value;
-
   for (let i = 1; i < newLength; ++i) {
     result[i] = array[i - 1];
   }
-
   return result;
 }
 /**
  * Create a reverse _copy_ of an array.
  * @internal
  */
-
-
 function reverseArray(array) {
   return array.slice().reverse();
 }
 /**
  * @internal
  */
-
-
 function arrayFirst(array) {
   return array[0];
 }
 /**
  * @internal
  */
-
-
 function arrayLast(array) {
   return array[array.length - 1];
 }
-
 const pathResult = {
   path: 0,
   index: 0,
@@ -312,27 +255,21 @@ const pathResult = {
 /**
  * @internal
  */
-
 function getPath(index, offset, depth, sizes) {
   let i = index;
-
   if (sizes === undefined && offset !== 0) {
     pathResult.updatedOffset = 0;
     i = handleOffset(depth, offset, i);
   }
-
   let path = i >> depth * branchBits & mask;
-
   if (sizes !== undefined) {
     while (sizes[path] <= i) {
       path++;
     }
-
     const traversed = path === 0 ? 0 : sizes[path - 1];
     i -= traversed;
     pathResult.updatedOffset = offset;
   }
-
   pathResult.path = path;
   pathResult.index = i;
   return pathResult;
@@ -340,8 +277,6 @@ function getPath(index, offset, depth, sizes) {
 /**
  * @internal
  */
-
-
 function updateNode(node, depth, index, offset, value) {
   const {
     path,
@@ -355,113 +290,88 @@ function updateNode(node, depth, index, offset, value) {
 /**
  * @internal
  */
-
-
 function cloneNode({
   sizes,
   array
 }) {
   return new Node(sizes === undefined ? undefined : copyArray(sizes), copyArray(array));
-} // This array should not be mutated. Thus a dummy element is placed in
+}
+// This array should not be mutated. Thus a dummy element is placed in
 // it. Thus the affix will not be owned and thus not mutated.
-
 /**
  * @internal
  */
-
-
-const emptyAffix = [0]; // We store a bit field in Vector. From right to left, the first five
+const emptyAffix = [0];
+// We store a bit field in Vector. From right to left, the first five
 // bits are suffix length, the next five are prefix length and the
 // rest is depth. The functions below are for working with the bits in
 // a sane way.
-
 /**
  * @internal
  */
-
 exports.emptyAffix = emptyAffix;
 const affixBits = 6;
 /**
  * @internal
  */
-
 const affixMask = 0b111111;
 /**
  * @internal
  */
-
 function getSuffixSize(l) {
   return l.bits & affixMask;
 }
 /**
  * @internal
  */
-
-
 function getPrefixSize(l) {
   return l.bits >> affixBits & affixMask;
 }
 /**
  * @internal
  */
-
-
 function getDepth(l) {
   return l.bits >> affixBits * 2;
 }
 /**
  * @internal
  */
-
-
 function setPrefix(size, bits) {
   return size << affixBits | bits & ~(affixMask << affixBits);
 }
 /**
  * @internal
  */
-
-
 function setSuffix(size, bits) {
   return size | bits & ~affixMask;
 }
 /**
  * @internal
  */
-
-
 function setDepth(depth, bits) {
   return depth << affixBits * 2 | bits & (affixMask | affixMask << affixBits);
 }
 /**
  * @internal
  */
-
-
 function incrementPrefix(bits) {
   return bits + (1 << affixBits);
 }
 /**
  * @internal
  */
-
-
 function incrementSuffix(bits) {
   return bits + 1;
 }
 /**
  * @internal
  */
-
-
 function incrementDepth(bits) {
   return bits + (1 << affixBits * 2);
 }
 /**
  * @internal
  */
-
-
 function decrementDepth(bits) {
   return bits - (1 << affixBits * 2);
 }
@@ -470,12 +380,9 @@ function decrementDepth(bits) {
  *
  * @tsplus pipeable fncts.MutableVector push
  */
-
-
 function push(value) {
   return l => {
     const suffixSize = getSuffixSize(l);
-
     if (l.length === 0) {
       l.bits = setPrefix(1, l.bits);
       l.prefix = [value];
@@ -493,11 +400,9 @@ function push(value) {
       let depth = getDepth(l);
       l.suffix = [value];
       l.bits = setSuffix(1, l.bits);
-
       if (index - 1 < branchingFactor ** (depth + 1)) {
         for (; depth >= 0; --depth) {
           const path = index >> depth * branchBits & mask;
-
           if (path < current.array.length) {
             current = current.array[path];
           } else {
@@ -510,7 +415,6 @@ function push(value) {
         l.root = new Node(undefined, [l.root, createPath(depth, newNode)]);
       }
     }
-
     l.length++;
     return l;
   };
@@ -518,55 +422,43 @@ function push(value) {
 /**
  * @internal
  */
-
-
 function nodeNthDense(node, depth, index) {
-  let current = node; // eslint-disable-next-line no-param-reassign
-
+  let current = node;
+  // eslint-disable-next-line no-param-reassign
   for (; depth >= 0; --depth) {
     current = current.array[index >> depth * branchBits & mask];
   }
-
   return current;
 }
 /**
  * @internal
  */
-
-
 function handleOffset(depth, offset, index) {
   let i = index;
-  i += offset; // eslint-disable-next-line no-param-reassign
-
+  i += offset;
+  // eslint-disable-next-line no-param-reassign
   for (; depth >= 0; --depth) {
     i = index - (offset & mask << depth * branchBits);
-
     if ((index >> depth * branchBits & mask) !== 0) {
       break;
     }
   }
-
   return i;
 }
 /**
  * @internal
  */
-
-
 function nodeNth(node, depth, offset, index) {
   let path;
   let current = node;
   let i = index;
   let ofs = offset;
   let dep = depth;
-
   while (current.sizes !== undefined) {
     path = i >> dep * branchBits & mask;
-
     while (current.sizes[path] <= i) {
       path++;
     }
-
     if (path !== 0) {
       i -= current.sizes[path - 1];
       ofs = 0; // Offset is discarded if the left spine isn't traversed
@@ -575,23 +467,18 @@ function nodeNth(node, depth, offset, index) {
     dep--;
     current = current.array[path];
   }
-
   return nodeNthDense(current, dep, ofs === 0 ? i : handleOffset(dep, ofs, i));
 }
 /**
  * @internal
  */
-
-
 function setSizes(node, height) {
   let sum = 0;
   const sizeTable = [];
-
   for (let i = 0; i < node.array.length; ++i) {
     sum += sizeOfSubtree(node.array[i], height - 1);
     sizeTable[i] = sum;
   }
-
   node.sizes = sizeTable;
   return node;
 }
@@ -600,8 +487,6 @@ function setSizes(node, height) {
  *
  * @internal
  */
-
-
 function sizeOfSubtree(node, height) {
   if (height !== 0) {
     if (node.sizes !== undefined) {
@@ -614,13 +499,11 @@ function sizeOfSubtree(node, height) {
   } else {
     return node.array.length;
   }
-} // prepend & append
-
+}
+// prepend & append
 /**
  * @internal
  */
-
-
 function affixPush(a, array, length) {
   if (array.length === length) {
     array.push(a);
@@ -638,28 +521,21 @@ function affixPush(a, array, length) {
  *
  * @internal
  */
-
-
 function copyLeft(l, k) {
   let currentNode = cloneNode(l.root); // copy root
-
   l.root = currentNode; // install copy of root
-
   for (let i = 1; i < k; ++i) {
     const index = 0; // go left
-
     if (currentNode.sizes !== undefined) {
       for (let i = 0; i < currentNode.sizes.length; ++i) {
         currentNode.sizes[i] += 32;
       }
     }
-
-    const newNode = cloneNode(currentNode.array[index]); // Install the copied node
-
+    const newNode = cloneNode(currentNode.array[index]);
+    // Install the copied node
     currentNode.array[index] = newNode;
     currentNode = newNode;
   }
-
   return currentNode;
 }
 /**
@@ -667,21 +543,16 @@ function copyLeft(l, k) {
  *
  * @internal
  */
-
-
 function nodePrepend(value, size, node) {
   const array = arrayPrepend(value, node.array);
   let sizes = undefined;
-
   if (node.sizes !== undefined) {
     sizes = new Array(node.sizes.length + 1);
     sizes[0] = size;
-
     for (let i = 0; i < node.sizes.length; ++i) {
       sizes[i + 1] = node.sizes[i] + size;
     }
   }
-
   return new Node(sizes, array);
 }
 /**
@@ -690,11 +561,8 @@ function nodePrepend(value, size, node) {
  *
  * @internal
  */
-
-
 function prependTopTree(l, depth, node) {
   let newOffset;
-
   if (l.root.array.length < branchingFactor) {
     // There is space in the root, there is never a size table in this
     // case
@@ -707,7 +575,6 @@ function prependTopTree(l, depth, node) {
     newOffset = depth === 0 ? 0 : 32 ** (depth + 1) - 32;
     l.root = new Node(sizes, [createPath(depth, node), l.root]);
   }
-
   return newOffset;
 }
 /**
@@ -716,8 +583,6 @@ function prependTopTree(l, depth, node) {
  *
  * @internal
  */
-
-
 function prependNodeToTree(l, array) {
   if (l.root === undefined) {
     if (getSuffixSize(l) === 0) {
@@ -727,13 +592,11 @@ function prependNodeToTree(l, array) {
     } else {
       l.root = new Node(undefined, array);
     }
-
     return l;
   } else {
     const node = new Node(undefined, array);
     const depth = getDepth(l);
     let newOffset = 0;
-
     if (l.root.sizes === undefined) {
       if (l.offset !== 0) {
         newOffset = l.offset - branchingFactor;
@@ -745,30 +608,24 @@ function prependNodeToTree(l, array) {
       }
     } else {
       // represents how many nodes _with size-tables_ that we should copy.
-      let copyableCount = 0; // go down while there is size tables
-
+      let copyableCount = 0;
+      // go down while there is size tables
       let nodesTraversed = 0;
       let currentNode = l.root;
-
       while (currentNode.sizes !== undefined && nodesTraversed < depth) {
         ++nodesTraversed;
-
         if (currentNode.array.length < 32) {
           // there is room if offset is > 0 or if the first node does not
           // contain as many nodes as it possibly can
           copyableCount = nodesTraversed;
         }
-
         currentNode = currentNode.array[0];
       }
-
       if (l.offset !== 0) {
         const copiedNode = copyLeft(l, nodesTraversed);
-
         for (let i = 0; i < copiedNode.sizes.length; ++i) {
           copiedNode.sizes[i] += branchingFactor;
         }
-
         copiedNode.array[0] = prependDense(copiedNode.array[0], depth - nodesTraversed, l.offset, node);
         l.offset = l.offset - branchingFactor;
         return l;
@@ -777,8 +634,8 @@ function prependNodeToTree(l, array) {
           l.offset = prependTopTree(l, depth, node);
         } else {
           let parent;
-          let prependableNode; // Copy the part of the path with size tables
-
+          let prependableNode;
+          // Copy the part of the path with size tables
           if (copyableCount > 1) {
             parent = copyLeft(l, copyableCount - 1);
             prependableNode = parent.array[0];
@@ -786,23 +643,19 @@ function prependNodeToTree(l, array) {
             parent = undefined;
             prependableNode = l.root;
           }
-
-          const path = createPath(depth - copyableCount, node); // add offset
-
+          const path = createPath(depth - copyableCount, node);
+          // add offset
           l.offset = 32 ** (depth - copyableCount + 1) - 32;
           const prepended = nodePrepend(path, 32, prependableNode);
-
           if (parent === undefined) {
             l.root = prepended;
           } else {
             parent.array[0] = prepended;
           }
         }
-
         return l;
       }
     }
-
     l.offset = newOffset;
     return l;
   }
@@ -812,13 +665,10 @@ function prependNodeToTree(l, array) {
  *
  * @internal
  */
-
-
 function prependDense(node, depth, offset, value) {
   // We're indexing down `offset - 1`. At each step `path` is either 0 or -1.
   const curOffset = offset >> depth * branchBits & mask;
   const path = (offset - 1 >> depth * branchBits & mask) - curOffset;
-
   if (path < 0) {
     return new Node(undefined, arrayPrepend(createPath(depth - 1, value), node.array));
   } else {
@@ -833,8 +683,6 @@ function prependDense(node, depth, offset, value) {
  *
  * @internal
  */
-
-
 function appendNodeToTree(l, array) {
   if (l.root === undefined) {
     // The old Vector has no content in tree, all content is in affixes
@@ -844,26 +692,20 @@ function appendNodeToTree(l, array) {
     } else {
       l.root = new Node(undefined, array);
     }
-
     return l;
   }
-
   const depth = getDepth(l);
   let index = handleOffset(depth, l.offset, l.length - 1 - getPrefixSize(l));
   let nodesToCopy = 0;
   let nodesVisited = 0;
   let shift = depth * 5;
   let currentNode = l.root;
-
   if (32 ** (depth + 1) < index) {
     shift = 0; // there is no room
-
     nodesVisited = depth;
   }
-
   while (shift > 5) {
     let childIndex;
-
     if (currentNode.sizes === undefined) {
       // does not have size table
       childIndex = index >> shift & mask;
@@ -872,17 +714,13 @@ function appendNodeToTree(l, array) {
       childIndex = currentNode.array.length - 1;
       index -= currentNode.sizes[childIndex - 1];
     }
-
     nodesVisited++;
-
     if (childIndex < mask) {
       // we are not going down the far right path, this implies that
       // there is still room in the current node
       nodesToCopy = nodesVisited;
     }
-
     currentNode = currentNode.array[childIndex];
-
     if (currentNode === undefined) {
       // This will only happened in a pvec subtree. The index does not
       // exist so we'll have to create a new path from here on.
@@ -892,18 +730,14 @@ function appendNodeToTree(l, array) {
 
     shift -= 5;
   }
-
   if (shift !== 0) {
     nodesVisited++;
-
     if (currentNode.array.length < branchingFactor) {
       // there is room in the found node
       nodesToCopy = nodesVisited;
     }
   }
-
   const node = new Node(undefined, array);
-
   if (nodesToCopy === 0) {
     // there was no room in the found node
     const newPath = nodesVisited === 0 ? node : createPath(nodesVisited, node);
@@ -914,7 +748,6 @@ function appendNodeToTree(l, array) {
     const copiedNode = copyFirstK(l, nodesToCopy, array.length);
     copiedNode.array.push(createPath(depth - nodesToCopy, node));
   }
-
   return l;
 }
 /**
@@ -922,52 +755,38 @@ function appendNodeToTree(l, array) {
  *
  * @internal
  */
-
-
 function copyFirstK(newVector, k, leafSize) {
   let currentNode = cloneNode(newVector.root); // copy root
-
   newVector.root = currentNode; // install root
-
   for (let i = 1; i < k; ++i) {
     const index = currentNode.array.length - 1;
-
     if (currentNode.sizes !== undefined) {
       currentNode.sizes[index] += leafSize;
     }
-
-    const newNode = cloneNode(currentNode.array[index]); // Install the copied node
-
+    const newNode = cloneNode(currentNode.array[index]);
+    // Install the copied node
     currentNode.array[index] = newNode;
     currentNode = newNode;
   }
-
   if (currentNode.sizes !== undefined) {
     currentNode.sizes.push(arrayLast(currentNode.sizes) + leafSize);
   }
-
   return currentNode;
 }
-
 const eMax = 2;
 /**
  * @internal
  */
-
 function createConcatPlan(array) {
   const sizes = [];
   let sum = 0;
-
   for (let i = 0; i < array.length; ++i) {
     sum += array[i].array.length; // FIXME: maybe only access array once
-
     sizes[i] = array[i].array.length;
   }
-
   const optimalLength = Math.ceil(sum / branchingFactor);
   let n = array.length;
   let i = 0;
-
   if (optimalLength + eMax >= n) {
     return undefined; // no rebalancing needed
   }
@@ -976,27 +795,22 @@ function createConcatPlan(array) {
     while (sizes[i] > branchingFactor - eMax / 2) {
       // Skip nodes that are already sufficiently balanced
       ++i;
-    } // the node at this index is too short
-
-
+    }
+    // the node at this index is too short
     let remaining = sizes[i]; // number of elements to re-distribute
-
     do {
       const size = Math.min(remaining + sizes[i + 1], branchingFactor);
       sizes[i] = size;
       remaining = remaining - (size - sizes[i + 1]);
       ++i;
-    } while (remaining > 0); // Shift nodes after
-
-
+    } while (remaining > 0);
+    // Shift nodes after
     for (let j = i; j <= n - 1; ++j) {
       sizes[j] = sizes[j + 1];
     }
-
     --i;
     --n;
   }
-
   sizes.length = n;
   return sizes;
 }
@@ -1007,55 +821,42 @@ function createConcatPlan(array) {
  *
  * @internal
  */
-
-
 function concatNodeMerge(left, center, right) {
   const array = [];
-
   if (left !== undefined) {
     for (let i = 0; i < left.array.length - 1; ++i) {
       array.push(left.array[i]);
     }
   }
-
   for (let i = 0; i < center.array.length; ++i) {
     array.push(center.array[i]);
   }
-
   if (right !== undefined) {
     for (let i = 1; i < right.array.length; ++i) {
       array.push(right.array[i]);
     }
   }
-
   return array;
 }
 /**
  * @internal
  */
-
-
 function executeConcatPlan(merged, plan, height) {
   const result = [];
   let sourceIdx = 0; // the current node we're copying from
-
   let offset = 0; // elements in source already used
-
   for (let toMove of plan) {
     let source = merged[sourceIdx].array;
-
     if (toMove === source.length && offset === 0) {
       // source matches target exactly, reuse source
       result.push(merged[sourceIdx]);
       ++sourceIdx;
     } else {
       const node = new Node(undefined, []);
-
       while (toMove > 0) {
         const available = source.length - offset;
         const itemsToCopy = Math.min(toMove, available);
         pushElements(source, node.array, offset, itemsToCopy);
-
         if (toMove >= available) {
           ++sourceIdx;
           source = merged[sourceIdx].array;
@@ -1063,19 +864,15 @@ function executeConcatPlan(merged, plan, height) {
         } else {
           offset += itemsToCopy;
         }
-
         toMove -= itemsToCopy;
       }
-
       if (height > 1) {
         // Set sizes on children unless they are leaf nodes
         setSizes(node, height - 1);
       }
-
       result.push(node);
     }
   }
-
   return result;
 }
 /**
@@ -1085,13 +882,10 @@ function executeConcatPlan(merged, plan, height) {
  *
  * @internal
  */
-
-
 function rebalance(left, center, right, height, top) {
   const merged = concatNodeMerge(left, center, right);
   const plan = createConcatPlan(merged);
   const balanced = plan !== undefined ? executeConcatPlan(merged, plan, height) : merged;
-
   if (balanced.length <= branchingFactor) {
     if (top === true) {
       return new Node(undefined, balanced);
@@ -1107,8 +901,6 @@ function rebalance(left, center, right, height, top) {
 /**
  * @internal
  */
-
-
 function concatSubTree(left, lDepth, right, rDepth, isTop) {
   if (lDepth > rDepth) {
     const c = concatSubTree(arrayLast(left.array), lDepth - 1, right, rDepth, false);
@@ -1126,15 +918,11 @@ function concatSubTree(left, lDepth, right, rDepth, isTop) {
 /**
  * @internal
  */
-
-
 const concatBuffer = /*#__PURE__*/new Array(3);
 /**
  * @internal
  */
-
 exports.concatBuffer = concatBuffer;
-
 function concatAffixes(left, right) {
   // TODO: Try and find a neat way to reduce the LOC here
   let nr = 0;
@@ -1142,42 +930,32 @@ function concatAffixes(left, right) {
   let i = 0;
   let length = getSuffixSize(left);
   concatBuffer[nr] = [];
-
   for (i = 0; i < length; ++i) {
     concatBuffer[nr][arrIdx++] = left.suffix[i];
   }
-
   length = getPrefixSize(right);
-
   for (i = 0; i < length; ++i) {
     if (arrIdx === 32) {
       arrIdx = 0;
       ++nr;
       concatBuffer[nr] = [];
     }
-
     concatBuffer[nr][arrIdx++] = right.prefix[length - 1 - i];
   }
-
   length = getSuffixSize(right);
-
   for (i = 0; i < length; ++i) {
     if (arrIdx === 32) {
       arrIdx = 0;
       ++nr;
       concatBuffer[nr] = [];
     }
-
     concatBuffer[nr][arrIdx++] = right.suffix[i];
   }
-
   return nr;
 }
 /**
  * @internal
  */
-
-
 function getHeight(node) {
   if (node.array[0] instanceof Node) {
     return 1 + getHeight(node.array[0]);
@@ -1188,31 +966,23 @@ function getHeight(node) {
 /**
  * @internal
  */
-
-
-let newAffix; // function getBitsForDepth(n: number, depth: number): number {
+let newAffix;
+// function getBitsForDepth(n: number, depth: number): number {
 //   return n & ~(~0 << ((depth + 1) * branchBits));
 // }
-
 exports.newAffix = newAffix;
-
 function sliceNode(node, index, depth, pathLeft, pathRight, childLeft, childRight) {
   const array = node.array.slice(pathLeft, pathRight + 1);
-
   if (childLeft !== undefined) {
     array[0] = childLeft;
   }
-
   if (childRight !== undefined) {
     array[array.length - 1] = childRight;
   }
-
   let sizes = node.sizes;
-
   if (sizes !== undefined) {
     sizes = sizes.slice(pathLeft, pathRight + 1);
     let slicedOffLeft = pathLeft !== 0 ? node.sizes[pathLeft - 1] : 0;
-
     if (childLeft !== undefined) {
       // If the left child has been sliced into a new child we need to know
       // how many elements have been removed from the child.
@@ -1231,112 +1001,89 @@ function sliceNode(node, index, depth, pathLeft, pathRight, childLeft, childRigh
         slicedOffLeft += (index - slicedOffLeft & ~0b011111) + 32;
       }
     }
-
     for (let i = 0; i < sizes.length; ++i) {
       sizes[i] -= slicedOffLeft;
     }
-
     if (childRight !== undefined) {
       const slicedOffRight = sizeOfSubtree(node.array[pathRight], depth - 1) - sizeOfSubtree(childRight, depth - 1);
       sizes[sizes.length - 1] -= slicedOffRight;
     }
   }
-
   return new Node(sizes, array);
 }
 /**
  * @internal
  */
-
-
 let newOffset = 0;
 exports.newOffset = newOffset;
-
 function sliceLeft(tree, depth, index, offset, top) {
   let {
     index: newIndex,
     path,
     updatedOffset
   } = getPath(index, offset, depth, tree.sizes);
-
   if (depth === 0) {
-    exports.newAffix = newAffix = tree.array.slice(path).reverse(); // This leaf node is moved up as a suffix so there is nothing here
+    exports.newAffix = newAffix = tree.array.slice(path).reverse();
+    // This leaf node is moved up as a suffix so there is nothing here
     // after slicing
-
     return undefined;
   } else {
     const child = sliceLeft(tree.array[path], depth - 1, newIndex, updatedOffset, false);
-
     if (child === undefined) {
       // There is nothing in the child after slicing so we don't include it
       ++path;
-
       if (path === tree.array.length) {
         return undefined;
       }
-    } // If we've sliced something away and it's not a the root, update offset
-
-
+    }
+    // If we've sliced something away and it's not a the root, update offset
     if (tree.sizes === undefined && top === false) {
       exports.newOffset = newOffset = newOffset | 32 - (tree.array.length - path) << depth * branchBits;
     }
-
     return sliceNode(tree, index, depth, path, tree.array.length - 1, child, undefined);
   }
 }
 /** Slice elements off of a tree from the right */
-
-
 function sliceRight(node, depth, index, offset) {
   let {
     index: newIndex,
     path
   } = getPath(index, offset, depth, node.sizes);
-
   if (depth === 0) {
-    exports.newAffix = newAffix = node.array.slice(0, path + 1); // this leaf node is moved up as a suffix so there is nothing here
+    exports.newAffix = newAffix = node.array.slice(0, path + 1);
+    // this leaf node is moved up as a suffix so there is nothing here
     // after slicing
-
     return undefined;
   } else {
     // slice the child, note that we subtract 1 then the radix lookup
     // algorithm can find the last element that we want to include
     // and sliceRight will do a slice that is inclusive on the index.
     const child = sliceRight(node.array[path], depth - 1, newIndex, path === 0 ? offset : 0);
-
     if (child === undefined) {
       // there is nothing in the child after slicing so we don't include it
       --path;
-
       if (path === -1) {
         return undefined;
       }
-    } // note that we add 1 to the path since we want the slice to be
+    }
+    // note that we add 1 to the path since we want the slice to be
     // inclusive on the end index. Only at the leaf level do we want
     // to do an exclusive slice.
-
-
     const array = node.array.slice(0, path + 1);
-
     if (child !== undefined) {
       array[array.length - 1] = child;
     }
-
     let sizes = node.sizes;
-
     if (sizes !== undefined) {
       sizes = sizes.slice(0, path + 1);
-
       if (child !== undefined) {
         const slicedOff = sizeOfSubtree(node.array[path], depth - 1) - sizeOfSubtree(child, depth - 1);
         sizes[sizes.length - 1] -= slicedOff;
       }
     }
-
     return new Node(sizes, array);
   }
 }
-
 function sliceTreeVector(from, to, tree, depth, offset, l) {
   const sizes = tree.sizes;
   let {
@@ -1347,7 +1094,6 @@ function sliceTreeVector(from, to, tree, depth, offset, l) {
     index: newTo,
     path: pathRight
   } = getPath(to, offset, depth, sizes);
-
   if (depth === 0) {
     // we are slicing a piece off a leaf node
     l.prefix = emptyAffix;
@@ -1364,21 +1110,17 @@ function sliceTreeVector(from, to, tree, depth, offset, l) {
     const childRight = sliceRight(tree.array[pathRight], depth - 1, newTo, 0);
     l.bits = setSuffix(newAffix.length, l.bits);
     l.suffix = newAffix;
-
     if (childRight === undefined) {
       --pathRight;
     }
-
     exports.newOffset = newOffset = 0;
     const childLeft = sliceLeft(tree.array[pathLeft], depth - 1, newFrom, pathLeft === 0 ? offset : 0, pathLeft === pathRight);
     l.offset = newOffset;
     l.bits = setPrefix(newAffix.length, l.bits);
     l.prefix = newAffix;
-
     if (childLeft === undefined) {
       ++pathLeft;
     }
-
     if (pathLeft >= pathRight) {
       if (pathLeft > pathRight) {
         // This only happens when `pathLeft` originally was equal to
@@ -1395,55 +1137,44 @@ function sliceTreeVector(from, to, tree, depth, offset, l) {
     } else {
       l.root = sliceNode(tree, from, depth, pathLeft, pathRight, childLeft, childRight);
     }
-
     return l;
   }
 }
 /**
  * @internal
  */
-
-
 function zeroOffset() {
   exports.newOffset = newOffset = 0;
 }
-
 function foldLeftArrayCb(cb, state, array, from, to, offset) {
-  for (var i = from; i < to && cb(array[i], state, i + offset); ++i) {//
+  for (var i = from; i < to && cb(array[i], state, i + offset); ++i) {
+    //
   }
-
   return [i === to, i + offset + 1];
 }
-
 function foldRightArrayCb(cb, state, array, from, to, offset) {
   // eslint-disable-next-line no-param-reassign
-  for (var i = from - 1; to <= i && cb(array[i], state, offset); --i, offset--) {//
+  for (var i = from - 1; to <= i && cb(array[i], state, offset); --i, offset--) {
+    //
   }
-
   return [i === to - 1, offset];
 }
-
 function foldLeftNodeCb(cb, state, node, depth, offset) {
   const {
     array
   } = node;
-
   if (depth === 0) {
     return foldLeftArrayCb(cb, state, array, 0, array.length, offset);
   }
-
   const to = array.length;
   let j = offset;
   let cont;
-
   for (let i = 0; i < to; ++i) {
     [cont, j] = foldLeftNodeCb(cb, state, array[i], depth - 1, j);
-
     if (!cont) {
       return [false, j];
     }
   }
-
   return [true, j];
 }
 /**
@@ -1453,170 +1184,128 @@ function foldLeftNodeCb(cb, state, node, depth, offset) {
  * to continue the fold. `true` indicates that the folding should
  * continue.
  */
-
-
 function foldLeftCb(cb, state, l) {
   const prefixSize = getPrefixSize(l);
   let i = prefixSize - 1;
   let cont = true;
   [cont, i] = foldRightArrayCb(cb, state, l.prefix, prefixSize, 0, i);
-
   if (!cont) {
     return state;
   }
-
   i = prefixSize;
-
   if (l.root !== undefined) {
     [cont, i] = foldLeftNodeCb(cb, state, l.root, getDepth(l), i);
-
     if (!cont) {
       return state;
     }
   }
-
   const suffixSize = getSuffixSize(l);
   foldLeftArrayCb(cb, state, l.suffix, 0, suffixSize, i);
   return state;
 }
-
 function foldRightNodeCb(cb, state, node, depth, offset) {
   const {
     array
   } = node;
-
   if (depth === 0) {
     return foldRightArrayCb(cb, state, array, array.length, 0, offset);
   }
-
   let j = offset;
   let cont;
-
   for (let i = array.length - 1; 0 <= i; --i) {
     [cont, j] = foldRightNodeCb(cb, state, array[i], depth - 1, j);
-
     if (!cont) {
       return [false, j];
     }
   }
-
   return [true, j];
 }
-
 function foldRightCb(cb, state, l) {
   const suffixSize = getSuffixSize(l);
   const prefixSize = getPrefixSize(l);
   let i = l.length - 1;
   let cont = true;
   [cont, i] = foldRightArrayCb(cb, state, l.suffix, suffixSize, 0, i);
-
   if (!cont) {
     return state;
   }
-
   if (l.root !== undefined) {
     [cont, i] = foldRightNodeCb(cb, state, l.root, getDepth(l), i);
-
     if (!cont) {
       return state;
     }
   }
-
   const prefix = l.prefix;
   foldLeftArrayCb(cb, state, l.prefix, prefix.length - prefixSize, prefix.length, prefix.length - 1);
   return state;
 }
-
 function foldLeftPrefix(f, b, array, length) {
   let acc = b;
   let j = 0;
-
   for (let i = length - 1; 0 <= i; --i, j++) {
     acc = f(j, acc, array[i]);
   }
-
   return [acc, j];
 }
-
 function foldLeftNode(f, b, node, depth, offset) {
   const {
     array
   } = node;
   let acc = b;
   let j = offset;
-
   if (depth === 0) {
     return foldLeftSuffix(f, b, array, array.length, offset);
   }
-
   for (let i = 0; i < array.length; ++i) {
     [acc, j] = foldLeftNode(f, acc, array[i], depth - 1, j);
   }
-
   return [acc, j];
 }
-
 function foldLeftSuffix(f, b, array, length, offset) {
   let acc = b;
   let j = offset;
-
   for (let i = 0; i < length; ++i, j++) {
     acc = f(j, acc, array[i]);
   }
-
   return [acc, j];
 }
-
 function foldRightPrefix(f, b, array, length, offset) {
   let acc = b;
   let j = offset;
-
   for (let i = 0; i < length; ++i, j--) {
     acc = f(j, array[i], acc);
   }
-
   return [acc, j];
 }
-
 function foldRightNode(f, b, node, depth, offset) {
   const {
     array
   } = node;
   let acc = b;
   let j = offset;
-
   if (depth === 0) {
     return foldRightSuffix(f, b, array, array.length, offset);
   }
-
   for (let i = array.length - 1; 0 <= i; --i) {
     [acc, j] = foldRightNode(f, acc, array[i], depth - 1, j);
   }
-
   return [acc, j];
 }
-
 function foldRightSuffix(f, b, array, length, offset) {
   let acc = b;
   let j = offset;
-
   for (let i = length - 1; 0 <= i; --i, j--) {
     acc = f(j, array[i], acc);
   }
-
   return [acc, j];
 }
-
 function mapArray(f, array, offset) {
   const result = new Array(array.length);
-
   for (let i = 0; i < array.length; ++i) {
     result[i] = f(offset + i, array[i]);
   }
-
   return [result, offset + array.length];
 }
-
 function mapNode(f, node, depth, offset, adjust) {
   if (depth !== 0) {
     const {
@@ -1624,41 +1313,32 @@ function mapNode(f, node, depth, offset, adjust) {
     } = node;
     let innerOffset = offset;
     const result = new Array(array.length);
-
     for (let i = 0; i < array.length; ++i) {
       const [res, newOffset] = mapNode(f, array[i], depth - 1, innerOffset, adjust * 32);
       innerOffset = newOffset;
       result[i] = res;
     }
-
     return [new Node(node.sizes, result), innerOffset];
   } else {
     const [res, newOffset] = mapArray(f, node.array, offset);
     return [new Node(undefined, res), newOffset];
   }
 }
-
 function mapPrefix(f, prefix, length) {
   const newPrefix = new Array(length);
-
   for (let i = length - 1; 0 <= i; --i) {
     newPrefix[i] = f(length - 1 - i, prefix[i]);
   }
-
   return newPrefix;
 }
-
 function mapAffix(f, suffix, length, totalLength) {
   const priorLength = totalLength - length;
   const newSuffix = new Array(length);
-
   for (let i = 0; i < length; ++i) {
     newSuffix[i] = f(priorLength + i, suffix[i]);
   }
-
   return newSuffix;
 }
-
 function arrayPush(array, a) {
   array.push(a);
   return array;