list-toolkit 2.0.0 → 2.1.0

package/README.md

@@ -102,7 +102,7 @@ const john = new Person('John'),
 const people = List.from([john, jane, jim, jill]);
 
 // iterator over the list manually:
-for (let node = people.front; node !== people; node = node[list.nextName]) {
+for (let node = people.front; node !== people; node = node[people.nextName]) {
   console.log(node.name); // John, Jane, Jim, Jill
 }
 // yes, the link names are customizable, can be strings or symbols, for example:
@@ -146,6 +146,7 @@ BSD 3-Clause "New" or "Revised" License. See the LICENSE file for details.
 
 ## Release History
 
+* 2.1.0 *Added splay tree. Updated deps.*
 * 2.0.0 *New major release.*
 * 1.0.1 *Fixed exports. Added more methods to `MinHeap`.*
 * 1.0.1 *Initial release.*

package/cjs/heap/min-heap.js

@@ -27,17 +27,10 @@ const down = (array, i, less = defaultLess, n = array.length) => {
   for (;;) {
     const l = (i << 1) + 1;
     if (l >= n) break;
-    let c = l,
+    const r = l + 1,
+      c = r < n && less(array[r], array[l]) ? r : l,
+      iValue = array[i],
       cValue = array[c];
-    const r = c + 1;
-    if (r < n) {
-      const rValue = array[r];
-      if (less(rValue, cValue)) {
-        c = r;
-        cValue = rValue;
-      }
-    }
-    const iValue = array[i];
     if (!less(cValue, iValue)) break;
     array[i] = cValue;
     array[c] = iValue;
@@ -48,6 +41,10 @@ const down = (array, i, less = defaultLess, n = array.length) => {
 class MinHeap {
   constructor(options, ...args) {
     (0, _metaUtils.copyOptions)(this, MinHeap.defaults, options);
+    if (typeof this.compare == 'function') {
+      this.less = (a, b) => this.compare(a, b) < 0;
+      this.equal = (a, b) => !this.compare(a, b);
+    }
     this.array = [];
     this.merge(...args);
   }
@@ -78,17 +75,10 @@ class MinHeap {
     for (let i = 0;;) {
       const l = (i << 1) + 1;
       if (l >= n) break;
-      let c = l,
+      const r = l + 1,
+        c = r < n && this.less(this.array[r], this.array[l]) ? r : l,
+        iValue = this.array[i],
         cValue = this.array[c];
-      const r = c + 1;
-      if (r < n) {
-        const rValue = this.array[r];
-        if (this.less(rValue, cValue)) {
-          c = r;
-          cValue = rValue;
-        }
-      }
-      const iValue = this.array[i];
       if (!this.less(cValue, iValue)) break;
       this.array[i] = cValue;
       this.array[c] = iValue;
@@ -120,17 +110,10 @@ class MinHeap {
     for (let i = 0;;) {
       const l = (i << 1) + 1;
       if (l >= n) break;
-      let c = l,
+      const r = l + 1,
+        c = r < n && this.less(this.array[r], this.array[l]) ? r : l,
+        iValue = this.array[i],
         cValue = this.array[c];
-      const r = c + 1;
-      if (r < n) {
-        const rValue = this.array[r];
-        if (this.less(rValue, cValue)) {
-          c = r;
-          cValue = rValue;
-        }
-      }
-      const iValue = this.array[i];
       if (!this.less(cValue, iValue)) break;
       this.array[i] = cValue;
       this.array[c] = iValue;
@@ -147,17 +130,10 @@ class MinHeap {
     for (let i = 0;;) {
       const l = (i << 1) + 1;
       if (l >= n) break;
-      let c = l,
+      const r = l + 1,
+        c = r < n && this.less(this.array[r], this.array[l]) ? r : l,
+        iValue = this.array[i],
         cValue = this.array[c];
-      const r = c + 1;
-      if (r < n) {
-        const rValue = this.array[r];
-        if (this.less(rValue, cValue)) {
-          c = r;
-          cValue = rValue;
-        }
-      }
-      const iValue = this.array[i];
       if (!this.less(cValue, iValue)) break;
       this.array[i] = cValue;
       this.array[c] = iValue;
@@ -230,17 +206,10 @@ class MinHeap {
       for (let i = j;;) {
         const l = (i << 1) + 1;
         if (l >= n) break;
-        let c = l,
+        const r = l + 1,
+          c = r < n && less(array[r], array[l]) ? r : l,
+          iValue = array[i],
           cValue = array[c];
-        const r = c + 1;
-        if (r < n) {
-          const rValue = array[r];
-          if (less(rValue, cValue)) {
-            c = r;
-            cValue = rValue;
-          }
-        }
-        const iValue = array[i];
         if (!less(cValue, iValue)) break;
         array[i] = cValue;
         array[c] = iValue;
@@ -323,6 +292,7 @@ class MinHeap {
 exports.MinHeap = MinHeap;
 MinHeap.defaults = {
   less: defaultLess,
-  equal: defaultEqual
+  equal: defaultEqual,
+  compare: null
 };
 var _default = exports.default = MinHeap;

package/cjs/meta-utils.js

@@ -119,7 +119,7 @@ exports.addAlias = addAlias;
 const addAliases = (object, dict, force) => copyDescriptors(object, object, dict, force);
 exports.addAliases = addAliases;
 const augmentIterator = iterator => {
-  if (!Object.hasOwnProperty(Symbol.iterator)) {
+  if (!iterator.hasOwnProperty(Symbol.iterator)) {
     iterator[Symbol.iterator] = function () {
       return this;
     };

package/cjs/tree/splay-tree.js

@@ -0,0 +1,362 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.SplayTreeNode = exports.SplayTree = void 0;
+var _metaUtils = require("../meta-utils.js");
+const defaultLess = (a, b) => a < b;
+const zig = tree => {
+  const newTree = tree.left,
+    parent = newTree.parent = tree.parent;
+  if (parent) {
+    if (parent.left === tree) parent.left = newTree;else parent.right = newTree;
+  }
+  tree.parent = newTree;
+  const child = tree.left = newTree.right;
+  if (child) child.parent = tree;
+  newTree.right = tree;
+  return newTree;
+};
+const zag = tree => {
+  const newTree = tree.right,
+    parent = newTree.parent = tree.parent;
+  if (parent) {
+    if (parent.left === tree) parent.left = newTree;else parent.right = newTree;
+  }
+  tree.parent = newTree;
+  const child = tree.right = newTree.left;
+  if (child) child.parent = tree;
+  newTree.left = tree;
+  return newTree;
+};
+const splay = node => {
+  while (node.parent) {
+    if (!node.parent.parent) {
+      node.parent.left === node ? zig(node.parent) : zag(node.parent);
+    } else if (node.parent.left === node && node.parent.parent.left === node.parent) {
+      zig(node.parent.parent);
+      zig(node.parent);
+    } else if (node.parent.right === node && node.parent.parent.right === node.parent) {
+      zag(node.parent.parent);
+      zag(node.parent);
+    } else if (node.parent.left === node && node.parent.parent.right === node.parent) {
+      zig(node.parent);
+      zag(node.parent);
+    } else {
+      zag(node.parent);
+      zig(node.parent);
+    }
+  }
+  return node;
+};
+const count = tree => tree ? count(tree.left) + count(tree.right) + 1 : 0;
+class SplayTreeNode {
+  constructor(value) {
+    this.left = this.right = this.parent = null;
+    this.value = value;
+  }
+  getMin() {
+    let z = this;
+    while (z.left) z = z.left;
+    return z;
+  }
+  getMax() {
+    let z = this;
+    while (z.right) z = z.right;
+    return z;
+  }
+}
+exports.SplayTreeNode = SplayTreeNode;
+class SplayTree {
+  constructor(options) {
+    (0, _metaUtils.copyOptions)(this, SplayTree.defaults, options);
+    if (typeof this.compare == 'function') {
+      this.less = (a, b) => this.compare(a, b) < 0;
+      this.find = this.findWithCompare;
+      this.insert = this.insertWithCompare;
+      this.splitMaxTree = this.splitMaxTreeWithCompare;
+    }
+    this.root = null;
+    this.size = 0;
+  }
+  get isEmpty() {
+    return !this.root;
+  }
+  get length() {
+    return this.size;
+  }
+  getMin() {
+    return this.root.getMin();
+  }
+  getMax() {
+    return this.root.getMax();
+  }
+  find(value) {
+    for (let z = this.root; z;) {
+      if (this.less(z.value, value)) z = z.right;else if (this.less(value, z.value)) z = z.left;else return z;
+    }
+    return null;
+  }
+  findWithCompare(value) {
+    for (let z = this.root; z;) {
+      const cmp = this.compare(value, z.value);
+      if (cmp < 0) z = z.left;else if (cmp > 0) z = z.right;else return z;
+    }
+    return null;
+  }
+  promote(value) {
+    const z = this.find(value);
+    if (z) {
+      this.root = splay(z);
+    }
+    return z;
+  }
+  splay(node) {
+    this.root = splay(node);
+    return this;
+  }
+  insert(value) {
+    let z = this.root,
+      parent = null;
+    while (z) {
+      parent = z;
+      if (this.less(z.value, value)) z = z.right;else if (this.less(value, z.value)) z = z.left;else break;
+    }
+    if (!z) {
+      z = new SplayTreeNode(value);
+      z.parent = parent;
+      if (parent) {
+        if (this.less(parent.value, value)) parent.right = z;else parent.left = z;
+      }
+      ++this.size;
+    }
+    this.root = splay(z);
+    return this;
+  }
+  insertWithCompare(value) {
+    let z = this.root,
+      parent = null;
+    while (z) {
+      parent = z;
+      const cmp = this.compare(value, z.value);
+      if (cmp < 0) z = z.left;else if (cmp > 0) z = z.right;else break;
+    }
+    if (!z) {
+      z = new SplayTreeNode(value);
+      z.parent = parent;
+      if (parent) {
+        if (this.compare(parent.value, value) < 0) parent.right = z;else parent.left = z;
+      }
+      ++this.size;
+    }
+    this.root = splay(z);
+    return this;
+  }
+  remove(value) {
+    const z = this.find(value);
+    if (!z) return this;
+    splay(z);
+    this.root = null;
+    let maxNode = null;
+    if (z.left) {
+      z.left.parent = null;
+      maxNode = z.left.getMax();
+      this.root = splay(maxNode);
+    }
+    if (z.right) {
+      if (maxNode) maxNode.right = z.right;else this.root = z.right;
+      z.right.parent = maxNode;
+    }
+    --this.size;
+    return this;
+  }
+  clear() {
+    this.root = null;
+    this.size = 0;
+    return this;
+  }
+  splitMaxTree(value) {
+    if (!this.root) return new SplayTree(this);
+    let z = this.root,
+      parent = null,
+      right;
+    while (z) {
+      parent = z;
+      if (this.less(z.value, value)) {
+        z = z.right;
+        right = true;
+      } else if (this.less(value, z.value)) {
+        z = z.left;
+        right = false;
+      } else break;
+    }
+    this.root = splay(z || parent);
+    const newTree = new SplayTree(this);
+    if (z || right) {
+      newTree.root = this.root.right;
+      if (newTree.root) {
+        newTree.root.parent = null;
+        newTree.size = count(newTree.root);
+        this.root.right = null;
+        this.size -= newTree.size;
+      }
+    } else {
+      newTree.root = this.root;
+      newTree.size = this.size;
+      this.root = this.root.left;
+      if (this.root) {
+        this.root.parent = null;
+        this.size = count(this.root);
+        newTree.root.left = null;
+        newTree.size -= this.size;
+      }
+    }
+    return newTree;
+  }
+  splitMaxTreeWithCompare(value) {
+    if (!this.root) return new SplayTree(this);
+    let z = this.root,
+      parent = null,
+      right;
+    while (z) {
+      parent = z;
+      const cmp = this.compare(value, z.value);
+      if (cmp < 0) {
+        z = z.left;
+        right = false;
+      } else if (cmp > 0) {
+        z = z.right;
+        right = true;
+      } else break;
+    }
+    this.root = splay(z || parent);
+    const newTree = new SplayTree(this);
+    if (z || right) {
+      newTree.root = this.root.right;
+      if (newTree.root) {
+        newTree.root.parent = null;
+        newTree.size = count(newTree.root);
+        this.root.right = null;
+        this.size -= newTree.size;
+      }
+    } else {
+      newTree.root = this.root;
+      newTree.size = this.size;
+      this.root = this.root.left;
+      if (this.root) {
+        this.root.parent = null;
+        this.size = count(this.root);
+        newTree.root.left = null;
+        newTree.size -= this.size;
+      }
+    }
+    return newTree;
+  }
+  joinMaxTreeUnsafe(tree) {
+    if (this.root.right) {
+      this.splay(this.getMax());
+    }
+    this.root.right = tree.root;
+    tree.root.parent = this.root;
+    this.size += tree.size;
+    tree.clear();
+    return this;
+  }
+  join(tree) {
+    if (!tree.root) return this;
+    if (!this.root) {
+      this.root = tree.root;
+      this.size = tree.size;
+      tree.clear();
+      return this;
+    }
+    const leftMax = this.getMax(),
+      rightMin = tree.getMin();
+    if (this.less(leftMax.value, rightMin.value)) {
+      return this.splay(leftMax).joinMaxTreeUnsafe(tree);
+    }
+    for (const value of tree) {
+      this.insert(value);
+    }
+    tree.clear();
+    return this;
+  }
+  [Symbol.iterator]() {
+    let current = this.root ? this.root.getMin() : null;
+    return {
+      next: () => {
+        if (!current) return {
+          done: true
+        };
+        const last = current;
+        if (current.right) {
+          current = current.right.getMin();
+        } else {
+          for (;;) {
+            const parent = current.parent;
+            if (!parent) {
+              current = null;
+              break;
+            }
+            if (parent.left === current) {
+              current = parent;
+              break;
+            }
+            current = parent;
+          }
+        }
+        return {
+          value: last.value
+        };
+      }
+    };
+  }
+  getReverseIterator() {
+    return {
+      [Symbol.iterator]: () => {
+        let current = this.root ? this.root.getMax() : null;
+        return {
+          next: () => {
+            if (!current) return {
+              done: true
+            };
+            const last = current;
+            if (current.left) {
+              current = current.left.getMax();
+            } else {
+              for (;;) {
+                const parent = current.parent;
+                if (!parent) {
+                  current = null;
+                  break;
+                }
+                if (parent.right === current) {
+                  current = parent;
+                  break;
+                }
+                current = parent;
+              }
+            }
+            return {
+              value: last.value
+            };
+          }
+        };
+      }
+    };
+  }
+  static from(values, options) {
+    const tree = new SplayTree(options);
+    for (const value of values) {
+      tree.insert(value);
+    }
+    return tree;
+  }
+}
+exports.SplayTree = SplayTree;
+SplayTree.defaults = {
+  less: defaultLess,
+  compare: null
+};
+var _default = exports.default = SplayTree;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "list-toolkit",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "List-based data structures to organize your objects.",
   "type": "module",
   "exports": {
@@ -33,10 +33,10 @@
   },
   "homepage": "https://github.com/uhop/list-toolkit#readme",
   "devDependencies": {
-    "@babel/cli": "^7.24.7",
-    "@babel/core": "^7.24.7",
-    "@babel/preset-env": "^7.24.7",
-    "tape-six": "^0.9.5"
+    "@babel/cli": "^7.24.8",
+    "@babel/core": "^7.25.2",
+    "@babel/preset-env": "^7.25.4",
+    "tape-six": "^0.9.6"
   },
   "files": [
     "/src",

package/src/heap/min-heap.js

@@ -26,17 +26,10 @@ const down = (array, i, less = defaultLess, n = array.length) => {
   for (;;) {
     const l = (i << 1) + 1;
     if (l >= n) break;
-    let c = l,
+    const r = l + 1,
+      c = r < n && less(array[r], array[l]) ? r : l,
+      iValue = array[i],
       cValue = array[c];
-    const r = c + 1;
-    if (r < n) {
-      const rValue = array[r];
-      if (less(rValue, cValue)) {
-        c = r;
-        cValue = rValue;
-      }
-    }
-    const iValue = array[i];
     if (!less(cValue, iValue)) break;
     array[i] = cValue;
     array[c] = iValue;
@@ -48,6 +41,10 @@ const down = (array, i, less = defaultLess, n = array.length) => {
 export class MinHeap {
   constructor(options, ...args) {
     copyOptions(this, MinHeap.defaults, options);
+    if (typeof this.compare == 'function') {
+      this.less = (a, b) => this.compare(a, b) < 0;
+      this.equal = (a, b) => !this.compare(a, b);
+    }
     this.array = [];
     this.merge(...args);
   }
@@ -83,17 +80,10 @@ export class MinHeap {
     for (let i = 0; ; ) {
       const l = (i << 1) + 1;
       if (l >= n) break;
-      let c = l,
+      const r = l + 1,
+        c = r < n && this.less(this.array[r], this.array[l]) ? r : l,
+        iValue = this.array[i],
         cValue = this.array[c];
-      const r = c + 1;
-      if (r < n) {
-        const rValue = this.array[r];
-        if (this.less(rValue, cValue)) {
-          c = r;
-          cValue = rValue;
-        }
-      }
-      const iValue = this.array[i];
       if (!this.less(cValue, iValue)) break;
       this.array[i] = cValue;
       this.array[c] = iValue;
@@ -127,17 +117,10 @@ export class MinHeap {
     for (let i = 0; ; ) {
       const l = (i << 1) + 1;
       if (l >= n) break;
-      let c = l,
+      const r = l + 1,
+        c = r < n && this.less(this.array[r], this.array[l]) ? r : l,
+        iValue = this.array[i],
         cValue = this.array[c];
-      const r = c + 1;
-      if (r < n) {
-        const rValue = this.array[r];
-        if (this.less(rValue, cValue)) {
-          c = r;
-          cValue = rValue;
-        }
-      }
-      const iValue = this.array[i];
       if (!this.less(cValue, iValue)) break;
       this.array[i] = cValue;
       this.array[c] = iValue;
@@ -155,17 +138,10 @@ export class MinHeap {
     for (let i = 0; ; ) {
       const l = (i << 1) + 1;
       if (l >= n) break;
-      let c = l,
+      const r = l + 1,
+        c = r < n && this.less(this.array[r], this.array[l]) ? r : l,
+        iValue = this.array[i],
         cValue = this.array[c];
-      const r = c + 1;
-      if (r < n) {
-        const rValue = this.array[r];
-        if (this.less(rValue, cValue)) {
-          c = r;
-          cValue = rValue;
-        }
-      }
-      const iValue = this.array[i];
       if (!this.less(cValue, iValue)) break;
       this.array[i] = cValue;
       this.array[c] = iValue;
@@ -257,17 +233,10 @@ export class MinHeap {
       for (let i = j; ; ) {
         const l = (i << 1) + 1;
         if (l >= n) break;
-        let c = l,
+        const r = l + 1,
+          c = r < n && less(array[r], array[l]) ? r : l,
+          iValue = array[i],
           cValue = array[c];
-        const r = c + 1;
-        if (r < n) {
-          const rValue = array[r];
-          if (less(rValue, cValue)) {
-            c = r;
-            cValue = rValue;
-          }
-        }
-        const iValue = array[i];
         if (!less(cValue, iValue)) break;
         array[i] = cValue;
         array[c] = iValue;
@@ -321,7 +290,7 @@ export class MinHeap {
     const last = heapArray.length - 1;
     if (index !== last) {
       const item = heapArray[index],
-        newItem = heapArray[index] = heapArray.pop();
+        newItem = (heapArray[index] = heapArray.pop());
       return MinHeap.updateByIndex(heapArray, index, less(newItem, item), less);
     }
     heapArray.pop();
@@ -360,6 +329,6 @@ export class MinHeap {
   }
 }
 
-MinHeap.defaults = {less: defaultLess, equal: defaultEqual};
+MinHeap.defaults = {less: defaultLess, equal: defaultEqual, compare: null};
 
 export default MinHeap;

package/src/meta-utils.js

@@ -100,7 +100,7 @@ export const addAlias = (object, name, aliases, force) => addDescriptor(object,
 export const addAliases = (object, dict, force) => copyDescriptors(object, object, dict, force);
 
 export const augmentIterator = iterator => {
-  if (!Object.hasOwnProperty(Symbol.iterator)) {
+  if (!iterator.hasOwnProperty(Symbol.iterator)) {
     iterator[Symbol.iterator] = function () {
       return this;
     };

package/src/tree/splay-tree.js

@@ -0,0 +1,378 @@
+'use strict';
+
+import {copyOptions} from '../meta-utils.js';
+
+const defaultLess = (a, b) => a < b;
+
+const zig = tree => {
+  const newTree = tree.left,
+    parent = (newTree.parent = tree.parent);
+  if (parent) {
+    if (parent.left === tree) parent.left = newTree;
+    else parent.right = newTree;
+  }
+  tree.parent = newTree;
+  const child = (tree.left = newTree.right);
+  if (child) child.parent = tree;
+  newTree.right = tree;
+  return newTree;
+};
+
+const zag = tree => {
+  const newTree = tree.right,
+    parent = (newTree.parent = tree.parent);
+  if (parent) {
+    if (parent.left === tree) parent.left = newTree;
+    else parent.right = newTree;
+  }
+  tree.parent = newTree;
+  const child = (tree.right = newTree.left);
+  if (child) child.parent = tree;
+  newTree.left = tree;
+  return newTree;
+};
+
+const splay = node => {
+  while (node.parent) {
+    if (!node.parent.parent) {
+      node.parent.left === node ? zig(node.parent) : zag(node.parent);
+    } else if (node.parent.left === node && node.parent.parent.left === node.parent) {
+      zig(node.parent.parent);
+      zig(node.parent);
+    } else if (node.parent.right === node && node.parent.parent.right === node.parent) {
+      zag(node.parent.parent);
+      zag(node.parent);
+    } else if (node.parent.left === node && node.parent.parent.right === node.parent) {
+      zig(node.parent);
+      zag(node.parent);
+    } else {
+      zag(node.parent);
+      zig(node.parent);
+    }
+  }
+  return node;
+};
+
+const count = tree => (tree ? count(tree.left) + count(tree.right) + 1 : 0);
+
+export class SplayTreeNode {
+  constructor(value) {
+    this.left = this.right = this.parent = null;
+    this.value = value;
+  }
+  getMin() {
+    let z = this;
+    while (z.left) z = z.left;
+    return z;
+  }
+  getMax() {
+    let z = this;
+    while (z.right) z = z.right;
+    return z;
+  }
+}
+
+export class SplayTree {
+  constructor(options) {
+    copyOptions(this, SplayTree.defaults, options);
+    if (typeof this.compare == 'function') {
+      this.less = (a, b) => this.compare(a, b) < 0;
+      this.find = this.findWithCompare;
+      this.insert = this.insertWithCompare;
+      this.splitMaxTree = this.splitMaxTreeWithCompare;
+    }
+    this.root = null;
+    this.size = 0;
+  }
+  get isEmpty() {
+    return !this.root;
+  }
+  get length() {
+    return this.size;
+  }
+  getMin() {
+    return this.root.getMin();
+  }
+  getMax() {
+    return this.root.getMax();
+  }
+  find(value) {
+    for (let z = this.root; z; ) {
+      if (this.less(z.value, value)) z = z.right;
+      else if (this.less(value, z.value)) z = z.left;
+      else return z;
+    }
+    return null;
+  }
+  findWithCompare(value) {
+    for (let z = this.root; z; ) {
+      const cmp = this.compare(value, z.value);
+      if (cmp < 0) z = z.left;
+      else if (cmp > 0) z = z.right;
+      else return z;
+    }
+    return null;
+  }
+  promote(value) {
+    const z = this.find(value);
+    if (z) {
+      this.root = splay(z);
+    }
+    return z;
+  }
+  splay(node) {
+    this.root = splay(node);
+    return this;
+  }
+  insert(value) {
+    let z = this.root,
+      parent = null;
+    while (z) {
+      parent = z;
+      if (this.less(z.value, value)) z = z.right;
+      else if (this.less(value, z.value)) z = z.left;
+      else break;
+    }
+    if (!z) {
+      z = new SplayTreeNode(value);
+      z.parent = parent;
+      if (parent) {
+        if (this.less(parent.value, value)) parent.right = z;
+        else parent.left = z;
+      }
+      ++this.size;
+    }
+    this.root = splay(z);
+    return this;
+  }
+  insertWithCompare(value) {
+    let z = this.root,
+      parent = null;
+    while (z) {
+      parent = z;
+      const cmp = this.compare(value, z.value);
+      if (cmp < 0) z = z.left;
+      else if (cmp > 0) z = z.right;
+      else break;
+    }
+    if (!z) {
+      z = new SplayTreeNode(value);
+      z.parent = parent;
+      if (parent) {
+        if (this.compare(parent.value, value) < 0) parent.right = z;
+        else parent.left = z;
+      }
+      ++this.size;
+    }
+    this.root = splay(z);
+    return this;
+  }
+  remove(value) {
+    const z = this.find(value);
+    if (!z) return this;
+
+    splay(z);
+    this.root = null;
+
+    let maxNode = null;
+    if (z.left) {
+      z.left.parent = null;
+      maxNode = z.left.getMax();
+      this.root = splay(maxNode);
+    }
+    if (z.right) {
+      if (maxNode) maxNode.right = z.right;
+      else this.root = z.right;
+      z.right.parent = maxNode;
+    }
+
+    --this.size;
+
+    return this;
+  }
+  clear() {
+    this.root = null;
+    this.size = 0;
+    return this;
+  }
+  splitMaxTree(value) {
+    if (!this.root) return new SplayTree(this);
+    let z = this.root,
+      parent = null,
+      right;
+    while (z) {
+      parent = z;
+      if (this.less(z.value, value)) {
+        z = z.right;
+        right = true;
+      } else if (this.less(value, z.value)) {
+        z = z.left;
+        right = false;
+      } else break;
+    }
+    this.root = splay(z || parent);
+
+    const newTree = new SplayTree(this);
+    if (z || right) {
+      newTree.root = this.root.right;
+      if (newTree.root) {
+        newTree.root.parent = null;
+        newTree.size = count(newTree.root);
+        this.root.right = null;
+        this.size -= newTree.size;
+      }
+    } else {
+      newTree.root = this.root;
+      newTree.size = this.size;
+      this.root = this.root.left;
+      if (this.root) {
+        this.root.parent = null;
+        this.size = count(this.root);
+        newTree.root.left = null;
+        newTree.size -= this.size;
+      }
+    }
+    return newTree;
+  }
+  splitMaxTreeWithCompare(value) {
+    if (!this.root) return new SplayTree(this);
+    let z = this.root,
+      parent = null,
+      right;
+    while (z) {
+      parent = z;
+      const cmp = this.compare(value, z.value);
+      if (cmp < 0) {
+        z = z.left;
+        right = false;
+      } else if (cmp > 0) {
+        z = z.right;
+        right = true;
+      } else break;
+    }
+    this.root = splay(z || parent);
+
+    const newTree = new SplayTree(this);
+    if (z || right) {
+      newTree.root = this.root.right;
+      if (newTree.root) {
+        newTree.root.parent = null;
+        newTree.size = count(newTree.root);
+        this.root.right = null;
+        this.size -= newTree.size;
+      }
+    } else {
+      newTree.root = this.root;
+      newTree.size = this.size;
+      this.root = this.root.left;
+      if (this.root) {
+        this.root.parent = null;
+        this.size = count(this.root);
+        newTree.root.left = null;
+        newTree.size -= this.size;
+      }
+    }
+    return newTree;
+  }
+  joinMaxTreeUnsafe(tree) {
+    if (this.root.right) {
+      this.splay(this.getMax());
+    }
+
+    this.root.right = tree.root;
+    tree.root.parent = this.root;
+    this.size += tree.size;
+
+    tree.clear();
+
+    return this;
+  }
+  join(tree) {
+    if (!tree.root) return this;
+    if (!this.root) {
+      this.root = tree.root;
+      this.size = tree.size;
+      tree.clear();
+      return this;
+    }
+
+    const leftMax = this.getMax(), rightMin = tree.getMin();
+    if (this.less(leftMax.value, rightMin.value)) {
+      return this.splay(leftMax).joinMaxTreeUnsafe(tree);
+    }
+
+    for (const value of tree) {
+      this.insert(value);
+    }
+
+    tree.clear();
+    return this;
+  }
+  [Symbol.iterator]() {
+    let current = this.root ? this.root.getMin() : null;
+    return {
+      next: () => {
+        if (!current) return {done: true};
+        const last = current;
+        if (current.right) {
+          current = current.right.getMin();
+        } else {
+          for (;;) {
+            const parent = current.parent;
+            if (!parent) {
+              current = null;
+              break;
+            }
+            if (parent.left === current) {
+              current = parent;
+              break;
+            }
+            current = parent;
+          }
+        }
+        return {value: last.value};
+      }
+    };
+  }
+  getReverseIterator() {
+    return {
+      [Symbol.iterator]: () => {
+        let current = this.root ? this.root.getMax() : null;
+        return {
+          next: () => {
+            if (!current) return {done: true};
+            const last = current;
+            if (current.left) {
+              current = current.left.getMax();
+            } else {
+              for (;;) {
+                const parent = current.parent;
+                if (!parent) {
+                  current = null;
+                  break;
+                }
+                if (parent.right === current) {
+                  current = parent;
+                  break;
+                }
+                current = parent;
+              }
+            }
+            return {value: last.value};
+          }
+        };
+      }
+    };
+  }
+  static from(values, options) {
+    const tree = new SplayTree(options);
+    for (const value of values) {
+      tree.insert(value);
+    }
+    return tree;
+  }
+}
+
+SplayTree.defaults = {less: defaultLess, compare: null};
+
+export default SplayTree;